docs: def _is_working_path(dom, path, element):
      """
      Check whether the path is working or not.
  
      Aply proper search function interpreting `path` to `dom` and check, if
      returned object is `element`. If so, return ``True``, otherwise ``False``.
  
      Args:
          dom (obj): HTMLElement DOM.
          path (obj): :class:`.PathCall` Instance containing informations about
                      path and which function it require to obtain element the
                      path is pointing to.
          element (obj): HTMLElement instance used to decide whether `path`
                         points to correct `element` or not.
  
      Returns:
          bool: True if `path` correctly points to proper `element`.
      """
      def i_or_none(el, i):
          """
          Return ``el[i]`` if the list is not blank, or None otherwise.
  
          Args:
              el (list, tuple): Any indexable object.
              i (int): Index.
  
          Returns:
              obj: Element at index `i` if `el` is not blank, or ``None``.
          """
          if not el:
              return None
  
          return el[i]
  
      # map decoders of all paths to one dictionary to make easier to call them
      path_functions = {
          "find": lambda el, index, params:
              i_or_none(el.find(*params), index),
          "wfind": lambda el, index, params:
              i_or_none(el.wfind(*params).childs, index),
          "match": lambda el, index, params:
              i_or_none(el.match(*params), index),
          "left_neighbour_tag": lambda el, index, neigh_data:
              i_or_none(
                  el.find(
                      neigh_data.tag_name,
                      neigh_data.params,
                      fn=utils.has_neigh(*neigh_data.fn_params, left=True)
                  ),
                  index
              ),
          "right_neighbour_tag": lambda el, index, neigh_data:
              i_or_none(
                  el.find(
                      neigh_data.tag_name,
                      neigh_data.params,
                      fn=utils.has_neigh(*neigh_data.fn_params, left=False)
                  ),
                  index
              ),
      }
  
      # call all decoders and see what you get from them
      el = None
      if isinstance(path, PathCall):
          el = path_functions[path.call_type](dom, path.index, path.params)
      elif isinstance(path, Chained):
          for path in path.chain:
              dom = path_functions[path.call_type](dom, path.index, path.params)
              if not dom:
                  return False
          el = dom
      else:
          raise UserWarning(
              "Unknown type of path parameters! (%s)" % str(path)
          )
  
      if not el:
          return False
  
      # test whether returned item is the item we are looking for
      return el.getContent().strip() == element.getContent().strip()