docs: def _do_strong_search(self, obj, recursive=True):
          """Search for the specific element *obj* within the node list.
  
          *obj* can be either a :class:`.Node` or a :class:`.Wikicode` object. If
          found, we return a tuple (*context*, *index*) where *context* is the
          :class:`.Wikicode` that contains *obj* and *index* is its index there,
          as a :class:`slice`. Note that if *recursive* is ``False``, *context*
          will always be ``self`` (since we only look for *obj* among immediate
          descendants), but if *recursive* is ``True``, then it could be any
          :class:`.Wikicode` contained by a node within ``self``. If *obj* is not
          found, :exc:`ValueError` is raised.
          """
          if isinstance(obj, Wikicode):
              if not self._is_child_wikicode(obj, recursive):
                  raise ValueError(obj)
              return obj, slice(0, len(obj.nodes))
  
          if isinstance(obj, Node):
              mkslice = lambda i: slice(i, i + 1)
              if not recursive:
                  return self, mkslice(self.index(obj))
              for node in self.nodes:
                  for context, child in self._get_children(node, contexts=True):
                      if obj is child:
                          if not context:
                              context = self
                          return context, mkslice(context.index(child))
              raise ValueError(obj)
  
          raise TypeError(obj)