docs: def reroot(self, node, length=None, branch_support=False):
          '''Reroot this ``Tree`` at ``length`` up the incident edge of ``node``. If 0 or ``None``, reroot at the node (not on the incident edge)
  
          Args:
              ``node`` (``Node``): The ``Node`` on whose incident edge this ``Tree`` will be rerooted
  
              ``length`` (``float``): The distance up the specified edge at which to reroot this ``Tree``. If 0 or ``None``, reroot at the node (not on the incident edge)
  
              ``branch_support`` (``bool``): ``True`` if internal node labels represent branch support values, otherwise ``False``
          '''
          warn("TreeSwift's rerooting functionality is poorly tested and likely has bugs. It will be fixed in a future release")
          if not isinstance(node, Node):
              raise TypeError("node must be a Node")
          if length is not None and not isinstance(length, float) and not isinstance(length, int):
              raise TypeError("length must be a float")
          if not isinstance(branch_support, bool):
              raise TypeError("branch_support must be a bool")
          if length is not None and length < 0:
              raise ValueError("Specified length at which to reroot must be positive")
          if node.edge_length is None:
              if length is not None and length != 0:
                  raise ValueError("Specified node has no edge length, so specified length must be None or 0")
          elif length is not None and length > node.edge_length:
              raise ValueError("Specified length must be shorter than the edge at which to reroot")
          if length is not None and length > 0:
              newnode = Node(edge_length=node.edge_length-length); node.edge_length -= length
              if not node.is_root():
                  p = node.parent; p.children.remove(node); p.add_child(newnode)
              newnode.add_child(node); node = newnode
          if node.is_root():
              return
          elif self.root.edge_length is not None:
              newnode = Node(label='ROOT'); newnode.add_child(self.root); self.root = newnode
          ancestors = [a for a in node.traverse_ancestors(include_self=True) if not a.is_root()]
          for i in range(len(ancestors)-1, -1, -1):
              curr = ancestors[i]; curr.parent.edge_length = curr.edge_length; curr.edge_length = None
              if branch_support:
                  curr.parent.label = curr.label; curr.label = None
              curr.parent.children.remove(curr); curr.add_child(curr.parent); curr.parent = None
          self.root = node; self.is_rooted = True