docs: def _glob(self, curdir, this, rest):
          """
          Handle glob flow.
  
          There are really only a couple of cases:
  
          - File name.
          - File name pattern (magic).
          - Directory.
          - Directory name pattern (magic).
          - Extra slashes `////`.
          - `globstar` `**`.
          """
  
          is_magic = this.is_magic
          dir_only = this.dir_only
          target = this.pattern
          is_globstar = this.is_globstar
  
          if is_magic and is_globstar:
              # Glob star directory `**`.
  
              # Throw away multiple consecutive `globstars`
              # and acquire the pattern after the `globstars` if available.
              this = rest.pop(0) if rest else None
              globstar_end = this is None
              while this and not globstar_end:
                  if this:
                      dir_only = this.dir_only
                      target = this.pattern
                  if this and this.is_globstar:
                      this = rest.pop(0) if rest else None
                      if this is None:
                          globstar_end = True
                  else:
                      break
  
              if globstar_end:
                  target = None
  
              # We match `**/next` during a deep glob, so what ever comes back,
              # we will send back through `_glob` with pattern after `next` (`**/next/after`).
              # So grab `after` if available.
              this = rest.pop(0) if rest else None
  
              # Deep searching is the unique case where we
              # might feed in a `None` for the next pattern to match.
              # Deep glob will account for this.
              matcher = self._get_matcher(target)
  
              # If our pattern ends with `curdir/**`, but does not start with `**` it matches zero or more,
              # so it should return `curdir/`, signifying `curdir` + no match.
              # If a pattern follows `**/something`, we always get the appropriate
              # return already, so this isn't needed in that case.
              # There is one quirk though with Bash, if `curdir` had magic before `**`, Bash
              # omits the trailing `/`. We don't worry about that.
              if globstar_end and curdir:
                  yield os.path.join(curdir, self.empty)
  
              # Search
              for path in self._glob_dir(curdir, matcher, dir_only, deep=True):
                  if this:
                      yield from self._glob(path, this, rest[:])
                  else:
                      yield path
  
          elif not dir_only:
              # Files: no need to recursively search at this point as we are done.
              matcher = self._get_matcher(target)
              yield from self._glob_dir(curdir, matcher)
  
          else:
              # Directory: search current directory against pattern
              # and feed the results back through with the next pattern.
              this = rest.pop(0) if rest else None
              matcher = self._get_matcher(target)
              for path in self._glob_dir(curdir, matcher, True):
                  if this:
                      yield from self._glob(path, this, rest[:])
                  else:
                      yield path