docs: def get_sections(self, levels=None, matches=None, flags=FLAGS, flat=False,
                       include_lead=None, include_headings=True):
          """Return a list of sections within the page.
  
          Sections are returned as :class:`.Wikicode` objects with a shared node
          list (implemented using :class:`.SmartList`) so that changes to
          sections are reflected in the parent Wikicode object.
  
          Each section contains all of its subsections, unless *flat* is
          ``True``. If *levels* is given, it should be a iterable of integers;
          only sections whose heading levels are within it will be returned. If
          *matches* is given, it should be either a function or a regex; only
          sections whose headings match it (without the surrounding equal signs)
          will be included. *flags* can be used to override the default regex
          flags (see :meth:`ifilter`) if a regex *matches* is used.
  
          If *include_lead* is ``True``, the first, lead section (without a
          heading) will be included in the list; ``False`` will not include it;
          the default will include it only if no specific *levels* were given. If
          *include_headings* is ``True``, the section's beginning
          :class:`.Heading` object will be included; otherwise, this is skipped.
          """
          title_matcher = self._build_matcher(matches, flags)
          matcher = lambda heading: (title_matcher(heading.title) and
                                     (not levels or heading.level in levels))
          iheadings = self._indexed_ifilter(recursive=False, forcetype=Heading)
          sections = []  # Tuples of (index_of_first_node, section)
          open_headings = [] # Tuples of (index, heading), where index and
                             # heading.level are both monotonically increasing
  
          # Add the lead section if appropriate:
          if include_lead or not (include_lead is not None or matches or levels):
              itr = self._indexed_ifilter(recursive=False, forcetype=Heading)
              try:
                  first = next(itr)[0]
                  sections.append((0, Wikicode(self.nodes[:first])))
              except StopIteration:  # No headings in page
                  sections.append((0, Wikicode(self.nodes[:])))
  
          # Iterate over headings, adding sections to the list as they end:
          for i, heading in iheadings:
              if flat:  # With flat, all sections close at the next heading
                  newly_closed, open_headings = open_headings, []
              else:  # Otherwise, figure out which sections have closed, if any
                  closed_start_index = len(open_headings)
                  for j, (start, last_heading) in enumerate(open_headings):
                      if heading.level <= last_heading.level:
                          closed_start_index = j
                          break
                  newly_closed = open_headings[closed_start_index:]
                  del open_headings[closed_start_index:]
              for start, closed_heading in newly_closed:
                  if matcher(closed_heading):
                      sections.append((start, Wikicode(self.nodes[start:i])))
              start = i if include_headings else (i + 1)
              open_headings.append((start, heading))
  
          # Add any remaining open headings to the list of sections:
          for start, heading in open_headings:
              if matcher(heading):
                  sections.append((start, Wikicode(self.nodes[start:])))
  
          # Ensure that earlier sections are earlier in the returned list:
          return [section for i, section in sorted(sections)]