docs: def _collect_paths(element):
      """
      Collect all possible path which leads to `element`.
  
      Function returns standard path from root element to this, reverse path,
      which uses negative indexes for path, also some pattern matches, like
      "this is element, which has neighbour with id 7" and so on.
  
      Args:
          element (obj): HTMLElement instance.
  
      Returns:
          list: List of :class:`.PathCall` and :class:`.Chained` objects.
      """
      output = []
  
      # look for element by parameters - sometimes the ID is unique
      path = vectors.el_to_path_vector(element)
      root = path[0]
      params = element.params if element.params else None
      match = root.find(element.getTagName(), params)
  
      if len(match) == 1:
          output.append(
              PathCall("find", 0, [element.getTagName(), params])
          )
  
      # look for element by neighbours
      output.extend(path_patterns.neighbours_pattern(element))
  
      # look for elements by patterns - element, which parent has tagname, and
      # which parent has tagname ..
      output.extend(path_patterns.predecesors_pattern(element, root))
  
      index_backtrack = []
      last_index_backtrack = []
      params_backtrack = []
      last_params_backtrack = []
  
      # look for element by paths from root to element
      for el in reversed(path):
          # skip root elements
          if not el.parent:
              continue
  
          tag_name = el.getTagName()
          match = el.parent.wfind(tag_name).childs
          index = match.index(el)
  
          index_backtrack.append(
              PathCall("wfind", index, [tag_name])
          )
          last_index_backtrack.append(
              PathCall("wfind", index - len(match), [tag_name])
          )
  
          # if element has some parameters, use them for lookup
          if el.params:
              match = el.parent.wfind(tag_name, el.params).childs
              index = match.index(el)
  
              params_backtrack.append(
                  PathCall("wfind", index, [tag_name, el.params])
              )
              last_params_backtrack.append(
                  PathCall("wfind", index - len(match), [tag_name, el.params])
              )
          else:
              params_backtrack.append(
                  PathCall("wfind", index, [tag_name])
              )
              last_params_backtrack.append(
                  PathCall("wfind", index - len(match), [tag_name])
              )
  
      output.extend([
          Chained(reversed(params_backtrack)),
          Chained(reversed(last_params_backtrack)),
          Chained(reversed(index_backtrack)),
          Chained(reversed(last_index_backtrack)),
      ])
  
      return output