openplanr 2.2640.8 → 2.2640.9

package/lib/host-packages/openai/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/06-react-dom-client-commit-effects.js

@@ -0,0 +1,1551 @@
+
+      function commitHookEffectListMount(flags, finishedWork) {
+        try {
+          var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+          if (null !== lastEffect) {
+            var firstEffect = lastEffect.next;
+            updateQueue = firstEffect;
+            do {
+              if ((updateQueue.tag & flags) === flags) {
+                lastEffect = void 0;
+                var create = updateQueue.create, inst = updateQueue.inst;
+                lastEffect = create();
+                inst.destroy = lastEffect;
+              }
+              updateQueue = updateQueue.next;
+            } while (updateQueue !== firstEffect);
+          }
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+      function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor$jscomp$0) {
+        try {
+          var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
+          if (null !== lastEffect) {
+            var firstEffect = lastEffect.next;
+            updateQueue = firstEffect;
+            do {
+              if ((updateQueue.tag & flags) === flags) {
+                var inst = updateQueue.inst, destroy = inst.destroy;
+                if (void 0 !== destroy) {
+                  inst.destroy = void 0;
+                  lastEffect = finishedWork;
+                  var nearestMountedAncestor = nearestMountedAncestor$jscomp$0, destroy_ = destroy;
+                  try {
+                    destroy_();
+                  } catch (error) {
+                    captureCommitPhaseError(
+                      lastEffect,
+                      nearestMountedAncestor,
+                      error
+                    );
+                  }
+                }
+              }
+              updateQueue = updateQueue.next;
+            } while (updateQueue !== firstEffect);
+          }
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+      function commitClassCallbacks(finishedWork) {
+        var updateQueue = finishedWork.updateQueue;
+        if (null !== updateQueue) {
+          var instance = finishedWork.stateNode;
+          try {
+            commitCallbacks(updateQueue, instance);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+      function safelyCallComponentWillUnmount(current, nearestMountedAncestor, instance) {
+        instance.props = resolveClassComponentProps(
+          current.type,
+          current.memoizedProps
+        );
+        instance.state = current.memoizedState;
+        try {
+          instance.componentWillUnmount();
+        } catch (error) {
+          captureCommitPhaseError(current, nearestMountedAncestor, error);
+        }
+      }
+      function safelyAttachRef(current, nearestMountedAncestor) {
+        try {
+          var ref = current.ref;
+          if (null !== ref) {
+            switch (current.tag) {
+              case 26:
+              case 27:
+              case 5:
+                var instanceToUse = current.stateNode;
+                break;
+              case 30:
+                instanceToUse = current.stateNode;
+                break;
+              default:
+                instanceToUse = current.stateNode;
+            }
+            "function" === typeof ref ? current.refCleanup = ref(instanceToUse) : ref.current = instanceToUse;
+          }
+        } catch (error) {
+          captureCommitPhaseError(current, nearestMountedAncestor, error);
+        }
+      }
+      function safelyDetachRef(current, nearestMountedAncestor) {
+        var ref = current.ref, refCleanup = current.refCleanup;
+        if (null !== ref)
+          if ("function" === typeof refCleanup)
+            try {
+              refCleanup();
+            } catch (error) {
+              captureCommitPhaseError(current, nearestMountedAncestor, error);
+            } finally {
+              current.refCleanup = null, current = current.alternate, null != current && (current.refCleanup = null);
+            }
+          else if ("function" === typeof ref)
+            try {
+              ref(null);
+            } catch (error$140) {
+              captureCommitPhaseError(current, nearestMountedAncestor, error$140);
+            }
+          else ref.current = null;
+      }
+      function commitHostMount(finishedWork) {
+        var type = finishedWork.type, props = finishedWork.memoizedProps, instance = finishedWork.stateNode;
+        try {
+          a: switch (type) {
+            case "button":
+            case "input":
+            case "select":
+            case "textarea":
+              props.autoFocus && instance.focus();
+              break a;
+            case "img":
+              props.src ? instance.src = props.src : props.srcSet && (instance.srcset = props.srcSet);
+          }
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+      function commitHostUpdate(finishedWork, newProps, oldProps) {
+        try {
+          var domElement = finishedWork.stateNode;
+          updateProperties(domElement, finishedWork.type, oldProps, newProps);
+          domElement[internalPropsKey] = newProps;
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+      function isHostParent(fiber) {
+        return 5 === fiber.tag || 3 === fiber.tag || 26 === fiber.tag || 27 === fiber.tag && isSingletonScope(fiber.type) || 4 === fiber.tag;
+      }
+      function getHostSibling(fiber) {
+        a: for (; ; ) {
+          for (; null === fiber.sibling; ) {
+            if (null === fiber.return || isHostParent(fiber.return)) return null;
+            fiber = fiber.return;
+          }
+          fiber.sibling.return = fiber.return;
+          for (fiber = fiber.sibling; 5 !== fiber.tag && 6 !== fiber.tag && 18 !== fiber.tag; ) {
+            if (27 === fiber.tag && isSingletonScope(fiber.type)) continue a;
+            if (fiber.flags & 2) continue a;
+            if (null === fiber.child || 4 === fiber.tag) continue a;
+            else fiber.child.return = fiber, fiber = fiber.child;
+          }
+          if (!(fiber.flags & 2)) return fiber.stateNode;
+        }
+      }
+      function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+        var tag = node.tag;
+        if (5 === tag || 6 === tag)
+          node = node.stateNode, before ? (9 === parent.nodeType ? parent.body : "HTML" === parent.nodeName ? parent.ownerDocument.body : parent).insertBefore(node, before) : (before = 9 === parent.nodeType ? parent.body : "HTML" === parent.nodeName ? parent.ownerDocument.body : parent, before.appendChild(node), parent = parent._reactRootContainer, null !== parent && void 0 !== parent || null !== before.onclick || (before.onclick = noop$1));
+        else if (4 !== tag && (27 === tag && isSingletonScope(node.type) && (parent = node.stateNode, before = null), node = node.child, null !== node))
+          for (insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling; null !== node; )
+            insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;
+      }
+      function insertOrAppendPlacementNode(node, before, parent) {
+        var tag = node.tag;
+        if (5 === tag || 6 === tag)
+          node = node.stateNode, before ? parent.insertBefore(node, before) : parent.appendChild(node);
+        else if (4 !== tag && (27 === tag && isSingletonScope(node.type) && (parent = node.stateNode), node = node.child, null !== node))
+          for (insertOrAppendPlacementNode(node, before, parent), node = node.sibling; null !== node; )
+            insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+      }
+      function commitHostSingletonAcquisition(finishedWork) {
+        var singleton = finishedWork.stateNode, props = finishedWork.memoizedProps;
+        try {
+          for (var type = finishedWork.type, attributes = singleton.attributes; attributes.length; )
+            singleton.removeAttributeNode(attributes[0]);
+          setInitialProperties(singleton, type, props);
+          singleton[internalInstanceKey] = finishedWork;
+          singleton[internalPropsKey] = props;
+        } catch (error) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error);
+        }
+      }
+      var offscreenSubtreeIsHidden = false;
+      var offscreenSubtreeWasHidden = false;
+      var needsFormReset = false;
+      var PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set;
+      var nextEffect = null;
+      function commitBeforeMutationEffects(root2, firstChild) {
+        root2 = root2.containerInfo;
+        eventsEnabled = _enabled;
+        root2 = getActiveElementDeep(root2);
+        if (hasSelectionCapabilities(root2)) {
+          if ("selectionStart" in root2)
+            var JSCompiler_temp = {
+              start: root2.selectionStart,
+              end: root2.selectionEnd
+            };
+          else
+            a: {
+              JSCompiler_temp = (JSCompiler_temp = root2.ownerDocument) && JSCompiler_temp.defaultView || window;
+              var selection = JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
+              if (selection && 0 !== selection.rangeCount) {
+                JSCompiler_temp = selection.anchorNode;
+                var anchorOffset = selection.anchorOffset, focusNode = selection.focusNode;
+                selection = selection.focusOffset;
+                try {
+                  JSCompiler_temp.nodeType, focusNode.nodeType;
+                } catch (e$20) {
+                  JSCompiler_temp = null;
+                  break a;
+                }
+                var length = 0, start2 = -1, end = -1, indexWithinAnchor = 0, indexWithinFocus = 0, node = root2, parentNode = null;
+                b: for (; ; ) {
+                  for (var next; ; ) {
+                    node !== JSCompiler_temp || 0 !== anchorOffset && 3 !== node.nodeType || (start2 = length + anchorOffset);
+                    node !== focusNode || 0 !== selection && 3 !== node.nodeType || (end = length + selection);
+                    3 === node.nodeType && (length += node.nodeValue.length);
+                    if (null === (next = node.firstChild)) break;
+                    parentNode = node;
+                    node = next;
+                  }
+                  for (; ; ) {
+                    if (node === root2) break b;
+                    parentNode === JSCompiler_temp && ++indexWithinAnchor === anchorOffset && (start2 = length);
+                    parentNode === focusNode && ++indexWithinFocus === selection && (end = length);
+                    if (null !== (next = node.nextSibling)) break;
+                    node = parentNode;
+                    parentNode = node.parentNode;
+                  }
+                  node = next;
+                }
+                JSCompiler_temp = -1 === start2 || -1 === end ? null : { start: start2, end };
+              } else JSCompiler_temp = null;
+            }
+          JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
+        } else JSCompiler_temp = null;
+        selectionInformation = { focusedElem: root2, selectionRange: JSCompiler_temp };
+        _enabled = false;
+        for (nextEffect = firstChild; null !== nextEffect; )
+          if (firstChild = nextEffect, root2 = firstChild.child, 0 !== (firstChild.subtreeFlags & 1028) && null !== root2)
+            root2.return = firstChild, nextEffect = root2;
+          else
+            for (; null !== nextEffect; ) {
+              firstChild = nextEffect;
+              focusNode = firstChild.alternate;
+              root2 = firstChild.flags;
+              switch (firstChild.tag) {
+                case 0:
+                  if (0 !== (root2 & 4) && (root2 = firstChild.updateQueue, root2 = null !== root2 ? root2.events : null, null !== root2))
+                    for (JSCompiler_temp = 0; JSCompiler_temp < root2.length; JSCompiler_temp++)
+                      anchorOffset = root2[JSCompiler_temp], anchorOffset.ref.impl = anchorOffset.nextImpl;
+                  break;
+                case 11:
+                case 15:
+                  break;
+                case 1:
+                  if (0 !== (root2 & 1024) && null !== focusNode) {
+                    root2 = void 0;
+                    JSCompiler_temp = firstChild;
+                    anchorOffset = focusNode.memoizedProps;
+                    focusNode = focusNode.memoizedState;
+                    selection = JSCompiler_temp.stateNode;
+                    try {
+                      var resolvedPrevProps = resolveClassComponentProps(
+                        JSCompiler_temp.type,
+                        anchorOffset
+                      );
+                      root2 = selection.getSnapshotBeforeUpdate(
+                        resolvedPrevProps,
+                        focusNode
+                      );
+                      selection.__reactInternalSnapshotBeforeUpdate = root2;
+                    } catch (error) {
+                      captureCommitPhaseError(
+                        JSCompiler_temp,
+                        JSCompiler_temp.return,
+                        error
+                      );
+                    }
+                  }
+                  break;
+                case 3:
+                  if (0 !== (root2 & 1024)) {
+                    if (root2 = firstChild.stateNode.containerInfo, JSCompiler_temp = root2.nodeType, 9 === JSCompiler_temp)
+                      clearContainerSparingly(root2);
+                    else if (1 === JSCompiler_temp)
+                      switch (root2.nodeName) {
+                        case "HEAD":
+                        case "HTML":
+                        case "BODY":
+                          clearContainerSparingly(root2);
+                          break;
+                        default:
+                          root2.textContent = "";
+                      }
+                  }
+                  break;
+                case 5:
+                case 26:
+                case 27:
+                case 6:
+                case 4:
+                case 17:
+                  break;
+                default:
+                  if (0 !== (root2 & 1024)) throw Error(formatProdErrorMessage(163));
+              }
+              root2 = firstChild.sibling;
+              if (null !== root2) {
+                root2.return = firstChild.return;
+                nextEffect = root2;
+                break;
+              }
+              nextEffect = firstChild.return;
+            }
+      }
+      function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
+        var flags = finishedWork.flags;
+        switch (finishedWork.tag) {
+          case 0:
+          case 11:
+          case 15:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            flags & 4 && commitHookEffectListMount(5, finishedWork);
+            break;
+          case 1:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            if (flags & 4)
+              if (finishedRoot = finishedWork.stateNode, null === current)
+                try {
+                  finishedRoot.componentDidMount();
+                } catch (error) {
+                  captureCommitPhaseError(finishedWork, finishedWork.return, error);
+                }
+              else {
+                var prevProps = resolveClassComponentProps(
+                  finishedWork.type,
+                  current.memoizedProps
+                );
+                current = current.memoizedState;
+                try {
+                  finishedRoot.componentDidUpdate(
+                    prevProps,
+                    current,
+                    finishedRoot.__reactInternalSnapshotBeforeUpdate
+                  );
+                } catch (error$139) {
+                  captureCommitPhaseError(
+                    finishedWork,
+                    finishedWork.return,
+                    error$139
+                  );
+                }
+              }
+            flags & 64 && commitClassCallbacks(finishedWork);
+            flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+            break;
+          case 3:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            if (flags & 64 && (finishedRoot = finishedWork.updateQueue, null !== finishedRoot)) {
+              current = null;
+              if (null !== finishedWork.child)
+                switch (finishedWork.child.tag) {
+                  case 27:
+                  case 5:
+                    current = finishedWork.child.stateNode;
+                    break;
+                  case 1:
+                    current = finishedWork.child.stateNode;
+                }
+              try {
+                commitCallbacks(finishedRoot, current);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+            break;
+          case 27:
+            null === current && flags & 4 && commitHostSingletonAcquisition(finishedWork);
+          case 26:
+          case 5:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            null === current && flags & 4 && commitHostMount(finishedWork);
+            flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
+            break;
+          case 12:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            break;
+          case 31:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
+            break;
+          case 13:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+            flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+            flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot && (finishedWork = retryDehydratedSuspenseBoundary.bind(
+              null,
+              finishedWork
+            ), registerSuspenseInstanceRetry(finishedRoot, finishedWork))));
+            break;
+          case 22:
+            flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden;
+            if (!flags) {
+              current = null !== current && null !== current.memoizedState || offscreenSubtreeWasHidden;
+              prevProps = offscreenSubtreeIsHidden;
+              var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+              offscreenSubtreeIsHidden = flags;
+              (offscreenSubtreeWasHidden = current) && !prevOffscreenSubtreeWasHidden ? recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                0 !== (finishedWork.subtreeFlags & 8772)
+              ) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+              offscreenSubtreeIsHidden = prevProps;
+              offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+            }
+            break;
+          case 30:
+            break;
+          default:
+            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
+        }
+      }
+      function detachFiberAfterEffects(fiber) {
+        var alternate = fiber.alternate;
+        null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
+        fiber.child = null;
+        fiber.deletions = null;
+        fiber.sibling = null;
+        5 === fiber.tag && (alternate = fiber.stateNode, null !== alternate && detachDeletedInstance(alternate));
+        fiber.stateNode = null;
+        fiber.return = null;
+        fiber.dependencies = null;
+        fiber.memoizedProps = null;
+        fiber.memoizedState = null;
+        fiber.pendingProps = null;
+        fiber.stateNode = null;
+        fiber.updateQueue = null;
+      }
+      var hostParent = null;
+      var hostParentIsContainer = false;
+      function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
+        for (parent = parent.child; null !== parent; )
+          commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, parent), parent = parent.sibling;
+      }
+      function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
+        if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
+          try {
+            injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
+          } catch (err) {
+          }
+        switch (deletedFiber.tag) {
+          case 26:
+            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            deletedFiber.memoizedState ? deletedFiber.memoizedState.count-- : deletedFiber.stateNode && (deletedFiber = deletedFiber.stateNode, deletedFiber.parentNode.removeChild(deletedFiber));
+            break;
+          case 27:
+            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+            var prevHostParent = hostParent, prevHostParentIsContainer = hostParentIsContainer;
+            isSingletonScope(deletedFiber.type) && (hostParent = deletedFiber.stateNode, hostParentIsContainer = false);
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            releaseSingletonInstance(deletedFiber.stateNode);
+            hostParent = prevHostParent;
+            hostParentIsContainer = prevHostParentIsContainer;
+            break;
+          case 5:
+            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
+          case 6:
+            prevHostParent = hostParent;
+            prevHostParentIsContainer = hostParentIsContainer;
+            hostParent = null;
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            hostParent = prevHostParent;
+            hostParentIsContainer = prevHostParentIsContainer;
+            if (null !== hostParent)
+              if (hostParentIsContainer)
+                try {
+                  (9 === hostParent.nodeType ? hostParent.body : "HTML" === hostParent.nodeName ? hostParent.ownerDocument.body : hostParent).removeChild(deletedFiber.stateNode);
+                } catch (error) {
+                  captureCommitPhaseError(
+                    deletedFiber,
+                    nearestMountedAncestor,
+                    error
+                  );
+                }
+              else
+                try {
+                  hostParent.removeChild(deletedFiber.stateNode);
+                } catch (error) {
+                  captureCommitPhaseError(
+                    deletedFiber,
+                    nearestMountedAncestor,
+                    error
+                  );
+                }
+            break;
+          case 18:
+            null !== hostParent && (hostParentIsContainer ? (finishedRoot = hostParent, clearHydrationBoundary(
+              9 === finishedRoot.nodeType ? finishedRoot.body : "HTML" === finishedRoot.nodeName ? finishedRoot.ownerDocument.body : finishedRoot,
+              deletedFiber.stateNode
+            ), retryIfBlockedOn(finishedRoot)) : clearHydrationBoundary(hostParent, deletedFiber.stateNode));
+            break;
+          case 4:
+            prevHostParent = hostParent;
+            prevHostParentIsContainer = hostParentIsContainer;
+            hostParent = deletedFiber.stateNode.containerInfo;
+            hostParentIsContainer = true;
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            hostParent = prevHostParent;
+            hostParentIsContainer = prevHostParentIsContainer;
+            break;
+          case 0:
+          case 11:
+          case 14:
+          case 15:
+            commitHookEffectListUnmount(2, deletedFiber, nearestMountedAncestor);
+            offscreenSubtreeWasHidden || commitHookEffectListUnmount(4, deletedFiber, nearestMountedAncestor);
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            break;
+          case 1:
+            offscreenSubtreeWasHidden || (safelyDetachRef(deletedFiber, nearestMountedAncestor), prevHostParent = deletedFiber.stateNode, "function" === typeof prevHostParent.componentWillUnmount && safelyCallComponentWillUnmount(
+              deletedFiber,
+              nearestMountedAncestor,
+              prevHostParent
+            ));
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            break;
+          case 21:
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            break;
+          case 22:
+            offscreenSubtreeWasHidden = (prevHostParent = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState;
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+            offscreenSubtreeWasHidden = prevHostParent;
+            break;
+          default:
+            recursivelyTraverseDeletionEffects(
+              finishedRoot,
+              nearestMountedAncestor,
+              deletedFiber
+            );
+        }
+      }
+      function commitActivityHydrationCallbacks(finishedRoot, finishedWork) {
+        if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot))) {
+          finishedRoot = finishedRoot.dehydrated;
+          try {
+            retryIfBlockedOn(finishedRoot);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+        }
+      }
+      function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
+        if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot))))
+          try {
+            retryIfBlockedOn(finishedRoot);
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+      }
+      function getRetryCache(finishedWork) {
+        switch (finishedWork.tag) {
+          case 31:
+          case 13:
+          case 19:
+            var retryCache = finishedWork.stateNode;
+            null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
+            return retryCache;
+          case 22:
+            return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
+          default:
+            throw Error(formatProdErrorMessage(435, finishedWork.tag));
+        }
+      }
+      function attachSuspenseRetryListeners(finishedWork, wakeables) {
+        var retryCache = getRetryCache(finishedWork);
+        wakeables.forEach(function(wakeable) {
+          if (!retryCache.has(wakeable)) {
+            retryCache.add(wakeable);
+            var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
+            wakeable.then(retry, retry);
+          }
+        });
+      }
+      function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
+        var deletions = parentFiber.deletions;
+        if (null !== deletions)
+          for (var i = 0; i < deletions.length; i++) {
+            var childToDelete = deletions[i], root2 = root$jscomp$0, returnFiber = parentFiber, parent = returnFiber;
+            a: for (; null !== parent; ) {
+              switch (parent.tag) {
+                case 27:
+                  if (isSingletonScope(parent.type)) {
+                    hostParent = parent.stateNode;
+                    hostParentIsContainer = false;
+                    break a;
+                  }
+                  break;
+                case 5:
+                  hostParent = parent.stateNode;
+                  hostParentIsContainer = false;
+                  break a;
+                case 3:
+                case 4:
+                  hostParent = parent.stateNode.containerInfo;
+                  hostParentIsContainer = true;
+                  break a;
+              }
+              parent = parent.return;
+            }
+            if (null === hostParent) throw Error(formatProdErrorMessage(160));
+            commitDeletionEffectsOnFiber(root2, returnFiber, childToDelete);
+            hostParent = null;
+            hostParentIsContainer = false;
+            root2 = childToDelete.alternate;
+            null !== root2 && (root2.return = null);
+            childToDelete.return = null;
+          }
+        if (parentFiber.subtreeFlags & 13886)
+          for (parentFiber = parentFiber.child; null !== parentFiber; )
+            commitMutationEffectsOnFiber(parentFiber, root$jscomp$0), parentFiber = parentFiber.sibling;
+      }
+      var currentHoistableRoot = null;
+      function commitMutationEffectsOnFiber(finishedWork, root2) {
+        var current = finishedWork.alternate, flags = finishedWork.flags;
+        switch (finishedWork.tag) {
+          case 0:
+          case 11:
+          case 14:
+          case 15:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 4 && (commitHookEffectListUnmount(3, finishedWork, finishedWork.return), commitHookEffectListMount(3, finishedWork), commitHookEffectListUnmount(5, finishedWork, finishedWork.return));
+            break;
+          case 1:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+            flags & 64 && offscreenSubtreeIsHidden && (finishedWork = finishedWork.updateQueue, null !== finishedWork && (flags = finishedWork.callbacks, null !== flags && (current = finishedWork.shared.hiddenCallbacks, finishedWork.shared.hiddenCallbacks = null === current ? flags : current.concat(flags))));
+            break;
+          case 26:
+            var hoistableRoot = currentHoistableRoot;
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+            if (flags & 4) {
+              var currentResource = null !== current ? current.memoizedState : null;
+              flags = finishedWork.memoizedState;
+              if (null === current)
+                if (null === flags)
+                  if (null === finishedWork.stateNode) {
+                    a: {
+                      flags = finishedWork.type;
+                      current = finishedWork.memoizedProps;
+                      hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+                      b: switch (flags) {
+                        case "title":
+                          currentResource = hoistableRoot.getElementsByTagName("title")[0];
+                          if (!currentResource || currentResource[internalHoistableMarker] || currentResource[internalInstanceKey] || "http://www.w3.org/2000/svg" === currentResource.namespaceURI || currentResource.hasAttribute("itemprop"))
+                            currentResource = hoistableRoot.createElement(flags), hoistableRoot.head.insertBefore(
+                              currentResource,
+                              hoistableRoot.querySelector("head > title")
+                            );
+                          setInitialProperties(currentResource, flags, current);
+                          currentResource[internalInstanceKey] = finishedWork;
+                          markNodeAsHoistable(currentResource);
+                          flags = currentResource;
+                          break a;
+                        case "link":
+                          var maybeNodes = getHydratableHoistableCache(
+                            "link",
+                            "href",
+                            hoistableRoot
+                          ).get(flags + (current.href || ""));
+                          if (maybeNodes) {
+                            for (var i = 0; i < maybeNodes.length; i++)
+                              if (currentResource = maybeNodes[i], currentResource.getAttribute("href") === (null == current.href || "" === current.href ? null : current.href) && currentResource.getAttribute("rel") === (null == current.rel ? null : current.rel) && currentResource.getAttribute("title") === (null == current.title ? null : current.title) && currentResource.getAttribute("crossorigin") === (null == current.crossOrigin ? null : current.crossOrigin)) {
+                                maybeNodes.splice(i, 1);
+                                break b;
+                              }
+                          }
+                          currentResource = hoistableRoot.createElement(flags);
+                          setInitialProperties(currentResource, flags, current);
+                          hoistableRoot.head.appendChild(currentResource);
+                          break;
+                        case "meta":
+                          if (maybeNodes = getHydratableHoistableCache(
+                            "meta",
+                            "content",
+                            hoistableRoot
+                          ).get(flags + (current.content || ""))) {
+                            for (i = 0; i < maybeNodes.length; i++)
+                              if (currentResource = maybeNodes[i], currentResource.getAttribute("content") === (null == current.content ? null : "" + current.content) && currentResource.getAttribute("name") === (null == current.name ? null : current.name) && currentResource.getAttribute("property") === (null == current.property ? null : current.property) && currentResource.getAttribute("http-equiv") === (null == current.httpEquiv ? null : current.httpEquiv) && currentResource.getAttribute("charset") === (null == current.charSet ? null : current.charSet)) {
+                                maybeNodes.splice(i, 1);
+                                break b;
+                              }
+                          }
+                          currentResource = hoistableRoot.createElement(flags);
+                          setInitialProperties(currentResource, flags, current);
+                          hoistableRoot.head.appendChild(currentResource);
+                          break;
+                        default:
+                          throw Error(formatProdErrorMessage(468, flags));
+                      }
+                      currentResource[internalInstanceKey] = finishedWork;
+                      markNodeAsHoistable(currentResource);
+                      flags = currentResource;
+                    }
+                    finishedWork.stateNode = flags;
+                  } else
+                    mountHoistable(
+                      hoistableRoot,
+                      finishedWork.type,
+                      finishedWork.stateNode
+                    );
+                else
+                  finishedWork.stateNode = acquireResource(
+                    hoistableRoot,
+                    flags,
+                    finishedWork.memoizedProps
+                  );
+              else
+                currentResource !== flags ? (null === currentResource ? null !== current.stateNode && (current = current.stateNode, current.parentNode.removeChild(current)) : currentResource.count--, null === flags ? mountHoistable(
+                  hoistableRoot,
+                  finishedWork.type,
+                  finishedWork.stateNode
+                ) : acquireResource(
+                  hoistableRoot,
+                  flags,
+                  finishedWork.memoizedProps
+                )) : null === flags && null !== finishedWork.stateNode && commitHostUpdate(
+                  finishedWork,
+                  finishedWork.memoizedProps,
+                  current.memoizedProps
+                );
+            }
+            break;
+          case 27:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+            null !== current && flags & 4 && commitHostUpdate(
+              finishedWork,
+              finishedWork.memoizedProps,
+              current.memoizedProps
+            );
+            break;
+          case 5:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 512 && (offscreenSubtreeWasHidden || null === current || safelyDetachRef(current, current.return));
+            if (finishedWork.flags & 32) {
+              hoistableRoot = finishedWork.stateNode;
+              try {
+                setTextContent(hoistableRoot, "");
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+            flags & 4 && null != finishedWork.stateNode && (hoistableRoot = finishedWork.memoizedProps, commitHostUpdate(
+              finishedWork,
+              hoistableRoot,
+              null !== current ? current.memoizedProps : hoistableRoot
+            ));
+            flags & 1024 && (needsFormReset = true);
+            break;
+          case 6:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            if (flags & 4) {
+              if (null === finishedWork.stateNode)
+                throw Error(formatProdErrorMessage(162));
+              flags = finishedWork.memoizedProps;
+              current = finishedWork.stateNode;
+              try {
+                current.nodeValue = flags;
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            }
+            break;
+          case 3:
+            tagCaches = null;
+            hoistableRoot = currentHoistableRoot;
+            currentHoistableRoot = getHoistableRoot(root2.containerInfo);
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            currentHoistableRoot = hoistableRoot;
+            commitReconciliationEffects(finishedWork);
+            if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
+              try {
+                retryIfBlockedOn(root2.containerInfo);
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            needsFormReset && (needsFormReset = false, recursivelyResetForms(finishedWork));
+            break;
+          case 4:
+            flags = currentHoistableRoot;
+            currentHoistableRoot = getHoistableRoot(
+              finishedWork.stateNode.containerInfo
+            );
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            currentHoistableRoot = flags;
+            break;
+          case 12:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            break;
+          case 31:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+            break;
+          case 13:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            finishedWork.child.flags & 8192 && null !== finishedWork.memoizedState !== (null !== current && null !== current.memoizedState) && (globalMostRecentFallbackTime = now());
+            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+            break;
+          case 22:
+            hoistableRoot = null !== finishedWork.memoizedState;
+            var wasHidden = null !== current && null !== current.memoizedState, prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden, prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || hoistableRoot;
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
+            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
+            commitReconciliationEffects(finishedWork);
+            if (flags & 8192)
+              a: for (root2 = finishedWork.stateNode, root2._visibility = hoistableRoot ? root2._visibility & -2 : root2._visibility | 1, hoistableRoot && (null === current || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || recursivelyTraverseDisappearLayoutEffects(finishedWork)), current = null, root2 = finishedWork; ; ) {
+                if (5 === root2.tag || 26 === root2.tag) {
+                  if (null === current) {
+                    wasHidden = current = root2;
+                    try {
+                      if (currentResource = wasHidden.stateNode, hoistableRoot)
+                        maybeNodes = currentResource.style, "function" === typeof maybeNodes.setProperty ? maybeNodes.setProperty("display", "none", "important") : maybeNodes.display = "none";
+                      else {
+                        i = wasHidden.stateNode;
+                        var styleProp = wasHidden.memoizedProps.style, display = void 0 !== styleProp && null !== styleProp && styleProp.hasOwnProperty("display") ? styleProp.display : null;
+                        i.style.display = null == display || "boolean" === typeof display ? "" : ("" + display).trim();
+                      }
+                    } catch (error) {
+                      captureCommitPhaseError(wasHidden, wasHidden.return, error);
+                    }
+                  }
+                } else if (6 === root2.tag) {
+                  if (null === current) {
+                    wasHidden = root2;
+                    try {
+                      wasHidden.stateNode.nodeValue = hoistableRoot ? "" : wasHidden.memoizedProps;
+                    } catch (error) {
+                      captureCommitPhaseError(wasHidden, wasHidden.return, error);
+                    }
+                  }
+                } else if (18 === root2.tag) {
+                  if (null === current) {
+                    wasHidden = root2;
+                    try {
+                      var instance = wasHidden.stateNode;
+                      hoistableRoot ? hideOrUnhideDehydratedBoundary(instance, true) : hideOrUnhideDehydratedBoundary(wasHidden.stateNode, false);
+                    } catch (error) {
+                      captureCommitPhaseError(wasHidden, wasHidden.return, error);
+                    }
+                  }
+                } else if ((22 !== root2.tag && 23 !== root2.tag || null === root2.memoizedState || root2 === finishedWork) && null !== root2.child) {
+                  root2.child.return = root2;
+                  root2 = root2.child;
+                  continue;
+                }
+                if (root2 === finishedWork) break a;
+                for (; null === root2.sibling; ) {
+                  if (null === root2.return || root2.return === finishedWork) break a;
+                  current === root2 && (current = null);
+                  root2 = root2.return;
+                }
+                current === root2 && (current = null);
+                root2.sibling.return = root2.return;
+                root2 = root2.sibling;
+              }
+            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (current = flags.retryQueue, null !== current && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, current))));
+            break;
+          case 19:
+            recursivelyTraverseMutationEffects(root2, finishedWork);
+            commitReconciliationEffects(finishedWork);
+            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
+            break;
+          case 30:
+            break;
+          case 21:
+            break;
+          default:
+            recursivelyTraverseMutationEffects(root2, finishedWork), commitReconciliationEffects(finishedWork);
+        }
+      }
+      function commitReconciliationEffects(finishedWork) {
+        var flags = finishedWork.flags;
+        if (flags & 2) {
+          try {
+            for (var hostParentFiber, parentFiber = finishedWork.return; null !== parentFiber; ) {
+              if (isHostParent(parentFiber)) {
+                hostParentFiber = parentFiber;
+                break;
+              }
+              parentFiber = parentFiber.return;
+            }
+            if (null == hostParentFiber) throw Error(formatProdErrorMessage(160));
+            switch (hostParentFiber.tag) {
+              case 27:
+                var parent = hostParentFiber.stateNode, before = getHostSibling(finishedWork);
+                insertOrAppendPlacementNode(finishedWork, before, parent);
+                break;
+              case 5:
+                var parent$141 = hostParentFiber.stateNode;
+                hostParentFiber.flags & 32 && (setTextContent(parent$141, ""), hostParentFiber.flags &= -33);
+                var before$142 = getHostSibling(finishedWork);
+                insertOrAppendPlacementNode(finishedWork, before$142, parent$141);
+                break;
+              case 3:
+              case 4:
+                var parent$143 = hostParentFiber.stateNode.containerInfo, before$144 = getHostSibling(finishedWork);
+                insertOrAppendPlacementNodeIntoContainer(
+                  finishedWork,
+                  before$144,
+                  parent$143
+                );
+                break;
+              default:
+                throw Error(formatProdErrorMessage(161));
+            }
+          } catch (error) {
+            captureCommitPhaseError(finishedWork, finishedWork.return, error);
+          }
+          finishedWork.flags &= -3;
+        }
+        flags & 4096 && (finishedWork.flags &= -4097);
+      }
+      function recursivelyResetForms(parentFiber) {
+        if (parentFiber.subtreeFlags & 1024)
+          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+            var fiber = parentFiber;
+            recursivelyResetForms(fiber);
+            5 === fiber.tag && fiber.flags & 1024 && fiber.stateNode.reset();
+            parentFiber = parentFiber.sibling;
+          }
+      }
+      function recursivelyTraverseLayoutEffects(root2, parentFiber) {
+        if (parentFiber.subtreeFlags & 8772)
+          for (parentFiber = parentFiber.child; null !== parentFiber; )
+            commitLayoutEffectOnFiber(root2, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
+      }
+      function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
+        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+          var finishedWork = parentFiber;
+          switch (finishedWork.tag) {
+            case 0:
+            case 11:
+            case 14:
+            case 15:
+              commitHookEffectListUnmount(4, finishedWork, finishedWork.return);
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              break;
+            case 1:
+              safelyDetachRef(finishedWork, finishedWork.return);
+              var instance = finishedWork.stateNode;
+              "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(
+                finishedWork,
+                finishedWork.return,
+                instance
+              );
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              break;
+            case 27:
+              releaseSingletonInstance(finishedWork.stateNode);
+            case 26:
+            case 5:
+              safelyDetachRef(finishedWork, finishedWork.return);
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              break;
+            case 22:
+              null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              break;
+            case 30:
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+              break;
+            default:
+              recursivelyTraverseDisappearLayoutEffects(finishedWork);
+          }
+          parentFiber = parentFiber.sibling;
+        }
+      }
+      function recursivelyTraverseReappearLayoutEffects(finishedRoot$jscomp$0, parentFiber, includeWorkInProgressEffects) {
+        includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
+        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+          var current = parentFiber.alternate, finishedRoot = finishedRoot$jscomp$0, finishedWork = parentFiber, flags = finishedWork.flags;
+          switch (finishedWork.tag) {
+            case 0:
+            case 11:
+            case 15:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              commitHookEffectListMount(4, finishedWork);
+              break;
+            case 1:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              current = finishedWork;
+              finishedRoot = current.stateNode;
+              if ("function" === typeof finishedRoot.componentDidMount)
+                try {
+                  finishedRoot.componentDidMount();
+                } catch (error) {
+                  captureCommitPhaseError(current, current.return, error);
+                }
+              current = finishedWork;
+              finishedRoot = current.updateQueue;
+              if (null !== finishedRoot) {
+                var instance = current.stateNode;
+                try {
+                  var hiddenCallbacks = finishedRoot.shared.hiddenCallbacks;
+                  if (null !== hiddenCallbacks)
+                    for (finishedRoot.shared.hiddenCallbacks = null, finishedRoot = 0; finishedRoot < hiddenCallbacks.length; finishedRoot++)
+                      callCallback(hiddenCallbacks[finishedRoot], instance);
+                } catch (error) {
+                  captureCommitPhaseError(current, current.return, error);
+                }
+              }
+              includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
+              safelyAttachRef(finishedWork, finishedWork.return);
+              break;
+            case 27:
+              commitHostSingletonAcquisition(finishedWork);
+            case 26:
+            case 5:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              includeWorkInProgressEffects && null === current && flags & 4 && commitHostMount(finishedWork);
+              safelyAttachRef(finishedWork, finishedWork.return);
+              break;
+            case 12:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              break;
+            case 31:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              includeWorkInProgressEffects && flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
+              break;
+            case 13:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              includeWorkInProgressEffects && flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
+              break;
+            case 22:
+              null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+              safelyAttachRef(finishedWork, finishedWork.return);
+              break;
+            case 30:
+              break;
+            default:
+              recursivelyTraverseReappearLayoutEffects(
+                finishedRoot,
+                finishedWork,
+                includeWorkInProgressEffects
+              );
+          }
+          parentFiber = parentFiber.sibling;
+        }
+      }
+      function commitOffscreenPassiveMountEffects(current, finishedWork) {
+        var previousCache = null;
+        null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (previousCache = current.memoizedState.cachePool.pool);
+        current = null;
+        null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current = finishedWork.memoizedState.cachePool.pool);
+        current !== previousCache && (null != current && current.refCount++, null != previousCache && releaseCache(previousCache));
+      }
+      function commitCachePassiveMountEffect(current, finishedWork) {
+        current = null;
+        null !== finishedWork.alternate && (current = finishedWork.alternate.memoizedState.cache);
+        finishedWork = finishedWork.memoizedState.cache;
+        finishedWork !== current && (finishedWork.refCount++, null != current && releaseCache(current));
+      }
+      function recursivelyTraversePassiveMountEffects(root2, parentFiber, committedLanes, committedTransitions) {
+        if (parentFiber.subtreeFlags & 10256)
+          for (parentFiber = parentFiber.child; null !== parentFiber; )
+            commitPassiveMountOnFiber(
+              root2,
+              parentFiber,
+              committedLanes,
+              committedTransitions
+            ), parentFiber = parentFiber.sibling;
+      }
+      function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions) {
+        var flags = finishedWork.flags;
+        switch (finishedWork.tag) {
+          case 0:
+          case 11:
+          case 15:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+            flags & 2048 && commitHookEffectListMount(9, finishedWork);
+            break;
+          case 1:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+            break;
+          case 3:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+            flags & 2048 && (finishedRoot = null, null !== finishedWork.alternate && (finishedRoot = finishedWork.alternate.memoizedState.cache), finishedWork = finishedWork.memoizedState.cache, finishedWork !== finishedRoot && (finishedWork.refCount++, null != finishedRoot && releaseCache(finishedRoot)));
+            break;
+          case 12:
+            if (flags & 2048) {
+              recursivelyTraversePassiveMountEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions
+              );
+              finishedRoot = finishedWork.stateNode;
+              try {
+                var _finishedWork$memoize2 = finishedWork.memoizedProps, id = _finishedWork$memoize2.id, onPostCommit = _finishedWork$memoize2.onPostCommit;
+                "function" === typeof onPostCommit && onPostCommit(
+                  id,
+                  null === finishedWork.alternate ? "mount" : "update",
+                  finishedRoot.passiveEffectDuration,
+                  -0
+                );
+              } catch (error) {
+                captureCommitPhaseError(finishedWork, finishedWork.return, error);
+              }
+            } else
+              recursivelyTraversePassiveMountEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions
+              );
+            break;
+          case 31:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+            break;
+          case 13:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+            break;
+          case 23:
+            break;
+          case 22:
+            _finishedWork$memoize2 = finishedWork.stateNode;
+            id = finishedWork.alternate;
+            null !== finishedWork.memoizedState ? _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            ) : recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork) : _finishedWork$memoize2._visibility & 2 ? recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            ) : (_finishedWork$memoize2._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions,
+              0 !== (finishedWork.subtreeFlags & 10256) || false
+            ));
+            flags & 2048 && commitOffscreenPassiveMountEffects(id, finishedWork);
+            break;
+          case 24:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+            flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+            break;
+          default:
+            recursivelyTraversePassiveMountEffects(
+              finishedRoot,
+              finishedWork,
+              committedLanes,
+              committedTransitions
+            );
+        }
+      }
+      function recursivelyTraverseReconnectPassiveEffects(finishedRoot$jscomp$0, parentFiber, committedLanes$jscomp$0, committedTransitions$jscomp$0, includeWorkInProgressEffects) {
+        includeWorkInProgressEffects = includeWorkInProgressEffects && (0 !== (parentFiber.subtreeFlags & 10256) || false);
+        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+          var finishedRoot = finishedRoot$jscomp$0, finishedWork = parentFiber, committedLanes = committedLanes$jscomp$0, committedTransitions = committedTransitions$jscomp$0, flags = finishedWork.flags;
+          switch (finishedWork.tag) {
+            case 0:
+            case 11:
+            case 15:
+              recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              );
+              commitHookEffectListMount(8, finishedWork);
+              break;
+            case 23:
+              break;
+            case 22:
+              var instance = finishedWork.stateNode;
+              null !== finishedWork.memoizedState ? instance._visibility & 2 ? recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              ) : recursivelyTraverseAtomicPassiveEffects(
+                finishedRoot,
+                finishedWork
+              ) : (instance._visibility |= 2, recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              ));
+              includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(
+                finishedWork.alternate,
+                finishedWork
+              );
+              break;
+            case 24:
+              recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              );
+              includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+              break;
+            default:
+              recursivelyTraverseReconnectPassiveEffects(
+                finishedRoot,
+                finishedWork,
+                committedLanes,
+                committedTransitions,
+                includeWorkInProgressEffects
+              );
+          }
+          parentFiber = parentFiber.sibling;
+        }
+      }
+      function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber) {
+        if (parentFiber.subtreeFlags & 10256)
+          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+            var finishedRoot = finishedRoot$jscomp$0, finishedWork = parentFiber, flags = finishedWork.flags;
+            switch (finishedWork.tag) {
+              case 22:
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+                flags & 2048 && commitOffscreenPassiveMountEffects(
+                  finishedWork.alternate,
+                  finishedWork
+                );
+                break;
+              case 24:
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+                flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
+                break;
+              default:
+                recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork);
+            }
+            parentFiber = parentFiber.sibling;
+          }
+      }
+      var suspenseyCommitFlag = 8192;
+      function recursivelyAccumulateSuspenseyCommit(parentFiber, committedLanes, suspendedState) {
+        if (parentFiber.subtreeFlags & suspenseyCommitFlag)
+          for (parentFiber = parentFiber.child; null !== parentFiber; )
+            accumulateSuspenseyCommitOnFiber(
+              parentFiber,
+              committedLanes,
+              suspendedState
+            ), parentFiber = parentFiber.sibling;
+      }
+      function accumulateSuspenseyCommitOnFiber(fiber, committedLanes, suspendedState) {
+        switch (fiber.tag) {
+          case 26:
+            recursivelyAccumulateSuspenseyCommit(
+              fiber,
+              committedLanes,
+              suspendedState
+            );
+            fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && suspendResource(
+              suspendedState,
+              currentHoistableRoot,
+              fiber.memoizedState,
+              fiber.memoizedProps
+            );
+            break;
+          case 5:
+            recursivelyAccumulateSuspenseyCommit(
+              fiber,
+              committedLanes,
+              suspendedState
+            );
+            break;
+          case 3:
+          case 4:
+            var previousHoistableRoot = currentHoistableRoot;
+            currentHoistableRoot = getHoistableRoot(fiber.stateNode.containerInfo);
+            recursivelyAccumulateSuspenseyCommit(
+              fiber,
+              committedLanes,
+              suspendedState
+            );
+            currentHoistableRoot = previousHoistableRoot;
+            break;
+          case 22:
+            null === fiber.memoizedState && (previousHoistableRoot = fiber.alternate, null !== previousHoistableRoot && null !== previousHoistableRoot.memoizedState ? (previousHoistableRoot = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(
+              fiber,
+              committedLanes,
+              suspendedState
+            ), suspenseyCommitFlag = previousHoistableRoot) : recursivelyAccumulateSuspenseyCommit(
+              fiber,
+              committedLanes,
+              suspendedState
+            ));
+            break;
+          default:
+            recursivelyAccumulateSuspenseyCommit(
+              fiber,
+              committedLanes,
+              suspendedState
+            );
+        }
+      }
+      function detachAlternateSiblings(parentFiber) {
+        var previousFiber = parentFiber.alternate;
+        if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
+          previousFiber.child = null;
+          do
+            previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber;
+          while (null !== parentFiber);
+        }
+      }
+      function recursivelyTraversePassiveUnmountEffects(parentFiber) {
+        var deletions = parentFiber.deletions;
+        if (0 !== (parentFiber.flags & 16)) {
+          if (null !== deletions)
+            for (var i = 0; i < deletions.length; i++) {
+              var childToDelete = deletions[i];
+              nextEffect = childToDelete;
+              commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+                childToDelete,
+                parentFiber
+              );
+            }
+          detachAlternateSiblings(parentFiber);
+        }
+        if (parentFiber.subtreeFlags & 10256)
+          for (parentFiber = parentFiber.child; null !== parentFiber; )
+            commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
+      }
+      function commitPassiveUnmountOnFiber(finishedWork) {
+        switch (finishedWork.tag) {
+          case 0:
+          case 11:
+          case 15:
+            recursivelyTraversePassiveUnmountEffects(finishedWork);
+            finishedWork.flags & 2048 && commitHookEffectListUnmount(9, finishedWork, finishedWork.return);
+            break;
+          case 3:
+            recursivelyTraversePassiveUnmountEffects(finishedWork);
+            break;
+          case 12:
+            recursivelyTraversePassiveUnmountEffects(finishedWork);
+            break;
+          case 22:
+            var instance = finishedWork.stateNode;
+            null !== finishedWork.memoizedState && instance._visibility & 2 && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (instance._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(finishedWork)) : recursivelyTraversePassiveUnmountEffects(finishedWork);
+            break;
+          default:
+            recursivelyTraversePassiveUnmountEffects(finishedWork);
+        }
+      }
+      function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
+        var deletions = parentFiber.deletions;
+        if (0 !== (parentFiber.flags & 16)) {
+          if (null !== deletions)
+            for (var i = 0; i < deletions.length; i++) {
+              var childToDelete = deletions[i];
+              nextEffect = childToDelete;
+              commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
+                childToDelete,
+                parentFiber
+              );
+            }
+          detachAlternateSiblings(parentFiber);
+        }
+        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
+          deletions = parentFiber;
+          switch (deletions.tag) {
+            case 0:
+            case 11:
+            case 15:
+              commitHookEffectListUnmount(8, deletions, deletions.return);
+              recursivelyTraverseDisconnectPassiveEffects(deletions);
+              break;
+            case 22:
+              i = deletions.stateNode;
+              i._visibility & 2 && (i._visibility &= -3, recursivelyTraverseDisconnectPassiveEffects(deletions));
+              break;
+            default:
+              recursivelyTraverseDisconnectPassiveEffects(deletions);
+          }
+          parentFiber = parentFiber.sibling;
+        }
+      }
+      function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor) {
+        for (; null !== nextEffect; ) {
+          var fiber = nextEffect;
+          switch (fiber.tag) {
+            case 0:
+            case 11:
+            case 15:
+              commitHookEffectListUnmount(8, fiber, nearestMountedAncestor);
+              break;
+            case 23:
+            case 22:
+              if (null !== fiber.memoizedState && null !== fiber.memoizedState.cachePool) {
+                var cache = fiber.memoizedState.cachePool.pool;
+                null != cache && cache.refCount++;
+              }
+              break;
+            case 24:
+              releaseCache(fiber.memoizedState.cache);
+          }
+          cache = fiber.child;
+          if (null !== cache) cache.return = fiber, nextEffect = cache;
+          else
+            a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
+              cache = nextEffect;
+              var sibling = cache.sibling, returnFiber = cache.return;
+              detachFiberAfterEffects(cache);
+              if (cache === fiber) {
+                nextEffect = null;
+                break a;
+              }
+              if (null !== sibling) {
+                sibling.return = returnFiber;
+                nextEffect = sibling;
+                break a;
+              }
+              nextEffect = returnFiber;
+            }
+        }
+      }
+      var DefaultAsyncDispatcher = {
+        getCacheForType: function(resourceType) {
+          var cache = readContext(CacheContext), cacheForType = cache.data.get(resourceType);
+          void 0 === cacheForType && (cacheForType = resourceType(), cache.data.set(resourceType, cacheForType));
+          return cacheForType;
+        },
+        cacheSignal: function() {
+          return readContext(CacheContext).controller.signal;
+        }
+      };
+      var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;