Make append function a proper method

        self.children.append(node)

        return node

    def append(self, level: int, content: T) -> Node[T]:

        """

        If this node can nurse this entry (consisting of a level and content), nurse it.

        Otherwise, find a parent among this node's parents who can nurse the entry.

        :return: the newly nursed node

        """

        if self.can_nurse_at(level):

            return self._nurse(level, content)

        else:

            return self.parent.append(level, content)

    @classmethod

    def new_root(cls) -> Node[T]:

        return cls(-inf, None, None)

type Entry[T] = tuple[Level, T]

def _append_entry[T](prime_possible_parent: Node[T], entry: Entry[T]) -> Node[T]:

    level, content = entry

    while True:

        if prime_possible_parent.can_nurse_at(level):

            # If the prime possible parent can nurse at this level, let it nurse the node,

            # and make the newly inserted node the next prime possible parent

            return prime_possible_parent._nurse(*entry)

        else:

            # Go up once

            prime_possible_parent = prime_possible_parent.parent

def make_toc[T](entries: Iterable[Entry[T]]) -> Node[T]:

    root = Node.new_root()

    prime_possible_parent = root

    for entry in entries:

        prime_possible_parent = _append_entry(prime_possible_parent, entry)

        prime_possible_parent = prime_possible_parent.append(*entry)

    return root