MikeCoder / markdown-preview.vim

class Markdown(object):

    # The dict of "extras" to enable in processing -- a mapping of

    # extra name to argument for the extra. Most extras do not have an

    # argument, in which case the value is None.

    #

    # This can be set via (a) subclassing and (b) the constructor

    # "extras" argument.

    extras = None

    urls = None

    titles = None

    html_blocks = None

    html_spans = None

    html_removed_text = "[HTML_REMOVED]"  # for compat with markdown.py

    # Used to track when we're inside an ordered or unordered list

    # (see _ProcessListItems() for details):

    list_level = 0

    _ws_only_line_re = re.compile(r"^[ \t]+$", re.M)

    def __init__(self, html4tags=False, tab_width=4, safe_mode=None,

                 extras=None, link_patterns=None,

                 footnote_title=None, footnote_return_symbol=None,

                 use_file_vars=False):

        if html4tags:

            self.empty_element_suffix = ">"

        else:

            self.empty_element_suffix = " />"

        self.tab_width = tab_width

        # For compatibility with earlier markdown2.py and with

        # markdown.py's safe_mode being a boolean,

        #   safe_mode == True -> "replace"

        if safe_mode is True:

            self.safe_mode = "replace"

        else:

            self.safe_mode = safe_mode

        # Massaging and building the "extras" info.

        if self.extras is None:

            self.extras = {}

        elif not isinstance(self.extras, dict):

            self.extras = dict([(e, None) for e in self.extras])

        if extras:

            if not isinstance(extras, dict):

                extras = dict([(e, None) for e in extras])

            self.extras.update(extras)

        assert isinstance(self.extras, dict)

        if "toc" in self.extras and "header-ids" not in self.extras:

            self.extras["header-ids"] = None   # "toc" implies "header-ids"

        self._instance_extras = self.extras.copy()

        self.link_patterns = link_patterns

        self.footnote_title = footnote_title

        self.footnote_return_symbol = footnote_return_symbol

        self.use_file_vars = use_file_vars

        self._outdent_re = re.compile(r'^(\t|[ ]{1,%d})' % tab_width, re.M)

        self._escape_table = g_escape_table.copy()

        if "smarty-pants" in self.extras:

            self._escape_table['"'] = _hash_text('"')

            self._escape_table["'"] = _hash_text("'")

    def reset(self):

        self.urls = {}

        self.titles = {}

        self.html_blocks = {}

        self.html_spans = {}

        self.list_level = 0

        self.extras = self._instance_extras.copy()

        if "footnotes" in self.extras:

            self.footnotes = {}

            self.footnote_ids = []

        if "header-ids" in self.extras:

            self._count_from_header_id = {}  # no `defaultdict` in Python 2.4

        if "metadata" in self.extras:

            self.metadata = {}

    # Per <https://developer.mozilla.org/en-US/docs/HTML/Element/a> "rel"

    # should only be used in <a> tags with an "href" attribute.

    _a_nofollow = re.compile(r"""

        <(a)

        (

            [^>]*

            href=   # href is required

            ['"]?   # HTML5 attribute values do not have to be quoted

            [^#'"]  # We don't want to match href values that start with # (like footnotes)

        )

        """,

        re.IGNORECASE | re.VERBOSE

    )

    # Opens the linked document in a new window or tab

    # should only used in <a> tags with an "href" attribute.

    # same with _a_nofollow

    _a_blank = _a_nofollow

    def convert(self, text):

        """Convert the given text."""

        # Main function. The order in which other subs are called here is

        # essential. Link and image substitutions need to happen before

        # _EscapeSpecialChars(), so that any *'s or _'s in the <a>

        # and <img> tags get encoded.

        # Clear the global hashes. If we don't clear these, you get conflicts

        # from other articles when generating a page which contains more than

        # one article (e.g. an index page that shows the N most recent

        # articles):

        self.reset()

        if not isinstance(text, unicode):

            # TODO: perhaps shouldn't presume UTF-8 for string input?

            text = unicode(text, 'utf-8')

            # Look for emacs-style file variable hints.

            emacs_vars = self._get_emacs_vars(text)

            if "markdown-extras" in emacs_vars:

                splitter = re.compile("[ ,]+")

                for e in splitter.split(emacs_vars["markdown-extras"]):

                    if '=' in e:

                        ename, earg = e.split('=', 1)

                        try:

                            earg = int(earg)

                        except ValueError:

                            pass

                    else:

                        ename, earg = e, None

                    self.extras[ename] = earg

        # Standardize line endings:

        text = text.replace("\r\n", "\n")

        text = text.replace("\r", "\n")

        # Make sure $text ends with a couple of newlines:

        text += "\n\n"

        # Convert all tabs to spaces.

        text = self._detab(text)

        # Strip any lines consisting only of spaces and tabs.

        # This makes subsequent regexen easier to write, because we can

        # match consecutive blank lines with /\n+/ instead of something

        # contorted like /[ \t]*\n+/ .

        text = self._ws_only_line_re.sub("", text)

        # strip metadata from head and extract

        if "metadata" in self.extras:

            text = self._extract_metadata(text)

        text = self.preprocess(text)

        if "fenced-code-blocks" in self.extras and not self.safe_mode:

            text = self._do_fenced_code_blocks(text)

        if self.safe_mode:

            text = self._hash_html_spans(text)

        # Turn block-level HTML blocks into hash entries

        text = self._hash_html_blocks(text, raw=True)

        if "fenced-code-blocks" in self.extras and self.safe_mode:

            text = self._do_fenced_code_blocks(text)

        # Because numbering references aren't links (yet?) then we can do everything associated with counters

        # before we get started

        if "numbering" in self.extras:

            text = self._do_numbering(text)

        # Strip link definitions, store in hashes.

        if "footnotes" in self.extras:

            # Must do footnotes first because an unlucky footnote defn

            # looks like a link defn:

            #   [^4]: this "looks like a link defn"

            text = self._strip_footnote_definitions(text)

        text = self._strip_link_definitions(text)

        text = self._run_block_gamut(text)

        if "footnotes" in self.extras:

            text = self._add_footnotes(text)

        text = self.postprocess(text)

        text = self._unescape_special_chars(text)

        if self.safe_mode:

            text = self._unhash_html_spans(text)

        if "nofollow" in self.extras:

            text = self._a_nofollow.sub(r'<\1 rel="nofollow"\2', text)

        if "target-blank-links" in self.extras:

            text = self._a_blank.sub(r'<\1 target="_blank"\2', text)

        text += "\n"

        rv = UnicodeWithAttrs(text)

        if "toc" in self.extras:

            rv._toc = self._toc

        if "metadata" in self.extras:

            rv.metadata = self.metadata

        return rv

    def postprocess(self, text):

        """A hook for subclasses to do some postprocessing of the html, if

        desired. This is called before unescaping of special chars and

        unhashing of raw HTML spans.

        """

        return text

    def preprocess(self, text):

        """A hook for subclasses to do some preprocessing of the Markdown, if

        desired. This is called after basic formatting of the text, but prior

        to any extras, safe mode, etc. processing.

        """

        return text

    # Is metadata if the content starts with optional '---'-fenced `key: value`

    # pairs. E.g. (indented for presentation):

    #   ---

    #   foo: bar

    #   another-var: blah blah

    #   ---

    #   # header

    # or:

    #   foo: bar

    #   another-var: blah blah

    #

    #   # header

    _meta_data_pattern = re.compile(r'^(?:---[\ \t]*\n)?(.*:\s+>\n\s+[\S\s]+?)(?=\n\w+\s*:\s*\w+\n|\Z)|([\S\w]+\s*:(?! >)[ \t]*.*\n?)(?:---[\ \t]*\n)?', re.MULTILINE)

    _key_val_pat = re.compile("[\S\w]+\s*:(?! >)[ \t]*.*\n?", re.MULTILINE)

    # this allows key: >

    #                   value

    #                   conutiues over multiple lines

    _key_val_block_pat = re.compile(

        "(.*:\s+>\n\s+[\S\s]+?)(?=\n\w+\s*:\s*\w+\n|\Z)", re.MULTILINE)

    _meta_data_fence_pattern = re.compile(r'^---[\ \t]*\n', re.MULTILINE)

    _meta_data_newline = re.compile("^\n", re.MULTILINE)

    def _extract_metadata(self, text):

        if text.startswith("---"):

            fence_splits = re.split(self._meta_data_fence_pattern, text, maxsplit=2)

            metadata_content = fence_splits[1]

            match = re.findall(self._meta_data_pattern, metadata_content)

            if not match:

                return text

            tail = fence_splits[2]

        else:

            metadata_split = re.split(self._meta_data_newline, text, maxsplit=1)

            metadata_content = metadata_split[0]

            match = re.findall(self._meta_data_pattern, metadata_content)

            if not match:

                return text

            tail = metadata_split[1]

        kv = re.findall(self._key_val_pat, metadata_content)

        kvm = re.findall(self._key_val_block_pat, metadata_content)

        kvm = [item.replace(": >\n", ":", 1) for item in kvm]

        for item in kv + kvm:

            k, v = item.split(":", 1)

            self.metadata[k.strip()] = v.strip()

        return tail

    _emacs_oneliner_vars_pat = re.compile(r"-\*-\s*([^\r\n]*?)\s*-\*-", re.UNICODE)

    # This regular expression is intended to match blocks like this:

    #    PREFIX Local Variables: SUFFIX

    #    PREFIX mode: Tcl SUFFIX

    #    PREFIX End: SUFFIX

    # Some notes:

    # - "[ \t]" is used instead of "\s" to specifically exclude newlines

    # - "(\r\n|\n|\r)" is used instead of "$" because the sre engine does

    #   not like anything other than Unix-style line terminators.

    _emacs_local_vars_pat = re.compile(r"""^

        (?P<prefix>(?:[^\r\n|\n|\r])*?)

        [\ \t]*Local\ Variables:[\ \t]*

        (?P<suffix>.*?)(?:\r\n|\n|\r)

        (?P<content>.*?\1End:)

        """, re.IGNORECASE | re.MULTILINE | re.DOTALL | re.VERBOSE)

    def _get_emacs_vars(self, text):

        """Return a dictionary of emacs-style local variables.

        Parsing is done loosely according to this spec (and according to

        some in-practice deviations from this):

        http://www.gnu.org/software/emacs/manual/html_node/emacs/Specifying-File-Variables.html#Specifying-File-Variables

        """

        emacs_vars = {}

        SIZE = pow(2, 13)  # 8kB

        # Search near the start for a '-*-'-style one-liner of variables.

        head = text[:SIZE]

        if "-*-" in head:

            match = self._emacs_oneliner_vars_pat.search(head)

            if match:

                emacs_vars_str = match.group(1)

                assert '\n' not in emacs_vars_str

                emacs_var_strs = [s.strip() for s in emacs_vars_str.split(';')

                                  if s.strip()]

                if len(emacs_var_strs) == 1 and ':' not in emacs_var_strs[0]:

                    # While not in the spec, this form is allowed by emacs:

                    #   -*- Tcl -*-

                    # where the implied "variable" is "mode". This form

                    # is only allowed if there are no other variables.

                    emacs_vars["mode"] = emacs_var_strs[0].strip()

                else:

                    for emacs_var_str in emacs_var_strs:

                        try:

                            variable, value = emacs_var_str.strip().split(':', 1)

                        except ValueError:

                            log.debug("emacs variables error: malformed -*- "

                                      "line: %r", emacs_var_str)

                            continue

                        # Lowercase the variable name because Emacs allows "Mode"

                        # or "mode" or "MoDe", etc.

                        emacs_vars[variable.lower()] = value.strip()

        tail = text[-SIZE:]

        if "Local Variables" in tail:

            match = self._emacs_local_vars_pat.search(tail)

            if match:

                prefix = match.group("prefix")

                suffix = match.group("suffix")

                lines = match.group("content").splitlines(0)

                # print "prefix=%r, suffix=%r, content=%r, lines: %s"\

                #      % (prefix, suffix, match.group("content"), lines)

                # Validate the Local Variables block: proper prefix and suffix

                # usage.

                for i, line in enumerate(lines):

                    if not line.startswith(prefix):

                        log.debug("emacs variables error: line '%s' "

                                  "does not use proper prefix '%s'"

                                  % (line, prefix))

                        return {}

                    # Don't validate suffix on last line. Emacs doesn't care,

                    # neither should we.

                    if i != len(lines)-1 and not line.endswith(suffix):

                        log.debug("emacs variables error: line '%s' "

                                  "does not use proper suffix '%s'"

                                  % (line, suffix))

                        return {}

                # Parse out one emacs var per line.

                continued_for = None

                for line in lines[:-1]:  # no var on the last line ("PREFIX End:")

                    if prefix: line = line[len(prefix):]  # strip prefix

                    if suffix: line = line[:-len(suffix)]  # strip suffix

                    line = line.strip()

                    if continued_for:

                        variable = continued_for

                        if line.endswith('\\'):

                            line = line[:-1].rstrip()

                        else:

                            continued_for = None

                        emacs_vars[variable] += ' ' + line

                    else:

                        try:

                            variable, value = line.split(':', 1)

                        except ValueError:

                            log.debug("local variables error: missing colon "

                                      "in local variables entry: '%s'" % line)

                            continue

                        # Do NOT lowercase the variable name, because Emacs only

                        # allows "mode" (and not "Mode", "MoDe", etc.) in this block.

                        value = value.strip()

                        if value.endswith('\\'):

                            value = value[:-1].rstrip()

                            continued_for = variable

                        else:

                            continued_for = None

                        emacs_vars[variable] = value

        # Unquote values.

        for var, val in list(emacs_vars.items()):

            if len(val) > 1 and (val.startswith('"') and val.endswith('"')

               or val.startswith('"') and val.endswith('"')):

                emacs_vars[var] = val[1:-1]

        return emacs_vars

    def _detab_line(self, line):

        r"""Recusively convert tabs to spaces in a single line.

        Called from _detab()."""

        if '\t' not in line:

            return line

        chunk1, chunk2 = line.split('\t', 1)

        chunk1 += (' ' * (self.tab_width - len(chunk1) % self.tab_width))

        output = chunk1 + chunk2

        return self._detab_line(output)

    def _detab(self, text):

        r"""Iterate text line by line and convert tabs to spaces.

            >>> m = Markdown()

            >>> m._detab("\tfoo")

            '    foo'

            >>> m._detab("  \tfoo")

            '    foo'

            >>> m._detab("\t  foo")

            '      foo'

            >>> m._detab("  foo")

            '  foo'

            >>> m._detab("  foo\n\tbar\tblam")

            '  foo\n    bar blam'

        """

        if '\t' not in text:

            return text

        output = []

        for line in text.splitlines():

            output.append(self._detab_line(line))

        return '\n'.join(output)

    # I broke out the html5 tags here and add them to _block_tags_a and

    # _block_tags_b.  This way html5 tags are easy to keep track of.

    _html5tags = '|article|aside|header|hgroup|footer|nav|section|figure|figcaption'

    _block_tags_a = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math|ins|del'

    _block_tags_a += _html5tags

    _strict_tag_block_re = re.compile(r"""

        (                       # save in \1

            ^                   # start of line  (with re.M)

            <(%s)               # start tag = \2

            \b                  # word break

            (.*\n)*?            # any number of lines, minimally matching

            </\2>               # the matching end tag

            [ \t]*              # trailing spaces/tabs

            (?=\n+|\Z)          # followed by a newline or end of document

        )

        """ % _block_tags_a,

        re.X | re.M)

    _block_tags_b = 'p|div|h[1-6]|blockquote|pre|table|dl|ol|ul|script|noscript|form|fieldset|iframe|math'

    _block_tags_b += _html5tags

    _liberal_tag_block_re = re.compile(r"""

        (                       # save in \1

            ^                   # start of line  (with re.M)

            <(%s)               # start tag = \2

            \b                  # word break

            (.*\n)*?            # any number of lines, minimally matching

            .*</\2>             # the matching end tag

            [ \t]*              # trailing spaces/tabs

            (?=\n+|\Z)          # followed by a newline or end of document

        )

        """ % _block_tags_b,

        re.X | re.M)

    _html_markdown_attr_re = re.compile(

        r'''\s+markdown=("1"|'1')''')

    def _hash_html_block_sub(self, match, raw=False):

        html = match.group(1)

        if raw and self.safe_mode:

            html = self._sanitize_html(html)

        elif 'markdown-in-html' in self.extras and 'markdown=' in html:

            first_line = html.split('\n', 1)[0]

            m = self._html_markdown_attr_re.search(first_line)

            if m:

                lines = html.split('\n')

                middle = '\n'.join(lines[1:-1])

                last_line = lines[-1]

                first_line = first_line[:m.start()] + first_line[m.end():]

                f_key = _hash_text(first_line)

                self.html_blocks[f_key] = first_line

                l_key = _hash_text(last_line)

                self.html_blocks[l_key] = last_line

                return ''.join(["\n\n", f_key,

                    "\n\n", middle, "\n\n",

                    l_key, "\n\n"])

        key = _hash_text(html)

        self.html_blocks[key] = html

        return "\n\n" + key + "\n\n"

    def _hash_html_blocks(self, text, raw=False):

        """Hashify HTML blocks

        We only want to do this for block-level HTML tags, such as headers,

        lists, and tables. That's because we still want to wrap <p>s around

        "paragraphs" that are wrapped in non-block-level tags, such as anchors,

        phrase emphasis, and spans. The list of tags we're looking for is

        hard-coded.

        @param raw {boolean} indicates if these are raw HTML blocks in

            the original source. It makes a difference in "safe" mode.

        """

        if '<' not in text:

            return text

        # Pass `raw` value into our calls to self._hash_html_block_sub.

        hash_html_block_sub = _curry(self._hash_html_block_sub, raw=raw)

        # First, look for nested blocks, e.g.:

        #   <div>

        #       <div>

        #       tags for inner block must be indented.

        #       </div>

        #   </div>

        #

        # The outermost tags must start at the left margin for this to match, and

        # the inner nested divs must be indented.

        # We need to do this before the next, more liberal match, because the next

        # match will start at the first `<div>` and stop at the first `</div>`.

        text = self._strict_tag_block_re.sub(hash_html_block_sub, text)

        # Now match more liberally, simply from `\n<tag>` to `</tag>\n`

        text = self._liberal_tag_block_re.sub(hash_html_block_sub, text)

        # Special case just for <hr />. It was easier to make a special

        # case than to make the other regex more complicated.

        if "<hr" in text:

            _hr_tag_re = _hr_tag_re_from_tab_width(self.tab_width)

            text = _hr_tag_re.sub(hash_html_block_sub, text)

        # Special case for standalone HTML comments:

        if "<!--" in text:

            start = 0

            while True:

                # Delimiters for next comment block.

                try:

                    start_idx = text.index("<!--", start)

                except ValueError:

                    break

                try:

                    end_idx = text.index("-->", start_idx) + 3

                except ValueError:

                    break

                # Start position for next comment block search.

                start = end_idx

                # Validate whitespace before comment.

                if start_idx:

                    # - Up to `tab_width - 1` spaces before start_idx.

                    for i in range(self.tab_width - 1):

                        if text[start_idx - 1] != ' ':

                            break

                        start_idx -= 1

                        if start_idx == 0:

                            break

                    # - Must be preceded by 2 newlines or hit the start of

                    #   the document.

                    if start_idx == 0:

                        pass

                    elif start_idx == 1 and text[0] == '\n':

                        start_idx = 0  # to match minute detail of Markdown.pl regex

                    elif text[start_idx-2:start_idx] == '\n\n':

                        pass

                    else:

                        break

                # Validate whitespace after comment.

                # - Any number of spaces and tabs.

                while end_idx < len(text):

                    if text[end_idx] not in ' \t':

                        break

                    end_idx += 1

                # - Must be following by 2 newlines or hit end of text.

                if text[end_idx:end_idx+2] not in ('', '\n', '\n\n'):

                    continue

                # Escape and hash (must match `_hash_html_block_sub`).

                html = text[start_idx:end_idx]

                if raw and self.safe_mode:

                    html = self._sanitize_html(html)

                key = _hash_text(html)

                self.html_blocks[key] = html

                text = text[:start_idx] + "\n\n" + key + "\n\n" + text[end_idx:]

        if "xml" in self.extras:

            # Treat XML processing instructions and namespaced one-liner

            # tags as if they were block HTML tags. E.g., if standalone

            # (i.e. are their own paragraph), the following do not get

            # wrapped in a <p> tag:

            #    <?foo bar?>

            #

            #    <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" href="chapter_1.md"/>

            _xml_oneliner_re = _xml_oneliner_re_from_tab_width(self.tab_width)

            text = _xml_oneliner_re.sub(hash_html_block_sub, text)

        return text

    def _strip_link_definitions(self, text):

        # Strips link definitions from text, stores the URLs and titles in

        # hash references.

        less_than_tab = self.tab_width - 1

        # Link defs are in the form:

        #   [id]: url "optional title"

        _link_def_re = re.compile(r"""

            ^[ ]{0,%d}\[(.+)\]: # id = \1

              [ \t]*

              \n?               # maybe *one* newline

              [ \t]*

            <?(.+?)>?           # url = \2

              [ \t]*

            (?:

                \n?             # maybe one newline

                [ \t]*

                (?<=\s)         # lookbehind for whitespace

                ['"(]

                ([^\n]*)        # title = \3

                ['")]

                [ \t]*

            )?  # title is optional

            (?:\n+|\Z)

            """ % less_than_tab, re.X | re.M | re.U)

        return _link_def_re.sub(self._extract_link_def_sub, text)

    def _extract_link_def_sub(self, match):

        id, url, title = match.groups()

        key = id.lower()    # Link IDs are case-insensitive

        self.urls[key] = self._encode_amps_and_angles(url)

        if title:

            self.titles[key] = title

        return ""

    def _do_numbering(self, text):

        ''' We handle the special extension for generic numbering for

            tables, figures etc.

        '''

        # First pass to define all the references

        self.regex_defns = re.compile(r'''

            \[\#(\w+)\s* # the counter.  Open square plus hash plus a word \1

            ([^@]*)\s*   # Some optional characters, that aren't an @. \2

            @(\w+)       # the id.  Should this be normed? \3

            ([^\]]*)\]   # The rest of the text up to the terminating ] \4

            ''', re.VERBOSE)

        self.regex_subs = re.compile(r"\[@(\w+)\s*\]")  # [@ref_id]

        counters = {}

        references = {}

        replacements = []

        definition_html = '<figcaption class="{}" id="counter-ref-{}">{}{}{}</figcaption>'

        reference_html = '<a class="{}" href="#counter-ref-{}">{}</a>'

        for match in self.regex_defns.finditer(text):

            # We must have four match groups otherwise this isn't a numbering reference

            if len(match.groups()) != 4:

                continue

            counter = match.group(1)

            text_before = match.group(2)

            ref_id = match.group(3)

            text_after = match.group(4)

            number = counters.get(counter, 1)

            references[ref_id] = (number, counter)

            replacements.append((match.start(0),

                                 definition_html.format(counter,

                                                        ref_id,

                                                        text_before,

                                                        number,

                                                        text_after),

                                 match.end(0)))

            counters[counter] = number + 1

        for repl in reversed(replacements):

            text = text[:repl[0]] + repl[1] + text[repl[2]:]

        # Second pass to replace the references with the right

        # value of the counter

        # Fwiw, it's vaguely annoying to have to turn the iterator into

        # a list and then reverse it but I can't think of a better thing to do.

        for match in reversed(list(self.regex_subs.finditer(text))):

            number, counter = references.get(match.group(1), (None, None))

            if number is not None:

                repl = reference_html.format(counter,

                                             match.group(1),

                                             number)

            else:

                repl = reference_html.format(match.group(1),

                                             'countererror',

                                             '?' + match.group(1) + '?')

            if "smarty-pants" in self.extras:

                repl = repl.replace('"', self._escape_table['"'])

            text = text[:match.start()] + repl + text[match.end():]

        return text

    def _extract_footnote_def_sub(self, match):

        id, text = match.groups()

        text = _dedent(text, skip_first_line=not text.startswith('\n')).strip()

        normed_id = re.sub(r'\W', '-', id)

        # Ensure footnote text ends with a couple newlines (for some

        # block gamut matches).

        self.footnotes[normed_id] = text + "\n\n"

        return ""

    def _strip_footnote_definitions(self, text):

        """A footnote definition looks like this:

            [^note-id]: Text of the note.

                May include one or more indented paragraphs.

        Where,

        - The 'note-id' can be pretty much anything, though typically it

          is the number of the footnote.

        - The first paragraph may start on the next line, like so:

            [^note-id]:

                Text of the note.

        """

        less_than_tab = self.tab_width - 1

        footnote_def_re = re.compile(r'''

            ^[ ]{0,%d}\[\^(.+)\]:   # id = \1

            [ \t]*

            (                       # footnote text = \2

              # First line need not start with the spaces.

              (?:\s*.*\n+)

              (?:

                (?:[ ]{%d} | \t)  # Subsequent lines must be indented.

                .*\n+

              )*

            )

            # Lookahead for non-space at line-start, or end of doc.

            (?:(?=^[ ]{0,%d}\S)|\Z)

            ''' % (less_than_tab, self.tab_width, self.tab_width),

            re.X | re.M)

        return footnote_def_re.sub(self._extract_footnote_def_sub, text)

    _hr_re = re.compile(r'^[ ]{0,3}([-_*][ ]{0,2}){3,}$', re.M)

    def _run_block_gamut(self, text):

        # These are all the transformations that form block-level

        # tags like paragraphs, headers, and list items.

        if "fenced-code-blocks" in self.extras:

            text = self._do_fenced_code_blocks(text)

        text = self._do_headers(text)

        # Do Horizontal Rules:

        # On the number of spaces in horizontal rules: The spec is fuzzy: "If

        # you wish, you may use spaces between the hyphens or asterisks."

        # Markdown.pl 1.0.1's hr regexes limit the number of spaces between the

        # hr chars to one or two. We'll reproduce that limit here.

        hr = "\n<hr"+self.empty_element_suffix+"\n"

        text = re.sub(self._hr_re, hr, text)

        text = self._do_lists(text)

        if "pyshell" in self.extras:

            text = self._prepare_pyshell_blocks(text)

        if "wiki-tables" in self.extras:

            text = self._do_wiki_tables(text)

        if "tables" in self.extras:

            text = self._do_tables(text)

        text = self._do_code_blocks(text)

        text = self._do_block_quotes(text)

        # We already ran _HashHTMLBlocks() before, in Markdown(), but that

        # was to escape raw HTML in the original Markdown source. This time,

        # we're escaping the markup we've just created, so that we don't wrap

        # <p> tags around block-level tags.

        text = self._hash_html_blocks(text)

        text = self._form_paragraphs(text)

        return text

    def _pyshell_block_sub(self, match):

        lines = match.group(0).splitlines(0)

        _dedentlines(lines)

        indent = ' ' * self.tab_width

        s = ('\n'  # separate from possible cuddled paragraph

             + indent + ('\n'+indent).join(lines)

             + '\n\n')

        return s

    def _prepare_pyshell_blocks(self, text):

        """Ensure that Python interactive shell sessions are put in

        code blocks -- even if not properly indented.

        """

        if ">>>" not in text:

            return text

        less_than_tab = self.tab_width - 1

        _pyshell_block_re = re.compile(r"""

            ^([ ]{0,%d})>>>[ ].*\n   # first line

            ^(\1.*\S+.*\n)*         # any number of subsequent lines

            ^\n                     # ends with a blank line

            """ % less_than_tab, re.M | re.X)

        return _pyshell_block_re.sub(self._pyshell_block_sub, text)

    def _table_sub(self, match):

        trim_space_re = '^[ \t\n]+|[ \t\n]+$'

        trim_bar_re = '^\||\|$'

        split_bar_re = '^\||(?<!\\\\)\|'

        escape_bar_re = '\\\\\|'

        head, underline, body = match.groups()

        # Determine aligns for columns.

        cols = [re.sub(escape_bar_re, '|', cell.strip()) for cell in re.split(split_bar_re, re.sub(trim_bar_re, "", re.sub(trim_space_re, "", underline)))]

        align_from_col_idx = {}

        for col_idx, col in enumerate(cols):

            if col[0] == ':' and col[-1] == ':':

                align_from_col_idx[col_idx] = ' align="center"'

            elif col[0] == ':':

                align_from_col_idx[col_idx] = ' align="left"'

            elif col[-1] == ':':

                align_from_col_idx[col_idx] = ' align="right"'

        # thead

        hlines = ['<table%s>' % self._html_class_str_from_tag('table'), '<thead>', '<tr>']

        cols = [re.sub(escape_bar_re, '|', cell.strip()) for cell in re.split(split_bar_re, re.sub(trim_bar_re, "", re.sub(trim_space_re, "", head)))]

        for col_idx, col in enumerate(cols):

            hlines.append('  <th%s>%s</th>' % (

                align_from_col_idx.get(col_idx, ''),

                self._run_span_gamut(col)

            ))

        hlines.append('</tr>')

        hlines.append('</thead>')

        # tbody

        hlines.append('<tbody>')

        for line in body.strip('\n').split('\n'):

            hlines.append('<tr>')

            cols = [re.sub(escape_bar_re, '|', cell.strip()) for cell in re.split(split_bar_re, re.sub(trim_bar_re, "", re.sub(trim_space_re, "", line)))]

            for col_idx, col in enumerate(cols):

                hlines.append('  <td%s>%s</td>' % (

                    align_from_col_idx.get(col_idx, ''),

                    self._run_span_gamut(col)

                ))