function updateSuspenseComponent(
  current,
  workInProgress,
  renderExpirationTime,
) {
  const mode = workInProgress.mode
  const nextProps = workInProgress.pendingProps

  // We should attempt to render the primary children unless this boundary
  // already suspended during this render (`alreadyCaptured` is true).
  let nextState: SuspenseState | null = workInProgress.memoizedState
  if (nextState === null) {
    // An empty suspense state means this boundary has not yet timed out.
  } else {
    if (!nextState.alreadyCaptured) {
      // Since we haven't already suspended during this commit, clear the
      // existing suspense state. We'll try rendering again.
      nextState = null
    } else {
      // Something in this boundary's subtree already suspended. Switch to
      // rendering the fallback children. Set `alreadyCaptured` to true.
      if (current !== null && nextState === current.memoizedState) {
        // Create a new suspense state to avoid mutating the current tree's.
        nextState = {
          alreadyCaptured: true,
          didTimeout: true,
          timedOutAt: nextState.timedOutAt,
        }
      } else {
        // Already have a clone, so it's safe to mutate.
        nextState.alreadyCaptured = true
        nextState.didTimeout = true
      }
    }
  }
  const nextDidTimeout = nextState !== null && nextState.didTimeout

  let child
  let next
  if (current === null) {
    if (nextDidTimeout) {
      // Mount separate fragments for primary and fallback children.
      const nextFallbackChildren = nextProps.fallback
      const primaryChildFragment = createFiberFromFragment(
        null,
        mode,
        NoWork,
        null,
      )
      const fallbackChildFragment = createFiberFromFragment(
        nextFallbackChildren,
        mode,
        renderExpirationTime,
        null,
      )
      primaryChildFragment.sibling = fallbackChildFragment
      child = primaryChildFragment
      // Skip the primary children, and continue working on the
      // fallback children.
      next = fallbackChildFragment
      child.return = next.return = workInProgress
    } else {
      // Mount the primary children without an intermediate fragment fiber.
      const nextPrimaryChildren = nextProps.children
      child = next = mountChildFibers(
        workInProgress,
        null,
        nextPrimaryChildren,
        renderExpirationTime,
      )
    }
  } else {
    // This is an update. This branch is more complicated because we need to
    // ensure the state of the primary children is IncompleteClassComponent.
    const prevState = current.memoizedState
    const prevDidTimeout = prevState !== null && prevState.didTimeout
    if (prevDidTimeout) {
      // The current tree already timed out. That means each child set is
      // wrapped in a fragment fiber.
      const currentPrimaryChildFragment: Fiber = (current.child: any)
      const currentFallbackChildFragment: Fiber = (currentPrimaryChildFragment.sibling: any)
      if (nextDidTimeout) {
        // Still timed out. Reuse the current primary children by cloning
        // its fragment. We're going to skip over these entirely.
        const nextFallbackChildren = nextProps.fallback
        const primaryChildFragment = createWorkInProgress(
          currentPrimaryChildFragment,
          currentPrimaryChildFragment.pendingProps,
          NoWork,
        )
        primaryChildFragment.effectTag |= Placement
        // Clone the fallback child fragment, too. These we'll continue
        // working on.
        const fallbackChildFragment = (primaryChildFragment.sibling = createWorkInProgress(
          currentFallbackChildFragment,
          nextFallbackChildren,
          currentFallbackChildFragment.expirationTime,
        ))
        fallbackChildFragment.effectTag |= Placement
        child = primaryChildFragment
        primaryChildFragment.childExpirationTime = NoWork
        // Skip the primary children, and continue working on the
        // fallback children.
        next = fallbackChildFragment
        child.return = next.return = workInProgress
      } else {
        // No longer suspended. Switch back to showing the primary children,
        // and remove the intermediate fragment fiber.
        const nextPrimaryChildren = nextProps.children
        const currentPrimaryChild = currentPrimaryChildFragment.child
        const currentFallbackChild = currentFallbackChildFragment.child
        const primaryChild = reconcileChildFibers(
          workInProgress,
          currentPrimaryChild,
          nextPrimaryChildren,
          renderExpirationTime,
        )
        // Delete the fallback children.
        reconcileChildFibers(
          workInProgress,
          currentFallbackChild,
          null,
          renderExpirationTime,
        )
        // Continue rendering the children, like we normally do.
        child = next = primaryChild
      }
    } else {
      // The current tree has not already timed out. That means the primary
      // children are not wrapped in a fragment fiber.
      const currentPrimaryChild: Fiber = (current.child: any)
      if (nextDidTimeout) {
        // Timed out. Wrap the children in a fragment fiber to keep them
        // separate from the fallback children.
        const nextFallbackChildren = nextProps.fallback
        const primaryChildFragment = createFiberFromFragment(
          // It shouldn't matter what the pending props are because we aren't
          // going to render this fragment.
          null,
          mode,
          NoWork,
          null,
        )
        primaryChildFragment.effectTag |= Placement
        primaryChildFragment.child = currentPrimaryChild
        currentPrimaryChild.return = primaryChildFragment
        // Create a fragment from the fallback children, too.
        const fallbackChildFragment = (primaryChildFragment.sibling = createFiberFromFragment(
          nextFallbackChildren,
          mode,
          renderExpirationTime,
          null,
        ))
        fallbackChildFragment.effectTag |= Placement
        child = primaryChildFragment
        primaryChildFragment.childExpirationTime = NoWork
        // Skip the primary children, and continue working on the
        // fallback children.
        next = fallbackChildFragment
        child.return = next.return = workInProgress
      } else {
        // Still haven't timed out.  Continue rendering the children, like we
        // normally do.
        const nextPrimaryChildren = nextProps.children
        next = child = reconcileChildFibers(
          workInProgress,
          currentPrimaryChild,
          nextPrimaryChildren,
          renderExpirationTime,
        )
      }
    }
  }

  workInProgress.memoizedState = nextState
  workInProgress.child = child
  return next
}