`` for inline level syntax.
A block level spoiler looks like block quote, but the marker is ``>!``:
.. code-block:: text
>! here is the spoiler content
>!
>! it will be hidden
Will be converted into:
.. code-block:: html
here is the spoiler content
it will be hidden
An inline spoiler is surrounded with ``>!`` and ``!<``:
.. code-block:: text
this is the >! hidden text !<
Will be converted into:
.. code-block:: html
this is the hidden text
This plugin is **NOT ENABLED** by default in ``mistune.html()``. To enable
**spoiler** plugin with your own markdown instance::
markdown = mistune.create_markdown(plugins=['spoiler'])
Another way to create your own Markdown instance::
from mistune.plugins.spoiler import spoiler
renderer = mistune.HTMLRenderer()
markdown = mistune.Markdown(renderer, plugins=[spoiler])
mistune-3.1.3/docs/renderers.rst 0000664 0000000 0000000 00000011337 14766552020 0016671 0 ustar 00root root 0000000 0000000 .. _renderers:
Renderers
=========
Mistune has several built-in renderers, including:
- :class:`mistune.renderers.html.HTMLRenderer`
- :class:`mistune.renderers.markdown.MarkdownRenderer`
- :class:`mistune.renderers.rst.RSTRenderer`
You're welcome to contribute more renderers.
Customize HTMLRenderer
----------------------
You can customize HTML output with your own renderers. Take an example, we're going
to add an inline math syntax like below:
.. code::
`$a^2=4$`
To render this syntax, we can create a subclass of ``mistune.HTMLRenderer``:
.. code-block:: python
from mistune import HTMLRenderer
class MyRenderer(HTMLRenderer):
def codespan(self, text):
if text.startswith('$') and text.endswith('$'):
return '' + escape(text) + ''
return '' + escape(text) + ''
# use customized renderer
markdown = mistune.create_markdown(renderer=MyRenderer())
print(markdown('hi `$a^2=4$`'))
Available methods
~~~~~~~~~~~~~~~~~
Here is a a list of available renderer functions for ``HTMLRenderer``, including methods on plugins:
.. code-block::
# inline level
text(self, text)
link(self, text, url, title=None)
image(self, alt, url, title=None)
emphasis(self, text)
strong(self, text)
codespan(self, text)
linebreak(self)
softbreak(self)
inline_html(self, html)
# block level
paragraph(self, text)
heading(self, text, level, **attrs)
blank_line(self)
thematic_break(self)
block_text(self, text)
block_code(self, code, info=None)
block_quote(self, text)
block_html(self, html)
block_error(self, html)
list(self, text, ordered, **attrs)
list_item(self, text, **attrs)
# provided by strikethrough plugin
strikethrough(self, text)
# provided by mark plugin
mark(self, text)
# provided by insert plugin
insert(self, text)
# provided by subscript plugin
subscript(self, text)
# provided by abbr plugin
abbr(self, text, title)
# provided by ruby plugin
ruby(self, text, rt)
# provided by task_lists plugin
task_list_item(self, text, checked=False, **attrs)
# provide by table plugin
table(self, text)
table_head(self, text)
table_body(self, text)
table_row(self, text)
table_cell(self, text, align=None, head=False)
# provided by footnotes plugin
footnote_ref(self, key, index)
footnotes(self, text)
footnote_item(self, text, key, index)
# provide by def_list plugin
def_list(self, text)
def_list_head(self, text)
def_list_item(self, text)
# provide by math plugin
block_math(self, text)
inline_math(self, text)
RestructuredText Renderer
-------------------------
The ``RSTRenderer`` can be used to convert markdown text to RestructuredText.
.. code-block:: python
from mistune.renderers.rst import RSTRenderer
convert_rst = mistune.create_markdown(renderer=RSTRenderer())
convert_rst(your_markdown_text)
Markdown Renderer
-----------------
The ``MarkdownRenderer`` can be used to reformat your Markdown text.
.. code-block:: python
from mistune.renderers.markdown import MarkdownRenderer
format_markdown = mistune.create_markdown(renderer=MarkdownRenderer())
format_markdown(your_markdown_text)
With plugins
~~~~~~~~~~~~
The original ``MarkdownRenderer`` can **ONLY** render the basic Markdown syntax.
If you're using plugins, you would need to customize ``MarkdownRenderer`` with
extra render methods. Take an example, you are going to add the :ref:`strikethrough`
plugin:
.. code-block:: python
from mistune.renderers.markdown import MarkdownRenderer
class MyRenderer(MarkdownRenderer):
def strikethrough(self, token, state):
return '~~' + self.render_children(token, state) + '~~'
format_markdown = mistune.create_markdown(renderer=MarkdownRenderer(), plugins=['strikethrough'])
format_markdown(your_markdown_text)
Default methods
~~~~~~~~~~~~~~~
Here is a a list of default renderer functions of ``MarkdownRenderer``:
.. code-block::
# inline level
text(self, token, state)
link(self, token, state)
image(self, token, state)
emphasis(self, token, state)
strong(self, token, state)
codespan(self, token, state)
linebreak(self, token, state)
softbreak(self, token, state)
inline_html(self, token, state)
# block level
paragraph(self, token, state)
heading(self, token, state)
blank_line(self, token, state)
thematic_break(self, token, state)
block_text(self, token, state)
block_code(self, token, state)
block_quote(self, token, state)
block_html(self, token, state)
block_error(self, token, state)
list(self, token, state)
mistune-3.1.3/docs/upgrade.rst 0000664 0000000 0000000 00000002703 14766552020 0016324 0 ustar 00root root 0000000 0000000 Upgrade Guide
=============
Upgrade from v2 to v3
---------------------
HTMLRenderer
~~~~~~~~~~~~
When customizing renderers, these methods' parameters are changed:
.. code-block:: diff
- link(self, link, text=None, title=None)
+ link(self, text, url, title=None)
- image(self, src, alt="", title=None)
+ image(self, text, url, title=None)
- heading(self, text, level)
+ heading(self, text, level, **attrs)
- list(self, text, ordered, level, start=None)
+ list(self, text, ordered, **attrs)
- list_item(self, text, level)
+ list_item(self, text)
- table_cell(self, text, align=None, is_head=False)
+ table_cell(self, text, align=None, head=False)
For plugins:
.. code-block:: diff
- abbr(self, key, definition)
+ abbr(self, text: str, title: str)
- task_list_item(self, text: str, level: int, checked: bool)
+ task_list_item(self, text: str, checked: bool)
AstRenderer
~~~~~~~~~~~
There is no ``AstRenderer`` in v3, just pass ``None`` or ``'ast'`` to ``create_markdown``::
import mistune
md = mistune.create_markdown(renderer='ast') # or render=None
md('...markdown text...')
Plugins
~~~~~~~
Please check the advanced guide and built-in plugins source code to find
out how to write a mistune plugin.
Directives
~~~~~~~~~~
Find out all the details in :ref:`directives`. In v3, there is one more
style of directive -- fenced style directive.
mistune-3.1.3/pyproject.toml 0000664 0000000 0000000 00000003772 14766552020 0016136 0 ustar 00root root 0000000 0000000 [project]
name = "mistune"
description = "A sane and fast Markdown parser with useful plugins and renderers"
authors = [{name = "Hsiaoming Yang", email="me@lepture.com"}]
dependencies = [
"typing-extensions; python_version<'3.11'",
]
license = {text = "BSD-3-Clause"}
dynamic = ["version"]
requires-python = ">=3.8"
readme = "README.rst"
classifiers = [
"Development Status :: 4 - Beta",
"Environment :: Console",
"Environment :: Web Environment",
"Intended Audience :: Developers",
"License :: OSI Approved :: BSD License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3.13",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
"Topic :: Text Processing :: Markup",
]
[project.urls]
Documentation = "https://mistune.lepture.com/"
Source = "https://github.com/lepture/mistune"
Donate = "https://github.com/sponsors/lepture"
[build-system]
requires = ["setuptools"]
build-backend = "setuptools.build_meta"
[dependency-groups]
dev = [
"mypy",
"pytest",
"pytest-cov",
"ruff",
]
docs = [
"shibuya",
"sphinx",
"sphinx-copybutton",
"sphinx-design",
]
[tool.setuptools.dynamic]
version = {attr = "mistune.__version__"}
[tool.setuptools.packages.find]
where = ["src"]
[tool.setuptools.package-data]
mistune = ["py.typed"]
[tool.ruff]
line-length = 120
[tool.pytest.ini_options]
pythonpath = ["src", "."]
testpaths = ["tests"]
filterwarnings = ["error"]
[tool.coverage.run]
branch = true
source = ["mistune"]
[tool.coverage.paths]
source = ["src"]
[tool.coverage.report]
exclude_lines = [
"pragma: no cover",
"def __repr__",
"raise NotImplementedError",
"@(abc\\.)?abstractmethod",
]
mistune-3.1.3/requirements-dev.lock 0000664 0000000 0000000 00000001224 14766552020 0017361 0 ustar 00root root 0000000 0000000 # This file was autogenerated by uv via the following command:
# uv export --no-hashes -o requirements-dev.lock
-e .
colorama==0.4.6 ; sys_platform == 'win32'
coverage==7.6.1 ; python_full_version < '3.9'
coverage==7.7.0 ; python_full_version >= '3.9'
exceptiongroup==1.2.2 ; python_full_version < '3.11'
iniconfig==2.0.0
mypy==1.14.1 ; python_full_version < '3.9'
mypy==1.15.0 ; python_full_version >= '3.9'
mypy-extensions==1.0.0
packaging==24.2
pluggy==1.5.0
pytest==8.3.5
pytest-cov==5.0.0 ; python_full_version < '3.9'
pytest-cov==6.0.0 ; python_full_version >= '3.9'
ruff==0.11.0
tomli==2.2.1 ; python_full_version <= '3.11'
typing-extensions==4.12.2
mistune-3.1.3/requirements-docs.lock 0000664 0000000 0000000 00000004457 14766552020 0017546 0 ustar 00root root 0000000 0000000 # This file was autogenerated by uv via the following command:
# uv export --no-hashes --group docs -o requirements-docs.lock
-e .
alabaster==0.7.13 ; python_full_version < '3.9'
alabaster==0.7.16 ; python_full_version == '3.9.*'
alabaster==1.0.0 ; python_full_version >= '3.10'
babel==2.17.0
certifi==2025.1.31
charset-normalizer==3.4.1
colorama==0.4.6 ; sys_platform == 'win32'
docutils==0.20.1 ; python_full_version < '3.9'
docutils==0.21.2 ; python_full_version >= '3.9'
exceptiongroup==1.2.2 ; python_full_version < '3.11'
idna==3.10
imagesize==1.4.1
importlib-metadata==8.5.0 ; python_full_version < '3.9'
importlib-metadata==8.6.1 ; python_full_version == '3.9.*'
iniconfig==2.0.0
jinja2==3.1.6
markupsafe==2.1.5 ; python_full_version < '3.9'
markupsafe==3.0.2 ; python_full_version >= '3.9'
mypy==1.14.1 ; python_full_version < '3.9'
mypy==1.15.0 ; python_full_version >= '3.9'
mypy-extensions==1.0.0
packaging==24.2
pluggy==1.5.0
pygments==2.19.1
pytest==8.3.5
pytz==2025.1 ; python_full_version < '3.9'
requests==2.32.3
roman-numerals-py==3.1.0 ; python_full_version >= '3.11'
ruff==0.11.0
shibuya==2025.2.28
snowballstemmer==2.2.0
sphinx==7.1.2 ; python_full_version < '3.9'
sphinx==7.4.7 ; python_full_version == '3.9.*'
sphinx==8.1.3 ; python_full_version == '3.10.*'
sphinx==8.2.3 ; python_full_version >= '3.11'
sphinx-copybutton==0.5.2
sphinx-design==0.5.0 ; python_full_version < '3.9'
sphinx-design==0.6.1 ; python_full_version >= '3.9'
sphinxcontrib-applehelp==1.0.4 ; python_full_version < '3.9'
sphinxcontrib-applehelp==2.0.0 ; python_full_version >= '3.9'
sphinxcontrib-devhelp==1.0.2 ; python_full_version < '3.9'
sphinxcontrib-devhelp==2.0.0 ; python_full_version >= '3.9'
sphinxcontrib-htmlhelp==2.0.1 ; python_full_version < '3.9'
sphinxcontrib-htmlhelp==2.1.0 ; python_full_version >= '3.9'
sphinxcontrib-jsmath==1.0.1
sphinxcontrib-qthelp==1.0.3 ; python_full_version < '3.9'
sphinxcontrib-qthelp==2.0.0 ; python_full_version >= '3.9'
sphinxcontrib-serializinghtml==1.1.5 ; python_full_version < '3.9'
sphinxcontrib-serializinghtml==2.0.0 ; python_full_version >= '3.9'
tomli==2.2.1 ; python_full_version < '3.11'
typing-extensions==4.12.2
urllib3==2.2.3 ; python_full_version < '3.9'
urllib3==2.3.0 ; python_full_version >= '3.9'
zipp==3.20.2 ; python_full_version < '3.9'
zipp==3.21.0 ; python_full_version == '3.9.*'
mistune-3.1.3/serve-doc.py 0000664 0000000 0000000 00000000211 14766552020 0015444 0 ustar 00root root 0000000 0000000 from livereload import Server, shell
app = Server()
app.watch("docs", shell("make build-docs"), delay=2)
app.serve(root="build/_html/")
mistune-3.1.3/setup.py 0000664 0000000 0000000 00000000064 14766552020 0014723 0 ustar 00root root 0000000 0000000 from setuptools import setup
setup(name="mistune")
mistune-3.1.3/src/ 0000775 0000000 0000000 00000000000 14766552020 0014000 5 ustar 00root root 0000000 0000000 mistune-3.1.3/src/mistune/ 0000775 0000000 0000000 00000000000 14766552020 0015464 5 ustar 00root root 0000000 0000000 mistune-3.1.3/src/mistune/__init__.py 0000664 0000000 0000000 00000005572 14766552020 0017606 0 ustar 00root root 0000000 0000000 """
mistune
~~~~~~~
A fast yet powerful Python Markdown parser with renderers and
plugins, compatible with sane CommonMark rules.
Documentation: https://mistune.lepture.com/
"""
from typing import Any, Dict, Iterable, List, Optional, Tuple, Union, Literal
from .block_parser import BlockParser
from .core import BaseRenderer, BlockState, InlineState
from .inline_parser import InlineParser
from .markdown import Markdown
from .plugins import Plugin, PluginRef, import_plugin
from .renderers.html import HTMLRenderer
from .util import escape, escape_url, safe_entity, unikey
RendererRef = Union[Literal["html", "ast"], BaseRenderer]
def create_markdown(
escape: bool = True,
hard_wrap: bool = False,
renderer: Optional[RendererRef] = "html",
plugins: Optional[Iterable[PluginRef]] = None,
) -> Markdown:
"""Create a Markdown instance based on the given condition.
:param escape: Boolean. If using html renderer, escape html.
:param hard_wrap: Boolean. Break every new line into ``
``.
:param renderer: renderer instance, default is HTMLRenderer.
:param plugins: List of plugins.
This method is used when you want to re-use a Markdown instance::
markdown = create_markdown(
escape=False,
hard_wrap=True,
)
# re-use markdown function
markdown('.... your text ...')
"""
if renderer == "ast":
# explicit and more similar to 2.x's API
renderer = None
elif renderer == "html":
renderer = HTMLRenderer(escape=escape)
inline = InlineParser(hard_wrap=hard_wrap)
real_plugins: Optional[Iterable[Plugin]] = None
if plugins is not None:
real_plugins = [import_plugin(n) for n in plugins]
return Markdown(renderer=renderer, inline=inline, plugins=real_plugins)
html: Markdown = create_markdown(escape=False, plugins=["strikethrough", "footnotes", "table", "speedup"])
__cached_parsers: Dict[Tuple[bool, Optional[RendererRef], Optional[Iterable[Any]]], Markdown] = {}
def markdown(
text: str,
escape: bool = True,
renderer: Optional[RendererRef] = "html",
plugins: Optional[Iterable[Any]] = None,
) -> Union[str, List[Dict[str, Any]]]:
if renderer == "ast":
# explicit and more similar to 2.x's API
renderer = None
key = (escape, renderer, plugins)
if key in __cached_parsers:
return __cached_parsers[key](text)
md = create_markdown(escape=escape, renderer=renderer, plugins=plugins)
# improve the speed for markdown parser creation
__cached_parsers[key] = md
return md(text)
__all__ = [
"Markdown",
"HTMLRenderer",
"BlockParser",
"BlockState",
"BaseRenderer",
"InlineParser",
"InlineState",
"escape",
"escape_url",
"safe_entity",
"unikey",
"html",
"create_markdown",
"markdown",
]
__version__ = "3.1.3"
__homepage__ = "https://mistune.lepture.com/"
mistune-3.1.3/src/mistune/__main__.py 0000664 0000000 0000000 00000006207 14766552020 0017563 0 ustar 00root root 0000000 0000000 import argparse
import sys
from typing import TYPE_CHECKING, Optional
from . import __version__ as version
from . import create_markdown
from .renderers.markdown import MarkdownRenderer
from .renderers.rst import RSTRenderer
if TYPE_CHECKING:
from .core import BaseRenderer
from .markdown import Markdown
def _md(args: argparse.Namespace) -> "Markdown":
if args.plugin:
plugins = args.plugin
else:
# default plugins
plugins = ["strikethrough", "footnotes", "table", "speedup"]
if args.renderer == "rst":
renderer: "BaseRenderer" = RSTRenderer()
elif args.renderer == "markdown":
renderer = MarkdownRenderer()
else:
renderer = args.renderer
return create_markdown(
escape=args.escape,
hard_wrap=args.hardwrap,
renderer=renderer,
plugins=plugins,
)
def _output(text: str, args: argparse.Namespace) -> None:
if args.output:
with open(args.output, "w") as f:
f.write(text)
else:
print(text)
CMD_HELP = """Mistune, a sane and fast python markdown parser.
Here are some use cases of the command line tool:
$ python -m mistune -m "Hi **Markdown**"
Hi Markdown
$ python -m mistune -f README.md
...
$ cat README.md | python -m mistune
...
"""
def cli() -> None:
parser = argparse.ArgumentParser(
prog="python -m mistune",
description=CMD_HELP,
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument(
"-m",
"--message",
help="the markdown message to convert",
)
parser.add_argument(
"-f",
"--file",
help="the markdown file to convert",
)
parser.add_argument(
"-p",
"--plugin",
metavar="NAME",
action="extend",
nargs="+",
help="specifiy a plugin to use",
)
parser.add_argument(
"--escape",
action="store_true",
help="turn on escape option",
)
parser.add_argument(
"--hardwrap",
action="store_true",
help="turn on hardwrap option",
)
parser.add_argument(
"-o",
"--output",
help="write the rendered result into file",
)
parser.add_argument(
"-r",
"--renderer",
default="html",
help="specify the output renderer",
)
parser.add_argument("--version", action="version", version="mistune " + version)
args = parser.parse_args()
message = args.message
if not message and not args.file:
message = read_stdin()
if message:
md = _md(args)
text = md(message)
assert isinstance(text, str)
_output(text, args)
elif args.file:
md = _md(args)
text = md.read(args.file)[0]
assert isinstance(text, str)
_output(text, args)
else:
print("You MUST specify a message or file")
sys.exit(1)
def read_stdin() -> Optional[str]:
is_stdin_pipe = not sys.stdin.isatty()
if is_stdin_pipe:
return sys.stdin.read()
else:
return None
if __name__ == "__main__":
cli()
mistune-3.1.3/src/mistune/block_parser.py 0000664 0000000 0000000 00000040060 14766552020 0020504 0 ustar 00root root 0000000 0000000 import re
from typing import Optional, List, Tuple, Match, Pattern
from .util import (
unikey,
escape_url,
expand_tab,
expand_leading_tab,
)
from .core import Parser, BlockState
from .helpers import (
LINK_LABEL,
HTML_TAGNAME,
HTML_ATTRIBUTES,
BLOCK_TAGS,
PRE_TAGS,
unescape_char,
parse_link_href,
parse_link_title,
)
from .list_parser import parse_list, LIST_PATTERN
_INDENT_CODE_TRIM = re.compile(r"^ {1,4}", flags=re.M)
_ATX_HEADING_TRIM = re.compile(r"(\s+|^)#+\s*$")
_BLOCK_QUOTE_TRIM = re.compile(r"^ ?", flags=re.M)
_BLOCK_QUOTE_LEADING = re.compile(r"^ *>", flags=re.M)
_LINE_BLANK_END = re.compile(r"\n[ \t]*\n$")
_BLANK_TO_LINE = re.compile(r"[ \t]*\n")
_BLOCK_TAGS_PATTERN = "(" + "|".join(BLOCK_TAGS) + "|" + "|".join(PRE_TAGS) + ")"
_OPEN_TAG_END = re.compile(HTML_ATTRIBUTES + r"[ \t]*>[ \t]*(?:\n|$)")
_CLOSE_TAG_END = re.compile(r"[ \t]*>[ \t]*(?:\n|$)")
_STRICT_BLOCK_QUOTE = re.compile(r"( {0,3}>[^\n]*(?:\n|$))+")
class BlockParser(Parser[BlockState]):
state_cls = BlockState
BLANK_LINE = re.compile(r"(^[ \t\v\f]*\n)+", re.M)
RAW_HTML = (
r"^ {0,3}("
r"#{1,6})(?!#+)(?P[ \t]*|[ \t]+.*?)$",
"setex_heading": r"^ {0,3}(?P=|-){1,}[ \t]*$",
"fenced_code": (
r"^(?P {0,3})(?P`{3,}|~{3,})"
r"[ \t]*(?P.*?)$"
),
"indent_code": (
r"^(?: {4}| *\t)[^\n]+(?:\n+|$)"
r"((?:(?: {4}| *\t)[^\n]+(?:\n+|$))|\s)*"
),
"thematic_break": r"^ {0,3}((?:-[ \t]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})$",
"ref_link": r"^ {0,3}\[(?P" + LINK_LABEL + r")\]:",
"block_quote": r"^ {0,3}>(?P.*?)$",
"list": LIST_PATTERN,
"block_html": BLOCK_HTML,
"raw_html": RAW_HTML,
}
DEFAULT_RULES = (
"fenced_code",
"indent_code",
"atx_heading",
"setex_heading",
"thematic_break",
"block_quote",
"list",
"ref_link",
"raw_html",
"blank_line",
)
def __init__(
self,
block_quote_rules: Optional[List[str]] = None,
list_rules: Optional[List[str]] = None,
max_nested_level: int = 6,
):
super(BlockParser, self).__init__()
if block_quote_rules is None:
block_quote_rules = list(self.DEFAULT_RULES)
if list_rules is None:
list_rules = list(self.DEFAULT_RULES)
self.block_quote_rules = block_quote_rules
self.list_rules = list_rules
self.max_nested_level = max_nested_level
# register default parse methods
self._methods = {name: getattr(self, "parse_" + name) for name in self.SPECIFICATION}
def parse_blank_line(self, m: Match[str], state: BlockState) -> int:
"""Parse token for blank lines."""
state.append_token({"type": "blank_line"})
return m.end()
def parse_thematic_break(self, m: Match[str], state: BlockState) -> int:
"""Parse token for thematic break, e.g. ``
`` tag in HTML."""
state.append_token({"type": "thematic_break"})
# $ does not count '\n'
return m.end() + 1
def parse_indent_code(self, m: Match[str], state: BlockState) -> int:
"""Parse token for code block which is indented by 4 spaces."""
# it is a part of the paragraph
end_pos = state.append_paragraph()
if end_pos:
return end_pos
code = m.group(0)
code = expand_leading_tab(code)
code = _INDENT_CODE_TRIM.sub("", code)
code = code.strip("\n")
state.append_token({"type": "block_code", "raw": code, "style": "indent"})
return m.end()
def parse_fenced_code(self, m: Match[str], state: BlockState) -> Optional[int]:
"""Parse token for fenced code block. A fenced code block is started with
3 or more backtick(`) or tilde(~).
An example of a fenced code block:
.. code-block:: markdown
```python
def markdown(text):
return mistune.html(text)
```
"""
spaces = m.group("fenced_1")
marker = m.group("fenced_2")
info = m.group("fenced_3")
c = marker[0]
if info and c == "`":
# CommonMark Example 145
# Info strings for backtick code blocks cannot contain backticks
if info.find(c) != -1:
return None
_end = re.compile(r"^ {0,3}" + c + "{" + str(len(marker)) + r",}[ \t]*(?:\n|$)", re.M)
cursor_start = m.end() + 1
m2 = _end.search(state.src, cursor_start)
if m2:
code = state.src[cursor_start : m2.start()]
end_pos = m2.end()
else:
code = state.src[cursor_start:]
end_pos = state.cursor_max
if spaces and code:
_trim_pattern = re.compile("^ {0," + str(len(spaces)) + "}", re.M)
code = _trim_pattern.sub("", code)
token = {"type": "block_code", "raw": code, "style": "fenced", "marker": marker}
if info:
info = unescape_char(info)
token["attrs"] = {"info": info.strip()}
state.append_token(token)
return end_pos
def parse_atx_heading(self, m: Match[str], state: BlockState) -> int:
"""Parse token for ATX heading. An ATX heading is started with 1 to 6
symbol of ``#``."""
level = len(m.group("atx_1"))
text = m.group("atx_2").strip()
# remove last #
if text:
text = _ATX_HEADING_TRIM.sub("", text)
token = {"type": "heading", "text": text, "attrs": {"level": level}, "style": "atx"}
state.append_token(token)
return m.end() + 1
def parse_setex_heading(self, m: Match[str], state: BlockState) -> Optional[int]:
"""Parse token for setex style heading. A setex heading syntax looks like:
.. code-block:: markdown
H1 title
========
"""
last_token = state.last_token()
if last_token and last_token["type"] == "paragraph":
level = 1 if m.group("setext_1") == "=" else 2
last_token["type"] = "heading"
last_token["style"] = "setext"
last_token["attrs"] = {"level": level}
return m.end() + 1
sc = self.compile_sc(["thematic_break", "list"])
m2 = sc.match(state.src, state.cursor)
if m2:
return self.parse_method(m2, state)
return None
def parse_ref_link(self, m: Match[str], state: BlockState) -> Optional[int]:
"""Parse link references and save the link information into ``state.env``.
Here is an example of a link reference:
.. code-block:: markdown
a [link][example]
[example]: https://example.com "Optional title"
This method will save the link reference into ``state.env`` as::
state.env['ref_links']['example'] = {
'url': 'https://example.com',
'title': "Optional title",
}
"""
end_pos = state.append_paragraph()
if end_pos:
return end_pos
label = m.group("reflink_1")
key = unikey(label)
if not key:
return None
href, href_pos = parse_link_href(state.src, m.end(), block=True)
if href is None:
return None
assert href_pos is not None
_blank = self.BLANK_LINE.search(state.src, href_pos)
if _blank:
max_pos = _blank.start()
else:
max_pos = state.cursor_max
title, title_pos = parse_link_title(state.src, href_pos, max_pos)
if title_pos:
m2 = _BLANK_TO_LINE.match(state.src, title_pos)
if m2:
title_pos = m2.end()
else:
title_pos = None
title = None
if title_pos is None:
m3 = _BLANK_TO_LINE.match(state.src, href_pos)
if m3:
href_pos = m3.end()
else:
href_pos = None
href = None
end_pos = title_pos or href_pos
if not end_pos:
return None
if key not in state.env["ref_links"]:
assert href is not None
href = unescape_char(href)
data = {"url": escape_url(href), "label": label}
if title:
data["title"] = title
state.env["ref_links"][key] = data
return end_pos
def extract_block_quote(self, m: Match[str], state: BlockState) -> Tuple[str, Optional[int]]:
"""Extract text and cursor end position of a block quote."""
# cleanup at first to detect if it is code block
text = m.group("quote_1") + "\n"
text = expand_leading_tab(text, 3)
text = _BLOCK_QUOTE_TRIM.sub("", text)
sc = self.compile_sc(["blank_line", "indent_code", "fenced_code"])
require_marker = bool(sc.match(text))
state.cursor = m.end() + 1
end_pos: Optional[int] = None
if require_marker:
m2 = _STRICT_BLOCK_QUOTE.match(state.src, state.cursor)
if m2:
quote = m2.group(0)
quote = _BLOCK_QUOTE_LEADING.sub("", quote)
quote = expand_leading_tab(quote, 3)
quote = _BLOCK_QUOTE_TRIM.sub("", quote)
text += quote
state.cursor = m2.end()
else:
prev_blank_line = False
break_sc = self.compile_sc(
[
"blank_line",
"thematic_break",
"fenced_code",
"list",
"block_html",
]
)
while state.cursor < state.cursor_max:
m3 = _STRICT_BLOCK_QUOTE.match(state.src, state.cursor)
if m3:
quote = m3.group(0)
quote = _BLOCK_QUOTE_LEADING.sub("", quote)
quote = expand_leading_tab(quote, 3)
quote = _BLOCK_QUOTE_TRIM.sub("", quote)
text += quote
state.cursor = m3.end()
if not quote.strip():
prev_blank_line = True
else:
prev_blank_line = bool(_LINE_BLANK_END.search(quote))
continue
if prev_blank_line:
# CommonMark Example 249
# because of laziness, a blank line is needed between
# a block quote and a following paragraph
break
m4 = break_sc.match(state.src, state.cursor)
if m4:
end_pos = self.parse_method(m4, state)
if end_pos:
break
# lazy continuation line
pos = state.find_line_end()
line = state.get_text(pos)
line = expand_leading_tab(line, 3)
text += line
state.cursor = pos
# according to CommonMark Example 6, the second tab should be
# treated as 4 spaces
return expand_tab(text), end_pos
def parse_block_quote(self, m: Match[str], state: BlockState) -> int:
"""Parse token for block quote. Here is an example of the syntax:
.. code-block:: markdown
> a block quote starts
> with right arrows
"""
text, end_pos = self.extract_block_quote(m, state)
# scan children state
child = state.child_state(text)
if state.depth() >= self.max_nested_level - 1:
rules = list(self.block_quote_rules)
rules.remove("block_quote")
else:
rules = self.block_quote_rules
self.parse(child, rules)
token = {"type": "block_quote", "children": child.tokens}
if end_pos:
state.prepend_token(token)
return end_pos
state.append_token(token)
return state.cursor
def parse_list(self, m: Match[str], state: BlockState) -> int:
"""Parse tokens for ordered and unordered list."""
return parse_list(self, m, state)
def parse_block_html(self, m: Match[str], state: BlockState) -> Optional[int]:
return self.parse_raw_html(m, state)
def parse_raw_html(self, m: Match[str], state: BlockState) -> Optional[int]:
marker = m.group(0).strip()
# rule 2
if marker == "", m.end())
# rule 3
if marker == "", m.end())
# rule 5
if marker == "", m.end())
# rule 4
if marker.startswith("", m.end())
close_tag = None
open_tag = None
if marker.startswith(""
return _parse_html_to_end(state, end_tag, m.end())
# rule 6
if open_tag in BLOCK_TAGS:
return _parse_html_to_newline(state, self.BLANK_LINE)
# Blocks of type 7 may not interrupt a paragraph.
end_pos = state.append_paragraph()
if end_pos:
return end_pos
# rule 7
start_pos = m.end()
end_pos = state.find_line_end()
if (open_tag and _OPEN_TAG_END.match(state.src, start_pos, end_pos)) or (
close_tag and _CLOSE_TAG_END.match(state.src, start_pos, end_pos)
):
return _parse_html_to_newline(state, self.BLANK_LINE)
return None
def parse(self, state: BlockState, rules: Optional[List[str]] = None) -> None:
sc = self.compile_sc(rules)
while state.cursor < state.cursor_max:
m = sc.search(state.src, state.cursor)
if not m:
break
end_pos = m.start()
if end_pos > state.cursor:
text = state.get_text(end_pos)
state.add_paragraph(text)
state.cursor = end_pos
end_pos2 = self.parse_method(m, state)
if end_pos2:
state.cursor = end_pos2
else:
end_pos3 = state.find_line_end()
text = state.get_text(end_pos3)
state.add_paragraph(text)
state.cursor = end_pos3
if state.cursor < state.cursor_max:
text = state.src[state.cursor :]
state.add_paragraph(text)
state.cursor = state.cursor_max
def _parse_html_to_end(state: BlockState, end_marker: str, start_pos: int) -> int:
marker_pos = state.src.find(end_marker, start_pos)
if marker_pos == -1:
text = state.src[state.cursor :]
end_pos = state.cursor_max
else:
text = state.get_text(marker_pos)
state.cursor = marker_pos
end_pos = state.find_line_end()
text += state.get_text(end_pos)
state.append_token({"type": "block_html", "raw": text})
return end_pos
def _parse_html_to_newline(state: BlockState, newline: Pattern[str]) -> int:
m = newline.search(state.src, state.cursor)
if m:
end_pos = m.start()
text = state.get_text(end_pos)
else:
text = state.src[state.cursor :]
end_pos = state.cursor_max
state.append_token({"type": "block_html", "raw": text})
return end_pos
mistune-3.1.3/src/mistune/core.py 0000664 0000000 0000000 00000016660 14766552020 0016777 0 ustar 00root root 0000000 0000000 import re
import sys
from typing import (
Any,
Callable,
ClassVar,
Dict,
Generic,
Iterable,
List,
Match,
MutableMapping,
Optional,
Pattern,
Type,
TypeVar,
Union,
cast,
)
if sys.version_info >= (3, 11):
from typing import Self
else:
from typing_extensions import Self
_LINE_END = re.compile(r"\n|$")
class BlockState:
"""The state to save block parser's cursor and tokens."""
src: str
tokens: List[Dict[str, Any]]
cursor: int
cursor_max: int
list_tight: bool
parent: Any
env: MutableMapping[str, Any]
def __init__(self, parent: Optional[Any] = None) -> None:
self.src = ""
self.tokens = []
# current cursor position
self.cursor = 0
self.cursor_max = 0
# for list and block quote chain
self.list_tight = True
self.parent = parent
# for saving def references
if parent:
self.env = parent.env
else:
self.env = {"ref_links": {}}
def child_state(self, src: str) -> "BlockState":
child = self.__class__(self)
child.process(src)
return child
def process(self, src: str) -> None:
self.src = src
self.cursor_max = len(src)
def find_line_end(self) -> int:
m = _LINE_END.search(self.src, self.cursor)
assert m is not None
return m.end()
def get_text(self, end_pos: int) -> str:
return self.src[self.cursor : end_pos]
def last_token(self) -> Any:
if self.tokens:
return self.tokens[-1]
def prepend_token(self, token: Dict[str, Any]) -> None:
"""Insert token before the last token."""
self.tokens.insert(len(self.tokens) - 1, token)
def append_token(self, token: Dict[str, Any]) -> None:
"""Add token to the end of token list."""
self.tokens.append(token)
def add_paragraph(self, text: str) -> None:
last_token = self.last_token()
if last_token and last_token["type"] == "paragraph":
last_token["text"] += text
else:
self.tokens.append({"type": "paragraph", "text": text})
def append_paragraph(self) -> Optional[int]:
last_token = self.last_token()
if last_token and last_token["type"] == "paragraph":
pos = self.find_line_end()
last_token["text"] += self.get_text(pos)
return pos
return None
def depth(self) -> int:
d = 0
parent = self.parent
while parent:
d += 1
parent = parent.parent
return d
class InlineState:
"""The state to save inline parser's tokens."""
def __init__(self, env: MutableMapping[str, Any]):
self.env = env
self.src = ""
self.tokens: List[Dict[str, Any]] = []
self.in_image = False
self.in_link = False
self.in_emphasis = False
self.in_strong = False
def prepend_token(self, token: Dict[str, Any]) -> None:
"""Insert token before the last token."""
self.tokens.insert(len(self.tokens) - 1, token)
def append_token(self, token: Dict[str, Any]) -> None:
"""Add token to the end of token list."""
self.tokens.append(token)
def copy(self) -> "InlineState":
"""Create a copy of current state."""
state = self.__class__(self.env)
state.in_image = self.in_image
state.in_link = self.in_link
state.in_emphasis = self.in_emphasis
state.in_strong = self.in_strong
return state
ST = TypeVar("ST", InlineState, BlockState)
class Parser(Generic[ST]):
sc_flag: "re._FlagsType" = re.M
state_cls: Type[ST]
SPECIFICATION: ClassVar[Dict[str, str]] = {}
DEFAULT_RULES: ClassVar[Iterable[str]] = []
def __init__(self) -> None:
self.specification = self.SPECIFICATION.copy()
self.rules = list(self.DEFAULT_RULES)
self._methods: Dict[
str,
Callable[[Match[str], ST], Optional[int]],
] = {}
self.__sc: Dict[str, Pattern[str]] = {}
def compile_sc(self, rules: Optional[List[str]] = None) -> Pattern[str]:
if rules is None:
key = "$"
rules = self.rules
else:
key = "|".join(rules)
sc = self.__sc.get(key)
if sc:
return sc
regex = "|".join(r"(?P<%s>%s)" % (k, self.specification[k]) for k in rules)
sc = re.compile(regex, self.sc_flag)
self.__sc[key] = sc
return sc
def register(
self,
name: str,
pattern: Union[str, None],
func: Callable[[Self, Match[str], ST], Optional[int]],
before: Optional[str] = None,
) -> None:
"""Register a new rule to parse the token. This method is usually used to
create a new plugin.
:param name: name of the new grammar
:param pattern: regex pattern in string
:param func: the parsing function
:param before: insert this rule before a built-in rule
"""
self._methods[name] = lambda m, state: func(self, m, state)
if pattern:
self.specification[name] = pattern
if name not in self.rules:
self.insert_rule(self.rules, name, before=before)
def register_rule(self, name: str, pattern: str, func: Any) -> None:
raise DeprecationWarning("This plugin is not compatible with mistune v3.")
@staticmethod
def insert_rule(rules: List[str], name: str, before: Optional[str] = None) -> None:
if before:
try:
index = rules.index(before)
rules.insert(index, name)
except ValueError:
rules.append(name)
else:
rules.append(name)
def parse_method(self, m: Match[str], state: ST) -> Optional[int]:
lastgroup = m.lastgroup
assert lastgroup
func = self._methods[lastgroup]
return func(m, state)
class BaseRenderer(object):
NAME: ClassVar[str] = "base"
def __init__(self) -> None:
self.__methods: Dict[str, Callable[..., str]] = {}
def register(self, name: str, method: Callable[..., str]) -> None:
"""Register a render method for the named token. For example::
def render_wiki(renderer, key, title):
return f'{title}'
renderer.register('wiki', render_wiki)
"""
# bind self into renderer method
self.__methods[name] = lambda *arg, **kwargs: method(self, *arg, **kwargs)
def _get_method(self, name: str) -> Callable[..., str]:
try:
return cast(Callable[..., str], object.__getattribute__(self, name))
except AttributeError:
method = self.__methods.get(name)
if not method:
raise AttributeError('No renderer "{!r}"'.format(name))
return method
def render_token(self, token: Dict[str, Any], state: BlockState) -> str:
func = self._get_method(token["type"])
return func(token, state)
def iter_tokens(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> Iterable[str]:
for tok in tokens:
yield self.render_token(tok, state)
def render_tokens(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str:
return "".join(self.iter_tokens(tokens, state))
def __call__(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str:
return self.render_tokens(tokens, state)
mistune-3.1.3/src/mistune/directives/ 0000775 0000000 0000000 00000000000 14766552020 0017625 5 ustar 00root root 0000000 0000000 mistune-3.1.3/src/mistune/directives/__init__.py 0000664 0000000 0000000 00000001543 14766552020 0021741 0 ustar 00root root 0000000 0000000 from typing import List
from ._base import BaseDirective, DirectiveParser, DirectivePlugin
from ._fenced import FencedDirective
from ._rst import RSTDirective
from .admonition import Admonition
from .image import Figure, Image
from .include import Include
from .toc import TableOfContents
class RstDirective(RSTDirective): # pragma: no cover
def __init__(self, plugins: List[DirectivePlugin]) -> None:
super(RstDirective, self).__init__(plugins)
import warnings
warnings.warn(
"'RstDirective' is deprecated, please use 'RSTDirective' instead.",
DeprecationWarning,
stacklevel=2,
)
__all__ = [
"DirectiveParser",
"BaseDirective",
"DirectivePlugin",
"RSTDirective",
"FencedDirective",
"Admonition",
"TableOfContents",
"Include",
"Image",
"Figure",
]
mistune-3.1.3/src/mistune/directives/_base.py 0000664 0000000 0000000 00000010775 14766552020 0021262 0 ustar 00root root 0000000 0000000 import re
from abc import ABCMeta, abstractmethod
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
Iterable,
List,
Match,
Optional,
Tuple,
Type,
Union,
)
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BlockState
from ..markdown import Markdown
class DirectiveParser(ABCMeta):
name = "directive"
@staticmethod
@abstractmethod
def parse_type(m: Match[str]) -> str:
raise NotImplementedError()
@staticmethod
@abstractmethod
def parse_title(m: Match[str]) -> str:
raise NotImplementedError()
@staticmethod
@abstractmethod
def parse_content(m: Match[str]) -> str:
raise NotImplementedError()
@classmethod
def parse_tokens(cls, block: "BlockParser", text: str, state: "BlockState") -> Iterable[Dict[str, Any]]:
if state.depth() >= block.max_nested_level - 1 and cls.name in block.rules:
rules = list(block.rules)
rules.remove(cls.name)
else:
rules = block.rules
child = state.child_state(text)
block.parse(child, rules)
return child.tokens
@staticmethod
def parse_options(m: Match[str]) -> List[Tuple[str, str]]:
text = m.group("options")
if not text.strip():
return []
options = []
for line in re.split(r"\n+", text):
line = line.strip()[1:]
if not line:
continue
i = line.find(":")
k = line[:i]
v = line[i + 1 :].strip()
options.append((k, v))
return options
class BaseDirective(metaclass=ABCMeta):
parser: Type[DirectiveParser]
directive_pattern: Optional[str] = None
def __init__(self, plugins: List["DirectivePlugin"]):
self._methods: Dict[
str,
Callable[
["BlockParser", Match[str], "BlockState"],
Union[Dict[str, Any], List[Dict[str, Any]]],
],
] = {}
self.__plugins = plugins
def register(
self,
name: str,
fn: Callable[
["BlockParser", Match[str], "BlockState"],
Union[Dict[str, Any], List[Dict[str, Any]]],
],
) -> None:
self._methods[name] = fn
def parse_method(
self, block: "BlockParser", m: Match[str], state: "BlockState"
) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
_type = self.parser.parse_type(m)
method = self._methods.get(_type)
if method:
try:
token = method(block, m, state)
except ValueError as e:
token = {"type": "block_error", "raw": str(e)}
else:
text = m.group(0)
token = {
"type": "block_error",
"raw": text,
}
if isinstance(token, list):
for tok in token:
state.append_token(tok)
else:
state.append_token(token)
return token
@abstractmethod
def parse_directive(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
raise NotImplementedError()
def register_block_parser(self, md: "Markdown", before: Optional[str] = None) -> None:
md.block.register(
self.parser.name,
self.directive_pattern,
self.parse_directive,
before=before,
)
def __call__(self, markdown: "Markdown") -> None:
for plugin in self.__plugins:
plugin.parser = self.parser
plugin(self, markdown)
class DirectivePlugin:
parser: Type[DirectiveParser]
def __init__(self) -> None: ...
def parse_options(self, m: Match[str]) -> List[Tuple[str, str]]:
return self.parser.parse_options(m)
def parse_type(self, m: Match[str]) -> str:
return self.parser.parse_type(m)
def parse_title(self, m: Match[str]) -> str:
return self.parser.parse_title(m)
def parse_content(self, m: Match[str]) -> str:
return self.parser.parse_content(m)
def parse_tokens(self, block: "BlockParser", text: str, state: "BlockState") -> Iterable[Dict[str, Any]]:
return self.parser.parse_tokens(block, text, state)
def parse(
self, block: "BlockParser", m: Match[str], state: "BlockState"
) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
raise NotImplementedError()
def __call__(self, directive: BaseDirective, md: "Markdown") -> None:
raise NotImplementedError()
mistune-3.1.3/src/mistune/directives/_fenced.py 0000664 0000000 0000000 00000011332 14766552020 0021562 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, List, Match, Optional
from ._base import BaseDirective, DirectiveParser, DirectivePlugin
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BlockState
from ..markdown import Markdown
__all__ = ["FencedDirective"]
_type_re = re.compile(r"^ *\{[a-zA-Z0-9_-]+\}")
_directive_re = re.compile(
r"\{(?P[a-zA-Z0-9_-]+)\} *(?P[^\n]*)(?:\n|$)"
r"(?P<options>(?:\:[a-zA-Z0-9_-]+\: *[^\n]*\n+)*)"
r"\n*(?P<text>(?:[^\n]*\n+)*)"
)
class FencedParser(DirectiveParser):
name = "fenced_directive"
@staticmethod
def parse_type(m: Match[str]) -> str:
return m.group("type")
@staticmethod
def parse_title(m: Match[str]) -> str:
return m.group("title")
@staticmethod
def parse_content(m: Match[str]) -> str:
return m.group("text")
class FencedDirective(BaseDirective):
"""A **fenced** style of directive looks like a fenced code block, it is
inspired by markdown-it-docutils. The syntax looks like:
.. code-block:: text
```{directive-type} title
:option-key: option value
:option-key: option value
content text here
```
To use ``FencedDirective``, developers can add it into plugin list in
the :class:`Markdown` instance:
.. code-block:: python
import mistune
from mistune.directives import FencedDirective, Admonition
md = mistune.create_markdown(plugins=[
# ...
FencedDirective([Admonition()]),
])
FencedDirective is using >= 3 backticks or curly-brackets for the fenced
syntax. Developers can change it to other characters, e.g. colon:
.. code-block:: python
directive = FencedDirective([Admonition()], ':')
And then the directive syntax would look like:
.. code-block:: text
::::{note} Nesting directives
You can nest directives by ensuring the start and end fence matching
the length. For instance, in this example, the admonition is started
with 4 colons, then it should end with 4 colons.
You can nest another admonition with other length of colons except 4.
:::{tip} Longer outermost fence
It would be better that you put longer markers for the outer fence,
and shorter markers for the inner fence. In this example, we put 4
colons outsie, and 3 colons inside.
:::
::::
:param plugins: list of directive plugins
:param markers: characters to determine the fence, default is backtick
and curly-bracket
"""
parser = FencedParser
def __init__(self, plugins: List[DirectivePlugin], markers: str = "`~") -> None:
super(FencedDirective, self).__init__(plugins)
self.markers = markers
_marker_pattern = "|".join(re.escape(c) for c in markers)
self.directive_pattern = (
r"^(?P<fenced_directive_mark>(?:" + _marker_pattern + r"){3,})"
r"\{[a-zA-Z0-9_-]+\}"
)
def _process_directive(self, block: "BlockParser", marker: str, start: int, state: "BlockState") -> Optional[int]:
mlen = len(marker)
cursor_start = start + len(marker)
_end_pattern = (
r"^ {0,3}" + marker[0] + "{" + str(mlen) + r",}"
r"[ \t]*(?:\n|$)"
)
_end_re = re.compile(_end_pattern, re.M)
_end_m = _end_re.search(state.src, cursor_start)
if _end_m:
text = state.src[cursor_start : _end_m.start()]
end_pos = _end_m.end()
else:
text = state.src[cursor_start:]
end_pos = state.cursor_max
m = _directive_re.match(text)
if not m:
return None
self.parse_method(block, m, state)
return end_pos
def parse_directive(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
marker = m.group("fenced_directive_mark")
return self._process_directive(block, marker, m.start(), state)
def parse_fenced_code(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
info = m.group("fenced_3")
if not info or not _type_re.match(info):
return block.parse_fenced_code(m, state)
if state.depth() >= block.max_nested_level:
return block.parse_fenced_code(m, state)
marker = m.group("fenced_2")
return self._process_directive(block, marker, m.start(), state)
def __call__(self, md: "Markdown") -> None:
super(FencedDirective, self).__call__(md)
if self.markers == "`~":
md.block.register("fenced_code", None, self.parse_fenced_code)
else:
self.register_block_parser(md, "fenced_code")
mistune-3.1.3/src/mistune/directives/_rst.py 0000664 0000000 0000000 00000004352 14766552020 0021152 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Match, Optional
from ._base import BaseDirective, DirectiveParser
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BlockState
from ..markdown import Markdown
__all__ = ["RSTDirective"]
_directive_re = re.compile(
r"\.\.( +)(?P<type>[a-zA-Z0-9_-]+)\:\: *(?P<title>[^\n]*)(?:\n|$)"
r"(?P<options>(?: \1 {0,3}\:[a-zA-Z0-9_-]+\: *[^\n]*\n+)*)"
r"\n*(?P<text>(?: \1 {0,3}[^\n]*\n+)*)"
)
class RSTParser(DirectiveParser):
name = "rst_directive"
@staticmethod
def parse_type(m: Match[str]) -> str:
return m.group("type")
@staticmethod
def parse_title(m: Match[str]) -> str:
return m.group("title")
@staticmethod
def parse_content(m: Match[str]) -> str:
full_content = m.group(0)
text = m.group("text")
pretext = full_content[: -len(text)]
leading = len(m.group(1)) + 2
return "\n".join(line[leading:] for line in text.splitlines()) + "\n"
class RSTDirective(BaseDirective):
"""A RST style of directive syntax is inspired by reStructuredText.
The syntax is very powerful that you can define a lot of custom
features on your own. The syntax looks like:
.. code-block:: text
.. directive-type:: directive value
:option-key: option value
:option-key: option value
content text here
To use ``RSTDirective``, developers can add it into plugin list in
the :class:`Markdown` instance:
.. code-block:: python
import mistune
from mistune.directives import RSTDirective, Admonition
md = mistune.create_markdown(plugins=[
# ...
RSTDirective([Admonition()]),
])
"""
parser = RSTParser
directive_pattern = r"^\.\. +[a-zA-Z0-9_-]+\:\:"
def parse_directive(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
m2 = _directive_re.match(state.src, state.cursor)
if not m2:
return None
self.parse_method(block, m2, state)
return m2.end()
def __call__(self, markdown: "Markdown") -> None:
super(RSTDirective, self).__call__(markdown)
self.register_block_parser(markdown)
mistune-3.1.3/src/mistune/directives/admonition.py 0000664 0000000 0000000 00000004237 14766552020 0022346 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Any, Dict, Match
from ._base import BaseDirective, DirectivePlugin
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BlockState
from ..markdown import Markdown
class Admonition(DirectivePlugin):
SUPPORTED_NAMES = {
"attention",
"caution",
"danger",
"error",
"hint",
"important",
"note",
"tip",
"warning",
}
def parse(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Dict[str, Any]:
name = self.parse_type(m)
attrs = {"name": name}
options = dict(self.parse_options(m))
if "class" in options:
attrs["class"] = options["class"]
title = self.parse_title(m)
if not title:
title = name.capitalize()
content = self.parse_content(m)
children = [
{
"type": "admonition_title",
"text": title,
},
{
"type": "admonition_content",
"children": self.parse_tokens(block, content, state),
},
]
return {
"type": "admonition",
"children": children,
"attrs": attrs,
}
def __call__(self, directive: "BaseDirective", md: "Markdown") -> None:
for name in self.SUPPORTED_NAMES:
directive.register(name, self.parse)
assert md.renderer is not None
if md.renderer.NAME == "html":
md.renderer.register("admonition", render_admonition)
md.renderer.register("admonition_title", render_admonition_title)
md.renderer.register("admonition_content", render_admonition_content)
def render_admonition(self: Any, text: str, name: str, **attrs: Any) -> str:
html = '<section class="admonition ' + name
_cls = attrs.get("class")
if _cls:
html += " " + _cls
return html + '">\n' + text + "</section>\n"
def render_admonition_title(self: Any, text: str) -> str:
return '<p class="admonition-title">' + text + "</p>\n"
def render_admonition_content(self: Any, text: str) -> str:
return text
mistune-3.1.3/src/mistune/directives/image.py 0000664 0000000 0000000 00000012314 14766552020 0021262 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Any, Dict, List, Match, Optional
from ..util import escape as escape_text
from ..util import escape_url
from ._base import BaseDirective, DirectivePlugin
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BlockState
from ..markdown import Markdown
from ..renderers.html import HTMLRenderer
__all__ = ["Image", "Figure"]
_num_re = re.compile(r"^\d+(?:\.\d*)?")
_allowed_aligns = ["top", "middle", "bottom", "left", "center", "right"]
def _parse_attrs(options: Dict[str, Any]) -> Dict[str, Any]:
attrs = {}
if "alt" in options:
attrs["alt"] = options["alt"]
# validate align
align = options.get("align")
if align and align in _allowed_aligns:
attrs["align"] = align
height = options.get("height")
width = options.get("width")
if height and _num_re.match(height):
attrs["height"] = height
if width and _num_re.match(width):
attrs["width"] = width
if "target" in options:
attrs["target"] = escape_url(options["target"])
return attrs
class Image(DirectivePlugin):
NAME = "image"
def parse(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Dict[str, Any]:
options = dict(self.parse_options(m))
attrs = _parse_attrs(options)
attrs["src"] = self.parse_title(m)
return {"type": "block_image", "attrs": attrs}
def __call__(self, directive: "BaseDirective", md: "Markdown") -> None:
directive.register(self.NAME, self.parse)
assert md.renderer is not None
if md.renderer.NAME == "html":
md.renderer.register("block_image", render_block_image)
def render_block_image(
self: "HTMLRenderer",
src: str,
alt: Optional[str] = None,
width: Optional[str] = None,
height: Optional[str] = None,
**attrs: Any,
) -> str:
img = '<img src="' + escape_text(src) + '"'
style = ""
if alt:
img += ' alt="' + escape_text(alt) + '"'
if width:
if width.isdigit():
img += ' width="' + width + '"'
else:
style += "width:" + width + ";"
if height:
if height.isdigit():
img += ' height="' + height + '"'
else:
style += "height:" + height + ";"
if style:
img += ' style="' + escape_text(style) + '"'
img += " />"
_cls = "block-image"
align = attrs.get("align")
if align:
_cls += " align-" + align
target = attrs.get("target")
if target:
href = self.safe_url(target)
outer = '<a class="' + _cls + '" href="' + href + '">'
return outer + img + "</a>\n"
else:
return '<div class="' + _cls + '">' + img + "</div>\n"
class Figure(DirectivePlugin):
NAME = "figure"
def parse_directive_content(
self, block: "BlockParser", m: Match[str], state: "BlockState"
) -> Optional[List[Dict[str, Any]]]:
content = self.parse_content(m)
if not content:
return None
tokens = list(self.parse_tokens(block, content, state))
caption = tokens[0]
if caption["type"] == "paragraph":
caption["type"] = "figcaption"
children = [caption]
if len(tokens) > 1:
children.append({"type": "legend", "children": tokens[1:]})
return children
return None
def parse(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Dict[str, Any]:
options = dict(self.parse_options(m))
image_attrs = _parse_attrs(options)
image_attrs["src"] = self.parse_title(m)
align = image_attrs.pop("align", None)
fig_attrs = {}
if align:
fig_attrs["align"] = align
for k in ["figwidth", "figclass"]:
if k in options:
fig_attrs[k] = options[k]
children = [{"type": "block_image", "attrs": image_attrs}]
content = self.parse_directive_content(block, m, state)
if content:
children.extend(content)
return {
"type": "figure",
"attrs": fig_attrs,
"children": children,
}
def __call__(self, directive: "BaseDirective", md: "Markdown") -> None:
directive.register(self.NAME, self.parse)
assert md.renderer is not None
if md.renderer.NAME == "html":
md.renderer.register("figure", render_figure)
md.renderer.register("block_image", render_block_image)
md.renderer.register("figcaption", render_figcaption)
md.renderer.register("legend", render_legend)
def render_figure(
self: Any,
text: str,
align: Optional[str] = None,
figwidth: Optional[str] = None,
figclass: Optional[str] = None,
) -> str:
_cls = "figure"
if align:
_cls += " align-" + align
if figclass:
_cls += " " + figclass
html = '<figure class="' + _cls + '"'
if figwidth:
html += ' style="width:' + figwidth + '"'
return html + ">\n" + text + "</figure>\n"
def render_figcaption(self: Any, text: str) -> str:
return "<figcaption>" + text + "</figcaption>\n"
def render_legend(self: Any, text: str) -> str:
return '<div class="legend">\n' + text + "</div>\n"
mistune-3.1.3/src/mistune/directives/include.py 0000664 0000000 0000000 00000004447 14766552020 0021633 0 ustar 00root root 0000000 0000000 import os
from typing import TYPE_CHECKING, Any, Dict, List, Match, Union
from ._base import BaseDirective, DirectivePlugin
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState
from ..markdown import Markdown
class Include(DirectivePlugin):
def parse(
self, block: "BlockParser", m: Match[str], state: "BlockState"
) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
source_file = state.env.get("__file__")
if not source_file:
return {"type": "block_error", "raw": "Missing source file"}
encoding = "utf-8"
options = self.parse_options(m)
if options:
attrs = dict(options)
if "encoding" in attrs:
encoding = attrs["encoding"]
else:
attrs = {}
relpath = self.parse_title(m)
dest = os.path.join(os.path.dirname(source_file), relpath)
dest = os.path.normpath(dest)
if dest == source_file:
return {
"type": "block_error",
"raw": "Could not include self: " + relpath,
}
if not os.path.isfile(dest):
return {
"type": "block_error",
"raw": "Could not find file: " + relpath,
}
with open(dest, "rb") as f:
content = f.read().decode(encoding)
ext = os.path.splitext(relpath)[1]
if ext in {".md", ".markdown", ".mkd"}:
new_state = block.state_cls()
new_state.env["__file__"] = dest
new_state.process(content)
block.parse(new_state)
return new_state.tokens
elif ext in {".html", ".xhtml", ".htm"}:
return {"type": "block_html", "raw": content}
attrs["filepath"] = dest
return {
"type": "include",
"raw": content,
"attrs": attrs,
}
def __call__(self, directive: BaseDirective, md: "Markdown") -> None:
directive.register("include", self.parse)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("include", render_html_include)
def render_html_include(renderer: "BaseRenderer", text: str, **attrs: Any) -> str:
return '<pre class="directive-include">\n' + text + "</pre>\n"
mistune-3.1.3/src/mistune/directives/toc.py 0000664 0000000 0000000 00000007514 14766552020 0020773 0 ustar 00root root 0000000 0000000 """
TOC directive
~~~~~~~~~~~~~
The TOC directive syntax looks like::
.. toc:: Title
:min-level: 1
:max-level: 3
"Title", "min-level", and "max-level" option can be empty. "min-level"
and "max-level" are integers >= 1 and <= 6, which define the allowed
heading levels writers want to include in the table of contents.
"""
from typing import TYPE_CHECKING, Any, Dict, Match
from ..toc import normalize_toc_item, render_toc_ul
from ._base import BaseDirective, DirectivePlugin
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState
from ..markdown import Markdown
class TableOfContents(DirectivePlugin):
def __init__(self, min_level: int = 1, max_level: int = 3) -> None:
self.min_level = min_level
self.max_level = max_level
def generate_heading_id(self, token: Dict[str, Any], index: int) -> str:
return "toc_" + str(index + 1)
def parse(self, block: "BlockParser", m: Match[str], state: "BlockState") -> Dict[str, Any]:
title = self.parse_title(m)
options = self.parse_options(m)
if options:
d_options = dict(options)
collapse = "collapse" in d_options
min_level = _normalize_level(d_options, "min-level", self.min_level)
max_level = _normalize_level(d_options, "max-level", self.max_level)
if min_level < self.min_level:
raise ValueError(f'"min-level" option MUST be >= {self.min_level}')
if max_level > self.max_level:
raise ValueError(f'"max-level" option MUST be <= {self.max_level}')
if min_level > max_level:
raise ValueError('"min-level" option MUST be less than "max-level" option')
else:
collapse = False
min_level = self.min_level
max_level = self.max_level
attrs = {
"min_level": min_level,
"max_level": max_level,
"collapse": collapse,
}
return {"type": "toc", "text": title or "", "attrs": attrs}
def toc_hook(self, md: "Markdown", state: "BlockState") -> None:
sections = []
headings = []
for tok in state.tokens:
if tok["type"] == "toc":
sections.append(tok)
elif tok["type"] == "heading":
headings.append(tok)
if sections:
toc_items = []
# adding ID for each heading
for i, tok in enumerate(headings):
tok["attrs"]["id"] = self.generate_heading_id(tok, i)
toc_items.append(normalize_toc_item(md, tok))
for sec in sections:
_min = sec["attrs"]["min_level"]
_max = sec["attrs"]["max_level"]
toc = [item for item in toc_items if _min <= item[0] <= _max]
sec["attrs"]["toc"] = toc
def __call__(self, directive: BaseDirective, md: "Markdown") -> None:
if md.renderer and md.renderer.NAME == "html":
# only works with HTML renderer
directive.register("toc", self.parse)
md.before_render_hooks.append(self.toc_hook)
md.renderer.register("toc", render_html_toc)
def render_html_toc(renderer: "BaseRenderer", title: str, collapse: bool = False, **attrs: Any) -> str:
if not title:
title = "Table of Contents"
content = render_toc_ul(attrs["toc"])
html = '<details class="toc"'
if not collapse:
html += " open"
html += ">\n<summary>" + title + "</summary>\n"
return html + content + "</details>\n"
def _normalize_level(options: Dict[str, Any], name: str, default: Any) -> Any:
level = options.get(name)
if not level:
return default
try:
return int(level)
except (ValueError, TypeError):
raise ValueError(f'"{name}" option MUST be integer')
mistune-3.1.3/src/mistune/helpers.py 0000664 0000000 0000000 00000010406 14766552020 0017501 0 ustar 00root root 0000000 0000000 import re
import string
from typing import Any, Dict, Tuple, Union
from .util import escape_url
PREVENT_BACKSLASH = r"(?<!\\)(?:\\\\)*"
PUNCTUATION = r"[" + re.escape(string.punctuation) + r"]"
LINK_LABEL = r"(?:[^\\\[\]]|\\.){0,500}"
LINK_BRACKET_START = re.compile(r"[ \t]*\n?[ \t]*<")
LINK_BRACKET_RE = re.compile(r"<([^<>\n\\\x00]*)>")
LINK_HREF_BLOCK_RE = re.compile(r"[ \t]*\n?[ \t]*([^\s]+)(?:\s|$)")
LINK_HREF_INLINE_RE = re.compile(
r"[ \t]*\n?[ \t]*([^ \t\n]*?)(?:[ \t\n]|"
r"(?:" + PREVENT_BACKSLASH + r"\)))"
)
LINK_TITLE_RE = re.compile(
r"[ \t\n]+("
r'"(?:\\' + PUNCTUATION + r'|[^"\x00])*"|' # "title"
r"'(?:\\" + PUNCTUATION + r"|[^'\x00])*'" # 'title'
r")"
)
PAREN_END_RE = re.compile(r"\s*\)")
HTML_TAGNAME = r"[A-Za-z][A-Za-z0-9-]*"
HTML_ATTRIBUTES = (
r"(?:\s+[A-Za-z_:][A-Za-z0-9_.:-]*"
r'(?:\s*=\s*(?:[^ !"\'=<>`]+|\'[^\']*?\'|"[^\"]*?"))?)*'
)
BLOCK_TAGS = (
"address",
"article",
"aside",
"base",
"basefont",
"blockquote",
"body",
"caption",
"center",
"col",
"colgroup",
"dd",
"details",
"dialog",
"dir",
"div",
"dl",
"dt",
"fieldset",
"figcaption",
"figure",
"footer",
"form",
"frame",
"frameset",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"head",
"header",
"hr",
"html",
"iframe",
"legend",
"li",
"link",
"main",
"menu",
"menuitem",
"meta",
"nav",
"noframes",
"ol",
"optgroup",
"option",
"p",
"param",
"section",
"source",
"summary",
"table",
"tbody",
"td",
"tfoot",
"th",
"thead",
"title",
"tr",
"track",
"ul",
)
PRE_TAGS = ("pre", "script", "style", "textarea")
_INLINE_LINK_LABEL_RE = re.compile(LINK_LABEL + r"\]")
_INLINE_SQUARE_BRACKET_RE = re.compile(PREVENT_BACKSLASH + r"[\[\]]")
_ESCAPE_CHAR_RE = re.compile(r"\\(" + PUNCTUATION + r")")
def unescape_char(text: str) -> str:
return _ESCAPE_CHAR_RE.sub(r"\1", text)
def parse_link_text(src: str, pos: int) -> Union[Tuple[str, int], Tuple[None, None]]:
level = 1
found = False
start_pos = pos
while pos < len(src):
m = _INLINE_SQUARE_BRACKET_RE.search(src, pos)
if not m:
break
pos = m.end()
marker = m.group(0)
if marker == "]":
level -= 1
if level == 0:
found = True
break
else:
level += 1
if found:
text = src[start_pos : pos - 1]
return text, pos
return None, None
def parse_link_label(src: str, start_pos: int) -> Union[Tuple[str, int], Tuple[None, None]]:
m = _INLINE_LINK_LABEL_RE.match(src, start_pos)
if m:
label = m.group(0)[:-1]
return label, m.end()
return None, None
def parse_link_href(src: str, start_pos: int, block: bool = False) -> Union[Tuple[str, int], Tuple[None, None]]:
m = LINK_BRACKET_START.match(src, start_pos)
if m:
start_pos = m.end() - 1
m = LINK_BRACKET_RE.match(src, start_pos)
if m:
return m.group(1), m.end()
return None, None
if block:
m = LINK_HREF_BLOCK_RE.match(src, start_pos)
else:
m = LINK_HREF_INLINE_RE.match(src, start_pos)
if not m:
return None, None
end_pos = m.end()
href = m.group(1)
if block and src[end_pos - 1] == href[-1]:
return href, end_pos
return href, end_pos - 1
def parse_link_title(src: str, start_pos: int, max_pos: int) -> Union[Tuple[str, int], Tuple[None, None]]:
m = LINK_TITLE_RE.match(src, start_pos, max_pos)
if m:
title = m.group(1)[1:-1]
title = unescape_char(title)
return title, m.end()
return None, None
def parse_link(src: str, pos: int) -> Union[Tuple[Dict[str, Any], int], Tuple[None, None]]:
href, href_pos = parse_link_href(src, pos)
if href is None:
return None, None
assert href_pos is not None
title, title_pos = parse_link_title(src, href_pos, len(src))
next_pos = title_pos or href_pos
m = PAREN_END_RE.match(src, next_pos)
if not m:
return None, None
href = unescape_char(href)
attrs = {"url": escape_url(href)}
if title:
attrs["title"] = title
return attrs, m.end()
mistune-3.1.3/src/mistune/inline_parser.py 0000664 0000000 0000000 00000030576 14766552020 0020703 0 ustar 00root root 0000000 0000000 import re
from typing import (
Any,
Dict,
List,
Match,
MutableMapping,
Optional,
)
from .core import InlineState, Parser
from .helpers import (
HTML_ATTRIBUTES,
HTML_TAGNAME,
PREVENT_BACKSLASH,
PUNCTUATION,
parse_link,
parse_link_label,
parse_link_text,
unescape_char,
)
from .util import escape_url, unikey
PAREN_END_RE = re.compile(r"\s*\)")
AUTO_EMAIL = (
r"""<[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9]"""
r"(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?"
r"(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*>"
)
INLINE_HTML = (
r"<" + HTML_TAGNAME + HTML_ATTRIBUTES + r"\s*/?>|" # open tag
r"</" + HTML_TAGNAME + r"\s*>|" # close tag
r"<!--(?!>|->)(?:(?!--)[\s\S])+?(?<!-)-->|" # comment
r"<\?[\s\S]+?\?>|" # script like <?php?>
r"<![A-Z][\s\S]+?>|" # doctype
r"<!\[CDATA[\s\S]+?\]\]>" # cdata
)
EMPHASIS_END_RE = {
"*": re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\\*|[^\s*])\*(?!\*)"),
"_": re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\_|[^\s_])_(?!_)\b"),
"**": re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\\*|[^\s*])\*\*(?!\*)"),
"__": re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\_|[^\s_])__(?!_)\b"),
"***": re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\\*|[^\s*])\*\*\*(?!\*)"),
"___": re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\_|[^\s_])___(?!_)\b"),
}
class InlineParser(Parser[InlineState]):
sc_flag = 0
state_cls = InlineState
#: linebreak leaves two spaces at the end of line
STD_LINEBREAK = r"(?:\\| {2,})\n\s*"
#: every new line becomes <br>
HARD_LINEBREAK = r" *\n\s*"
# we only need to find the start pattern of an inline token
SPECIFICATION = {
# e.g. \`, \$
"escape": r"(?:\\" + PUNCTUATION + ")+",
# `code, ```code
"codespan": r"`{1,}",
# *w, **w, _w, __w
"emphasis": r"\*{1,3}(?=[^\s*])|\b_{1,3}(?=[^\s_])",
# [link], ![img]
"link": r"!?\[",
# <https://example.com>. regex copied from commonmark.js
"auto_link": r"<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*>",
"auto_email": AUTO_EMAIL,
"inline_html": INLINE_HTML,
"linebreak": STD_LINEBREAK,
"softbreak": HARD_LINEBREAK,
"prec_auto_link": r"<[A-Za-z][A-Za-z\d.+-]{1,31}:",
"prec_inline_html": r"</?" + HTML_TAGNAME + r"|<!|<\?",
}
DEFAULT_RULES = (
"escape",
"codespan",
"emphasis",
"link",
"auto_link",
"auto_email",
"inline_html",
"linebreak",
)
def __init__(self, hard_wrap: bool = False) -> None:
super(InlineParser, self).__init__()
self.hard_wrap = hard_wrap
# lazy add linebreak
if hard_wrap:
self.specification["linebreak"] = self.HARD_LINEBREAK
else:
self.rules.append("softbreak")
self._methods = {name: getattr(self, "parse_" + name) for name in self.rules}
def parse_escape(self, m: Match[str], state: InlineState) -> int:
text = m.group(0)
text = unescape_char(text)
state.append_token(
{
"type": "text",
"raw": text,
}
)
return m.end()
def parse_link(self, m: Match[str], state: InlineState) -> Optional[int]:
pos = m.end()
marker = m.group(0)
is_image = marker[0] == "!"
if is_image and state.in_image:
state.append_token({"type": "text", "raw": marker})
return pos
elif not is_image and state.in_link:
state.append_token({"type": "text", "raw": marker})
return pos
text = None
label, end_pos = parse_link_label(state.src, pos)
if label is None:
text, end_pos = parse_link_text(state.src, pos)
if text is None:
return None
assert end_pos is not None
if text is None:
text = label
assert text is not None
if end_pos >= len(state.src) and label is None:
return None
rules = ["codespan", "prec_auto_link", "prec_inline_html"]
prec_pos = self.precedence_scan(m, state, end_pos, rules)
if prec_pos:
return prec_pos
if end_pos < len(state.src):
c = state.src[end_pos]
if c == "(":
# standard link [text](<url> "title")
attrs, pos2 = parse_link(state.src, end_pos + 1)
if pos2:
token = self.__parse_link_token(is_image, text, attrs, state)
state.append_token(token)
return pos2
elif c == "[":
# standard ref link [text][label]
label2, pos2 = parse_link_label(state.src, end_pos + 1)
if pos2:
end_pos = pos2
if label2:
label = label2
if label is None:
return None
ref_links = state.env.get("ref_links")
if not ref_links:
return None
key = unikey(label)
env = ref_links.get(key)
if env:
attrs = {"url": env["url"], "title": env.get("title")}
token = self.__parse_link_token(is_image, text, attrs, state)
token["ref"] = key
token["label"] = label
state.append_token(token)
return end_pos
return None
def __parse_link_token(
self,
is_image: bool,
text: str,
attrs: Optional[Dict[str, Any]],
state: InlineState,
) -> Dict[str, Any]:
new_state = state.copy()
new_state.src = text
if is_image:
new_state.in_image = True
token = {
"type": "image",
"children": self.render(new_state),
"attrs": attrs,
}
else:
new_state.in_link = True
token = {
"type": "link",
"children": self.render(new_state),
"attrs": attrs,
}
return token
def parse_auto_link(self, m: Match[str], state: InlineState) -> int:
text = m.group(0)
pos = m.end()
if state.in_link:
self.process_text(text, state)
return pos
text = text[1:-1]
self._add_auto_link(text, text, state)
return pos
def parse_auto_email(self, m: Match[str], state: InlineState) -> int:
text = m.group(0)
pos = m.end()
if state.in_link:
self.process_text(text, state)
return pos
text = text[1:-1]
url = "mailto:" + text
self._add_auto_link(url, text, state)
return pos
def _add_auto_link(self, url: str, text: str, state: InlineState) -> None:
state.append_token(
{
"type": "link",
"children": [{"type": "text", "raw": text}],
"attrs": {"url": escape_url(url)},
}
)
def parse_emphasis(self, m: Match[str], state: InlineState) -> int:
pos = m.end()
marker = m.group(0)
mlen = len(marker)
if mlen == 1 and state.in_emphasis:
state.append_token({"type": "text", "raw": marker})
return pos
elif mlen == 2 and state.in_strong:
state.append_token({"type": "text", "raw": marker})
return pos
_end_re = EMPHASIS_END_RE[marker]
m1 = _end_re.search(state.src, pos)
if not m1:
state.append_token({"type": "text", "raw": marker})
return pos
end_pos = m1.end()
text = state.src[pos : end_pos - mlen]
prec_pos = self.precedence_scan(m, state, end_pos)
if prec_pos:
return prec_pos
new_state = state.copy()
new_state.src = text
if mlen == 1:
new_state.in_emphasis = True
children = self.render(new_state)
state.append_token({"type": "emphasis", "children": children})
elif mlen == 2:
new_state.in_strong = True
children = self.render(new_state)
state.append_token({"type": "strong", "children": children})
else:
new_state.in_emphasis = True
new_state.in_strong = True
children = [{"type": "strong", "children": self.render(new_state)}]
state.append_token(
{
"type": "emphasis",
"children": children,
}
)
return end_pos
def parse_codespan(self, m: Match[str], state: InlineState) -> int:
marker = m.group(0)
# require same marker with same length at end
pattern = re.compile(r"(.*?[^`])" + marker + r"(?!`)", re.S)
pos = m.end()
m2 = pattern.match(state.src, pos)
if m2:
end_pos = m2.end()
code = m2.group(1)
# Line endings are treated like spaces
code = code.replace("\n", " ")
if len(code.strip()):
if code.startswith(" ") and code.endswith(" "):
code = code[1:-1]
state.append_token({"type": "codespan", "raw": code})
return end_pos
else:
state.append_token({"type": "text", "raw": marker})
return pos
def parse_linebreak(self, m: Match[str], state: InlineState) -> int:
state.append_token({"type": "linebreak"})
return m.end()
def parse_softbreak(self, m: Match[str], state: InlineState) -> int:
state.append_token({"type": "softbreak"})
return m.end()
def parse_inline_html(self, m: Match[str], state: InlineState) -> int:
end_pos = m.end()
html = m.group(0)
state.append_token({"type": "inline_html", "raw": html})
if html.startswith(("<a ", "<a>", "<A ", "<A>")):
state.in_link = True
elif html.startswith(("</a ", "</a>", "</A ", "</A>")):
state.in_link = False
return end_pos
def process_text(self, text: str, state: InlineState) -> None:
state.append_token({"type": "text", "raw": text})
def parse(self, state: InlineState) -> List[Dict[str, Any]]:
pos = 0
sc = self.compile_sc()
while pos < len(state.src):
m = sc.search(state.src, pos)
if not m:
break
end_pos = m.start()
if end_pos > pos:
hole = state.src[pos:end_pos]
self.process_text(hole, state)
new_pos = self.parse_method(m, state)
if not new_pos:
# move cursor 1 character forward
pos = end_pos + 1
hole = state.src[end_pos:pos]
self.process_text(hole, state)
else:
pos = new_pos
if pos == 0:
# special case, just pure text
self.process_text(state.src, state)
elif pos < len(state.src):
self.process_text(state.src[pos:], state)
return state.tokens
def precedence_scan(
self,
m: Match[str],
state: InlineState,
end_pos: int,
rules: Optional[List[str]] = None,
) -> Optional[int]:
if rules is None:
rules = ["codespan", "link", "prec_auto_link", "prec_inline_html"]
mark_pos = m.end()
sc = self.compile_sc(rules)
m1 = sc.search(state.src, mark_pos, end_pos)
if not m1:
return None
lastgroup = m1.lastgroup
if not lastgroup:
return None
rule_name = lastgroup.replace("prec_", "")
sc = self.compile_sc([rule_name])
m2 = sc.match(state.src, m1.start())
if not m2:
return None
func = self._methods[rule_name]
new_state = state.copy()
new_state.src = state.src
m2_pos = func(m2, new_state)
if not m2_pos or m2_pos < end_pos:
return None
raw_text = state.src[m.start() : m2.start()]
state.append_token({"type": "text", "raw": raw_text})
for token in new_state.tokens:
state.append_token(token)
return m2_pos
def render(self, state: InlineState) -> List[Dict[str, Any]]:
self.parse(state)
return state.tokens
def __call__(self, s: str, env: MutableMapping[str, Any]) -> List[Dict[str, Any]]:
state = self.state_cls(env)
state.src = s
return self.render(state)
mistune-3.1.3/src/mistune/list_parser.py 0000664 0000000 0000000 00000016723 14766552020 0020376 0 ustar 00root root 0000000 0000000 """because list is complex, split list parser in a new file"""
import re
from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple, Match
from .util import expand_leading_tab, expand_tab, strip_end
if TYPE_CHECKING:
from .block_parser import BlockParser
from .core import BlockState
LIST_PATTERN = (
r"^(?P<list_1> {0,3})"
r"(?P<list_2>[\*\+-]|\d{1,9}[.)])"
r"(?P<list_3>[ \t]*|[ \t].+)$"
)
_LINE_HAS_TEXT = re.compile(r"(\s*)\S")
def parse_list(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
"""Parse tokens for ordered and unordered list."""
text = m.group("list_3")
if not text.strip():
# Example 285
# an empty list item cannot interrupt a paragraph
end_pos = state.append_paragraph()
if end_pos:
return end_pos
marker = m.group("list_2")
ordered = len(marker) > 1
depth = state.depth()
token: Dict[str, Any] = {
"type": "list",
"children": [],
"tight": True,
"bullet": marker[-1],
"attrs": {
"depth": depth,
"ordered": ordered,
},
}
if ordered:
start = int(marker[:-1])
if start != 1:
# Example 304
# we allow only lists starting with 1 to interrupt paragraphs
end_pos = state.append_paragraph()
if end_pos:
return end_pos
token["attrs"]["start"] = start
state.cursor = m.end() + 1
groups: Optional[Tuple[str, str, str]] = (m.group("list_1"), marker, text)
if depth >= block.max_nested_level - 1:
rules = list(block.list_rules)
rules.remove("list")
else:
rules = block.list_rules
bullet = _get_list_bullet(marker[-1])
while groups:
groups = _parse_list_item(block, bullet, groups, token, state, rules)
end_pos = token.pop("_end_pos", None)
_transform_tight_list(token)
if end_pos:
index = token.pop("_tok_index")
state.tokens.insert(index, token)
return end_pos
state.append_token(token)
return state.cursor
def _transform_tight_list(token: Dict[str, Any]) -> None:
if token["tight"]:
# reset tight list item
for list_item in token["children"]:
for tok in list_item["children"]:
if tok["type"] == "paragraph":
tok["type"] = "block_text"
elif tok["type"] == "list":
_transform_tight_list(tok)
def _parse_list_item(
block: "BlockParser",
bullet: str,
groups: Tuple[str, str, str],
token: Dict[str, Any],
state: "BlockState",
rules: List[str],
) -> Optional[Tuple[str, str, str]]:
spaces, marker, text = groups
leading_width = len(spaces) + len(marker)
text, continue_width = _compile_continue_width(text, leading_width)
item_pattern = _compile_list_item_pattern(bullet, leading_width)
pairs = [
("thematic_break", block.specification["thematic_break"]),
("fenced_code", block.specification["fenced_code"]),
("atx_heading", block.specification["atx_heading"]),
("block_quote", block.specification["block_quote"]),
("block_html", block.specification["block_html"]),
("list", block.specification["list"]),
]
if leading_width < 3:
_repl_w = str(leading_width)
pairs = [(n, p.replace("3", _repl_w, 1)) for n, p in pairs]
pairs.insert(1, ("list_item", item_pattern))
regex = "|".join(r"(?P<%s>(?<=\n)%s)" % pair for pair in pairs)
sc = re.compile(regex, re.M)
src = ""
next_group = None
prev_blank_line = False
pos = state.cursor
continue_space = " " * continue_width
while pos < state.cursor_max:
pos = state.find_line_end()
line = state.get_text(pos)
if block.BLANK_LINE.match(line):
src += "\n"
prev_blank_line = True
state.cursor = pos
continue
line = expand_leading_tab(line)
if line.startswith(continue_space):
if prev_blank_line and not text and not src.strip():
# Example 280
# A list item can begin with at most one blank line
break
src += line
prev_blank_line = False
state.cursor = pos
continue
m = sc.match(state.src, state.cursor)
if m:
tok_type = m.lastgroup
if tok_type == "list_item":
if prev_blank_line:
token["tight"] = False
next_group = (m.group("listitem_1"), m.group("listitem_2"), m.group("listitem_3"))
state.cursor = m.end() + 1
break
if tok_type == "list":
break
tok_index = len(state.tokens)
end_pos = block.parse_method(m, state)
if end_pos:
token["_tok_index"] = tok_index
token["_end_pos"] = end_pos
break
if prev_blank_line and not line.startswith(continue_space):
# not a continue line, and previous line is blank
break
src += line
state.cursor = pos
text += _clean_list_item_text(src, continue_width)
child = state.child_state(strip_end(text))
block.parse(child, rules)
if token["tight"] and _is_loose_list(child.tokens):
token["tight"] = False
token["children"].append(
{
"type": "list_item",
"children": child.tokens,
}
)
if next_group:
return next_group
return None
def _get_list_bullet(c: str) -> str:
if c == ".":
bullet = r"\d{0,9}\."
elif c == ")":
bullet = r"\d{0,9}\)"
elif c == "*":
bullet = r"\*"
elif c == "+":
bullet = r"\+"
else:
bullet = "-"
return bullet
def _compile_list_item_pattern(bullet: str, leading_width: int) -> str:
if leading_width > 3:
leading_width = 3
return (
r"^(?P<listitem_1> {0," + str(leading_width) + "})"
r"(?P<listitem_2>" + bullet + ")"
r"(?P<listitem_3>[ \t]*|[ \t][^\n]+)$"
)
def _compile_continue_width(text: str, leading_width: int) -> Tuple[str, int]:
text = expand_leading_tab(text, 3)
text = expand_tab(text)
m2 = _LINE_HAS_TEXT.match(text)
if m2:
# indent code, startswith 5 spaces
if text.startswith(" "):
space_width = 1
else:
space_width = len(m2.group(1))
text = text[space_width:] + "\n"
else:
space_width = 1
text = ""
continue_width = leading_width + space_width
return text, continue_width
def _clean_list_item_text(src: str, continue_width: int) -> str:
# according to Example 7, tab should be treated as 3 spaces
rv = []
trim_space = " " * continue_width
lines = src.split("\n")
for line in lines:
if line.startswith(trim_space):
line = line.replace(trim_space, "", 1)
# according to CommonMark Example 5
# tab should be treated as 4 spaces
line = expand_tab(line)
rv.append(line)
else:
rv.append(line)
return "\n".join(rv)
def _is_loose_list(tokens: Iterable[Dict[str, Any]]) -> bool:
paragraph_count = 0
for tok in tokens:
if tok["type"] == "blank_line":
return True
if tok["type"] == "paragraph":
paragraph_count += 1
if paragraph_count > 1:
return True
return False
mistune-3.1.3/src/mistune/markdown.py 0000664 0000000 0000000 00000007663 14766552020 0017674 0 ustar 00root root 0000000 0000000 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
from .block_parser import BlockParser
from .core import BaseRenderer, BlockState
from .inline_parser import InlineParser
from .plugins import Plugin
class Markdown:
"""Markdown instance to convert markdown text into HTML or other formats.
Here is an example with the HTMLRenderer::
from mistune import HTMLRenderer
md = Markdown(renderer=HTMLRenderer(escape=False))
md('hello **world**')
:param renderer: a renderer to convert parsed tokens
:param block: block level syntax parser
:param inline: inline level syntax parser
:param plugins: mistune plugins to use
"""
def __init__(
self,
renderer: Optional[BaseRenderer] = None,
block: Optional[BlockParser] = None,
inline: Optional[InlineParser] = None,
plugins: Optional[Iterable[Plugin]] = None,
):
if block is None:
block = BlockParser()
if inline is None:
inline = InlineParser()
self.renderer = renderer
self.block: BlockParser = block
self.inline: InlineParser = inline
self.before_parse_hooks: List[Callable[["Markdown", BlockState], None]] = []
self.before_render_hooks: List[Callable[["Markdown", BlockState], Any]] = []
self.after_render_hooks: List[
Callable[["Markdown", Union[str, List[Dict[str, Any]]], BlockState], Union[str, List[Dict[str, Any]]]]
] = []
if plugins:
for plugin in plugins:
plugin(self)
def use(self, plugin: Plugin) -> None:
plugin(self)
def render_state(self, state: BlockState) -> Union[str, List[Dict[str, Any]]]:
data = self._iter_render(state.tokens, state)
if self.renderer:
return self.renderer(data, state)
return list(data)
def _iter_render(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> Iterable[Dict[str, Any]]:
for tok in tokens:
if "children" in tok:
children = self._iter_render(tok["children"], state)
tok["children"] = list(children)
elif "text" in tok:
text = tok.pop("text")
# process inline text
# avoid striping emsp or other unicode spaces
tok["children"] = self.inline(text.strip(" \r\n\t\f"), state.env)
yield tok
def parse(self, s: str, state: Optional[BlockState] = None) -> Tuple[Union[str, List[Dict[str, Any]]], BlockState]:
"""Parse and convert the given markdown string. If renderer is None,
the returned **result** will be parsed markdown tokens.
:param s: markdown string
:param state: instance of BlockState
:returns: result, state
"""
if state is None:
state = self.block.state_cls()
# normalize line separator
s = s.replace("\r\n", "\n")
s = s.replace("\r", "\n")
if not s.endswith("\n"):
s += "\n"
state.process(s)
for hook in self.before_parse_hooks:
hook(self, state)
self.block.parse(state)
for hook2 in self.before_render_hooks:
hook2(self, state)
result = self.render_state(state)
for hook3 in self.after_render_hooks:
result = hook3(self, result, state)
return result, state
def read(
self, filepath: str, encoding: str = "utf-8", state: Optional[BlockState] = None
) -> Tuple[Union[str, List[Dict[str, Any]]], BlockState]:
if state is None:
state = self.block.state_cls()
state.env["__file__"] = filepath
with open(filepath, "rb") as f:
s = f.read()
s2 = s.decode(encoding)
return self.parse(s2, state)
def __call__(self, s: str) -> Union[str, List[Dict[str, Any]]]:
if s is None:
s = "\n"
return self.parse(s)[0]
mistune-3.1.3/src/mistune/plugins/ 0000775 0000000 0000000 00000000000 14766552020 0017145 5 ustar 00root root 0000000 0000000 mistune-3.1.3/src/mistune/plugins/__init__.py 0000664 0000000 0000000 00000003042 14766552020 0021255 0 ustar 00root root 0000000 0000000 from importlib import import_module
from typing import TYPE_CHECKING, Dict, Protocol, Union, cast
if TYPE_CHECKING:
from ..markdown import Markdown
_plugins = {
"speedup": "mistune.plugins.speedup.speedup",
"strikethrough": "mistune.plugins.formatting.strikethrough",
"mark": "mistune.plugins.formatting.mark",
"insert": "mistune.plugins.formatting.insert",
"superscript": "mistune.plugins.formatting.superscript",
"subscript": "mistune.plugins.formatting.subscript",
"footnotes": "mistune.plugins.footnotes.footnotes",
"table": "mistune.plugins.table.table",
"url": "mistune.plugins.url.url",
"abbr": "mistune.plugins.abbr.abbr",
"def_list": "mistune.plugins.def_list.def_list",
"math": "mistune.plugins.math.math",
"ruby": "mistune.plugins.ruby.ruby",
"task_lists": "mistune.plugins.task_lists.task_lists",
"spoiler": "mistune.plugins.spoiler.spoiler",
}
class Plugin(Protocol):
def __call__(self, md: "Markdown") -> None: ...
_cached_modules: Dict[str, Plugin] = {}
PluginRef = Union[str, Plugin] # reference to register a plugin
def import_plugin(name: PluginRef) -> Plugin:
if callable(name):
return name
if name in _cached_modules:
return _cached_modules[name]
if name in _plugins:
module_path, func_name = _plugins[name].rsplit(".", 1)
else:
module_path, func_name = name.rsplit(".", 1)
module = import_module(module_path)
plugin = cast(Plugin, getattr(module, func_name))
_cached_modules[name] = plugin
return plugin
mistune-3.1.3/src/mistune/plugins/abbr.py 0000664 0000000 0000000 00000006350 14766552020 0020431 0 ustar 00root root 0000000 0000000 import re
import types
from typing import TYPE_CHECKING, Match
from ..helpers import PREVENT_BACKSLASH
from ..util import escape
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
__all__ = ["abbr"]
# https://michelf.ca/projects/php-markdown/extra/#abbr
REF_ABBR = (
r"^ {0,3}\*\[(?P<abbr_key>[^\]]+)" + PREVENT_BACKSLASH + r"\]:"
r"(?P<abbr_text>(?:[ \t]*\n(?: {3,}|\t)[^\n]+)|(?:[^\n]*))$"
)
def parse_ref_abbr(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
ref = state.env.get("ref_abbrs")
if not ref:
ref = {}
key = m.group("abbr_key")
text = m.group("abbr_text")
ref[key] = text.strip()
state.env["ref_abbrs"] = ref
# abbr definition can split paragraph
state.append_token({"type": "blank_line"})
return m.end() + 1
def process_text(inline: "InlineParser", text: str, state: "InlineState") -> None:
ref = state.env.get("ref_abbrs")
if not ref:
return state.append_token({"type": "text", "raw": text})
if state.tokens:
last = state.tokens[-1]
if last["type"] == "text":
state.tokens.pop()
text = last["raw"] + text
abbrs_re = state.env.get("abbrs_re")
if not abbrs_re:
abbrs_re = re.compile(r"|".join(re.escape(k) for k in ref.keys()))
state.env["abbrs_re"] = abbrs_re
pos = 0
while pos < len(text):
m = abbrs_re.search(text, pos)
if not m:
break
end_pos = m.start()
if end_pos > pos:
hole = text[pos:end_pos]
state.append_token({"type": "text", "raw": hole})
label = m.group(0)
state.append_token(
{"type": "abbr", "children": [{"type": "text", "raw": label}], "attrs": {"title": ref[label]}}
)
pos = m.end()
if pos == 0:
# special case, just pure text
state.append_token({"type": "text", "raw": text})
elif pos < len(text):
state.append_token({"type": "text", "raw": text[pos:]})
def render_abbr(renderer: "BaseRenderer", text: str, title: str) -> str:
if not title:
return "<abbr>" + text + "</abbr>"
return '<abbr title="' + escape(title) + '">' + text + "</abbr>"
def abbr(md: "Markdown") -> None:
"""A mistune plugin to support abbreviations, spec defined at
https://michelf.ca/projects/php-markdown/extra/#abbr
Here is an example:
.. code-block:: text
The HTML specification
is maintained by the W3C.
*[HTML]: Hyper Text Markup Language
*[W3C]: World Wide Web Consortium
It will be converted into HTML:
.. code-block:: html
The <abbr title="Hyper Text Markup Language">HTML</abbr> specification
is maintained by the <abbr title="World Wide Web Consortium">W3C</abbr>.
:param md: Markdown instance
"""
md.block.register("ref_abbr", REF_ABBR, parse_ref_abbr, before="paragraph")
# replace process_text
md.inline.process_text = types.MethodType(process_text, md.inline) # type: ignore[method-assign]
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("abbr", render_abbr)
mistune-3.1.3/src/mistune/plugins/def_list.py 0000664 0000000 0000000 00000007650 14766552020 0021320 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Match
from ..util import strip_end
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState
from ..markdown import Markdown
__all__ = ["def_list"]
# https://michelf.ca/projects/php-markdown/extra/#def-list
DEF_PATTERN = (
r"^(?P<def_list_head>(?:[^\n]+\n)+?)"
r"\n?(?:"
r"\:[ \t]+.*\n"
r"(?:[^\n]+\n)*" # lazy continue line
r"(?:(?:[ \t]*\n)*[ \t]+[^\n]+\n)*"
r"(?:[ \t]*\n)*"
r")+"
)
DEF_RE = re.compile(DEF_PATTERN, re.M)
DD_START_RE = re.compile(r"^:[ \t]+", re.M)
TRIM_RE = re.compile(r"^ {0,4}", re.M)
HAS_BLANK_LINE_RE = re.compile(r"\n[ \t]*\n$")
def parse_def_list(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
pos = m.end()
children = list(_parse_def_item(block, m))
m2 = DEF_RE.match(state.src, pos)
while m2:
children.extend(list(_parse_def_item(block, m2)))
pos = m2.end()
m2 = DEF_RE.match(state.src, pos)
state.append_token(
{
"type": "def_list",
"children": children,
}
)
return pos
def _parse_def_item(block: "BlockParser", m: Match[str]) -> Iterable[Dict[str, Any]]:
head = m.group("def_list_head")
for line in head.splitlines():
yield {
"type": "def_list_head",
"text": line,
}
src = m.group(0)
end = len(head)
m2 = DD_START_RE.search(src, end)
assert m2 is not None
start = m2.start()
prev_blank_line = src[end:start] == "\n"
while m2:
m2 = DD_START_RE.search(src, start + 1)
if not m2:
break
end = m2.start()
text = src[start:end].replace(":", " ", 1)
children = _process_text(block, text, prev_blank_line)
prev_blank_line = bool(HAS_BLANK_LINE_RE.search(text))
yield {
"type": "def_list_item",
"children": children,
}
start = end
text = src[start:].replace(":", " ", 1)
children = _process_text(block, text, prev_blank_line)
yield {
"type": "def_list_item",
"children": children,
}
def _process_text(block: "BlockParser", text: str, loose: bool) -> List[Any]:
text = TRIM_RE.sub("", text)
state = block.state_cls()
state.process(strip_end(text))
# use default list rules
block.parse(state, block.list_rules)
tokens = state.tokens
if not loose and len(tokens) == 1 and tokens[0]["type"] == "paragraph":
tokens[0]["type"] = "block_text"
return tokens
def render_def_list(renderer: "BaseRenderer", text: str) -> str:
return "<dl>\n" + text + "</dl>\n"
def render_def_list_head(renderer: "BaseRenderer", text: str) -> str:
return "<dt>" + text + "</dt>\n"
def render_def_list_item(renderer: "BaseRenderer", text: str) -> str:
return "<dd>" + text + "</dd>\n"
def def_list(md: "Markdown") -> None:
"""A mistune plugin to support def list, spec defined at
https://michelf.ca/projects/php-markdown/extra/#def-list
Here is an example:
.. code-block:: text
Apple
: Pomaceous fruit of plants of the genus Malus in
the family Rosaceae.
Orange
: The fruit of an evergreen tree of the genus Citrus.
It will be converted into HTML:
.. code-block:: html
<dl>
<dt>Apple</dt>
<dd>Pomaceous fruit of plants of the genus Malus in
the family Rosaceae.</dd>
<dt>Orange</dt>
<dd>The fruit of an evergreen tree of the genus Citrus.</dd>
</dl>
:param md: Markdown instance
"""
md.block.register("def_list", DEF_PATTERN, parse_def_list, before="paragraph")
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("def_list", render_def_list)
md.renderer.register("def_list_head", render_def_list_head)
md.renderer.register("def_list_item", render_def_list_item)
mistune-3.1.3/src/mistune/plugins/footnotes.py 0000664 0000000 0000000 00000011571 14766552020 0021544 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Any, Dict, List, Match, Union
from ..core import BlockState
from ..helpers import LINK_LABEL
from ..util import unikey
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
__all__ = ["footnotes"]
_PARAGRAPH_SPLIT = re.compile(r"\n{2,}")
# https://michelf.ca/projects/php-markdown/extra/#footnotes
REF_FOOTNOTE = (
r"^(?P<footnote_lead> {0,3})"
r"\[\^(?P<footnote_key>" + LINK_LABEL + r")]:[ \t]"
r"(?P<footnote_text>[^\n]*(?:\n+|$)"
r"(?:(?P=footnote_lead) {1,3}(?! )[^\n]*\n+)*"
r")"
)
INLINE_FOOTNOTE = r"\[\^(?P<footnote_key>" + LINK_LABEL + r")\]"
def parse_inline_footnote(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
key = unikey(m.group("footnote_key"))
ref = state.env.get("ref_footnotes")
if ref and key in ref:
notes = state.env.get("footnotes")
if not notes:
notes = []
if key not in notes:
notes.append(key)
state.env["footnotes"] = notes
state.append_token({"type": "footnote_ref", "raw": key, "attrs": {"index": notes.index(key) + 1}})
else:
state.append_token({"type": "text", "raw": m.group(0)})
return m.end()
def parse_ref_footnote(block: "BlockParser", m: Match[str], state: BlockState) -> int:
ref = state.env.get("ref_footnotes")
if not ref:
ref = {}
key = unikey(m.group("footnote_key"))
if key not in ref:
ref[key] = m.group("footnote_text")
state.env["ref_footnotes"] = ref
return m.end()
def parse_footnote_item(block: "BlockParser", key: str, index: int, state: BlockState) -> Dict[str, Any]:
ref = state.env.get("ref_footnotes")
if not ref:
raise ValueError("Missing 'ref_footnotes'.")
text = ref[key]
lines = text.splitlines()
second_line = None
for second_line in lines[1:]:
if second_line:
break
if second_line:
spaces = len(second_line) - len(second_line.lstrip())
pattern = re.compile(r"^ {" + str(spaces) + r",}", flags=re.M)
text = pattern.sub("", text).strip()
items = _PARAGRAPH_SPLIT.split(text)
children = [{"type": "paragraph", "text": s} for s in items]
else:
text = text.strip()
children = [{"type": "paragraph", "text": text}]
return {"type": "footnote_item", "children": children, "attrs": {"key": key, "index": index}}
def md_footnotes_hook(
md: "Markdown", result: Union[str, List[Dict[str, Any]]], state: BlockState
) -> Union[str, List[Dict[str, Any]]]:
notes = state.env.get("footnotes")
if not notes:
return result
children = [parse_footnote_item(md.block, k, i + 1, state) for i, k in enumerate(notes)]
state = BlockState()
state.tokens = [{"type": "footnotes", "children": children}]
output = md.render_state(state)
return result + output # type: ignore[operator]
def render_footnote_ref(renderer: "BaseRenderer", key: str, index: int) -> str:
i = str(index)
html = '<sup class="footnote-ref" id="fnref-' + i + '">'
return html + '<a href="#fn-' + i + '">' + i + "</a></sup>"
def render_footnotes(renderer: "BaseRenderer", text: str) -> str:
return '<section class="footnotes">\n<ol>\n' + text + "</ol>\n</section>\n"
def render_footnote_item(renderer: "BaseRenderer", text: str, key: str, index: int) -> str:
i = str(index)
back = '<a href="#fnref-' + i + '" class="footnote">↩</a>'
text = text.rstrip()[:-4] + back + "</p>"
return '<li id="fn-' + i + '">' + text + "</li>\n"
def footnotes(md: "Markdown") -> None:
"""A mistune plugin to support footnotes, spec defined at
https://michelf.ca/projects/php-markdown/extra/#footnotes
Here is an example:
.. code-block:: text
That's some text with a footnote.[^1]
[^1]: And that's the footnote.
It will be converted into HTML:
.. code-block:: html
<p>That's some text with a footnote.<sup class="footnote-ref" id="fnref-1"><a href="#fn-1">1</a></sup></p>
<section class="footnotes">
<ol>
<li id="fn-1"><p>And that's the footnote.<a href="#fnref-1" class="footnote">↩</a></p></li>
</ol>
</section>
:param md: Markdown instance
"""
md.inline.register(
"footnote",
INLINE_FOOTNOTE,
parse_inline_footnote,
before="link",
)
md.block.register(
"ref_footnote",
REF_FOOTNOTE,
parse_ref_footnote,
before="ref_link",
)
md.after_render_hooks.append(md_footnotes_hook)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("footnote_ref", render_footnote_ref)
md.renderer.register("footnote_item", render_footnote_item)
md.renderer.register("footnotes", render_footnotes)
mistune-3.1.3/src/mistune/plugins/formatting.py 0000664 0000000 0000000 00000012473 14766552020 0021700 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Match, Optional, Pattern
from ..helpers import PREVENT_BACKSLASH
if TYPE_CHECKING:
from ..core import BaseRenderer, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
__all__ = ["strikethrough", "mark", "insert", "superscript", "subscript"]
_STRIKE_END = re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\~|[^\s~])~~(?!~)")
_MARK_END = re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\=|[^\s=])==(?!=)")
_INSERT_END = re.compile(r"(?:" + PREVENT_BACKSLASH + r"\\\^|[^\s^])\^\^(?!\^)")
SUPERSCRIPT_PATTERN = r"\^(?:" + PREVENT_BACKSLASH + r"\\\^|\S|\\ )+?\^"
SUBSCRIPT_PATTERN = r"~(?:" + PREVENT_BACKSLASH + r"\\~|\S|\\ )+?~"
def parse_strikethrough(inline: "InlineParser", m: Match[str], state: "InlineState") -> Optional[int]:
return _parse_to_end(inline, m, state, "strikethrough", _STRIKE_END)
def render_strikethrough(renderer: "BaseRenderer", text: str) -> str:
return "<del>" + text + "</del>"
def parse_mark(inline: "InlineParser", m: Match[str], state: "InlineState") -> Optional[int]:
return _parse_to_end(inline, m, state, "mark", _MARK_END)
def render_mark(renderer: "BaseRenderer", text: str) -> str:
return "<mark>" + text + "</mark>"
def parse_insert(inline: "InlineParser", m: Match[str], state: "InlineState") -> Optional[int]:
return _parse_to_end(inline, m, state, "insert", _INSERT_END)
def render_insert(renderer: "BaseRenderer", text: str) -> str:
return "<ins>" + text + "</ins>"
def parse_superscript(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
return _parse_script(inline, m, state, "superscript")
def render_superscript(renderer: "BaseRenderer", text: str) -> str:
return "<sup>" + text + "</sup>"
def parse_subscript(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
return _parse_script(inline, m, state, "subscript")
def render_subscript(renderer: "BaseRenderer", text: str) -> str:
return "<sub>" + text + "</sub>"
def _parse_to_end(
inline: "InlineParser",
m: Match[str],
state: "InlineState",
tok_type: str,
end_pattern: Pattern[str],
) -> Optional[int]:
pos = m.end()
m1 = end_pattern.search(state.src, pos)
if not m1:
return None
end_pos = m1.end()
text = state.src[pos : end_pos - 2]
new_state = state.copy()
new_state.src = text
children = inline.render(new_state)
state.append_token({"type": tok_type, "children": children})
return end_pos
def _parse_script(inline: "InlineParser", m: Match[str], state: "InlineState", tok_type: str) -> int:
text = m.group(0)
new_state = state.copy()
new_state.src = text[1:-1].replace("\\ ", " ")
children = inline.render(new_state)
state.append_token({"type": tok_type, "children": children})
return m.end()
def strikethrough(md: "Markdown") -> None:
"""A mistune plugin to support strikethrough. Spec defined by
GitHub flavored Markdown and commonly used by many parsers:
.. code-block:: text
~~This was mistaken text~~
It will be converted into HTML:
.. code-block:: html
<del>This was mistaken text</del>
:param md: Markdown instance
"""
md.inline.register(
"strikethrough",
r"~~(?=[^\s~])",
parse_strikethrough,
before="link",
)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("strikethrough", render_strikethrough)
def mark(md: "Markdown") -> None:
"""A mistune plugin to add ``<mark>`` tag. Spec defined at
https://facelessuser.github.io/pymdown-extensions/extensions/mark/:
.. code-block:: text
==mark me== ==mark \\=\\= equal==
:param md: Markdown instance
"""
md.inline.register(
"mark",
r"==(?=[^\s=])",
parse_mark,
before="link",
)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("mark", render_mark)
def insert(md: "Markdown") -> None:
"""A mistune plugin to add ``<ins>`` tag. Spec defined at
https://facelessuser.github.io/pymdown-extensions/extensions/caret/#insert:
.. code-block:: text
^^insert me^^
:param md: Markdown instance
"""
md.inline.register(
"insert",
r"\^\^(?=[^\s\^])",
parse_insert,
before="link",
)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("insert", render_insert)
def superscript(md: "Markdown") -> None:
"""A mistune plugin to add ``<sup>`` tag. Spec defined at
https://pandoc.org/MANUAL.html#superscripts-and-subscripts:
.. code-block:: text
2^10^ is 1024.
:param md: Markdown instance
"""
md.inline.register("superscript", SUPERSCRIPT_PATTERN, parse_superscript, before="linebreak")
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("superscript", render_superscript)
def subscript(md: "Markdown") -> None:
"""A mistune plugin to add ``<sub>`` tag. Spec defined at
https://pandoc.org/MANUAL.html#superscripts-and-subscripts:
.. code-block:: text
H~2~O is a liquid.
:param md: Markdown instance
"""
md.inline.register("subscript", SUBSCRIPT_PATTERN, parse_subscript, before="linebreak")
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("subscript", render_subscript)
mistune-3.1.3/src/mistune/plugins/math.py 0000664 0000000 0000000 00000004142 14766552020 0020451 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Match
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
__all__ = ["math", "math_in_quote", "math_in_list"]
BLOCK_MATH_PATTERN = r"^ {0,3}\$\$[ \t]*\n(?P<math_text>[\s\S]+?)\n\$\$[ \t]*$"
INLINE_MATH_PATTERN = r"\$(?!\s)(?P<math_text>.+?)(?!\s)\$"
def parse_block_math(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
text = m.group("math_text")
state.append_token({"type": "block_math", "raw": text})
return m.end() + 1
def parse_inline_math(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
text = m.group("math_text")
state.append_token({"type": "inline_math", "raw": text})
return m.end()
def render_block_math(renderer: "BaseRenderer", text: str) -> str:
return '<div class="math">$$\n' + text + "\n$$</div>\n"
def render_inline_math(renderer: "BaseRenderer", text: str) -> str:
return r'<span class="math">\(' + text + r"\)</span>"
def math(md: "Markdown") -> None:
"""A mistune plugin to support math. The syntax is used
by many markdown extensions:
.. code-block:: text
Block math is surrounded by $$:
$$
f(a)=f(b)
$$
Inline math is surrounded by `$`, such as $f(a)=f(b)$
:param md: Markdown instance
"""
md.block.register("block_math", BLOCK_MATH_PATTERN, parse_block_math, before="list")
md.inline.register("inline_math", INLINE_MATH_PATTERN, parse_inline_math, before="link")
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("block_math", render_block_math)
md.renderer.register("inline_math", render_inline_math)
def math_in_quote(md: "Markdown") -> None:
"""Enable block math plugin in block quote."""
md.block.insert_rule(md.block.block_quote_rules, "block_math", before="list")
def math_in_list(md: "Markdown") -> None:
"""Enable block math plugin in list."""
md.block.insert_rule(md.block.list_rules, "block_math", before="list")
mistune-3.1.3/src/mistune/plugins/ruby.py 0000664 0000000 0000000 00000006322 14766552020 0020503 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Any, Dict, List, Match, Optional
from ..helpers import parse_link, parse_link_label
from ..util import unikey
if TYPE_CHECKING:
from ..core import BaseRenderer, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
RUBY_PATTERN = r"\[(?:\w+\([\w ]+\))+\]"
_ruby_re = re.compile(RUBY_PATTERN)
def parse_ruby(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
text = m.group(0)[1:-2]
items = text.split(")")
tokens = []
for item in items:
rb, rt = item.split("(")
tokens.append({"type": "ruby", "raw": rb, "attrs": {"rt": rt}})
end_pos = m.end()
next_match = _ruby_re.match(state.src, end_pos)
if next_match:
for tok in tokens:
state.append_token(tok)
return parse_ruby(inline, next_match, state)
# repeat link logic
if end_pos < len(state.src):
link_pos = _parse_ruby_link(inline, state, end_pos, tokens)
if link_pos:
return link_pos
for tok in tokens:
state.append_token(tok)
return end_pos
def _parse_ruby_link(
inline: "InlineParser", state: "InlineState", pos: int, tokens: List[Dict[str, Any]]
) -> Optional[int]:
c = state.src[pos]
if c == "(":
# standard link [text](<url> "title")
attrs, link_pos = parse_link(state.src, pos + 1)
if link_pos:
state.append_token(
{
"type": "link",
"children": tokens,
"attrs": attrs,
}
)
return link_pos
elif c == "[":
# standard ref link [text][label]
label, link_pos = parse_link_label(state.src, pos + 1)
if label and link_pos:
ref_links = state.env["ref_links"]
key = unikey(label)
env = ref_links.get(key)
if env:
attrs = {"url": env["url"], "title": env.get("title")}
state.append_token(
{
"type": "link",
"children": tokens,
"attrs": attrs,
}
)
else:
for tok in tokens:
state.append_token(tok)
state.append_token(
{
"type": "text",
"raw": "[" + label + "]",
}
)
return link_pos
return None
def render_ruby(renderer: "BaseRenderer", text: str, rt: str) -> str:
return "<ruby>" + text + "<rt>" + rt + "</rt></ruby>"
def ruby(md: "Markdown") -> None:
"""A mistune plugin to support ``<ruby>`` tag. The syntax is defined
at https://lepture.com/en/2022/markdown-ruby-markup:
.. code-block:: text
[漢字(ㄏㄢˋㄗˋ)]
[漢(ㄏㄢˋ)字(ㄗˋ)]
[漢字(ㄏㄢˋㄗˋ)][link]
[漢字(ㄏㄢˋㄗˋ)](/url "title")
[link]: /url "title"
:param md: Markdown instance
"""
md.inline.register("ruby", RUBY_PATTERN, parse_ruby, before="link")
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("ruby", render_ruby)
mistune-3.1.3/src/mistune/plugins/speedup.py 0000664 0000000 0000000 00000002612 14766552020 0021165 0 ustar 00root root 0000000 0000000 import re
import string
from typing import TYPE_CHECKING, Match
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BlockState, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
# because mismatch is too slow, add parsers for paragraph and text
HARD_LINEBREAK_RE = re.compile(r" *\n\s*")
PARAGRAPH = (
# start with none punctuation, not number, not whitespace
r"(?:^[^\s\d" + re.escape(string.punctuation) + r"][^\n]*\n)+"
)
__all__ = ["speedup"]
def parse_text(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
text = m.group(0)
text = HARD_LINEBREAK_RE.sub("\n", text)
inline.process_text(text, state)
return m.end()
def parse_paragraph(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
text = m.group(0)
state.add_paragraph(text)
return m.end()
def speedup(md: "Markdown") -> None:
"""Increase the speed of parsing paragraph and inline text."""
md.block.register("paragraph", PARAGRAPH, parse_paragraph)
punc = r"\\><!\[_*`~\^\$="
text_pattern = r"[\s\S]+?(?=[" + punc + r"]|"
if "url_link" in md.inline.rules:
text_pattern += "https?:|"
if md.inline.hard_wrap:
text_pattern += r" *\n|"
else:
text_pattern += r" {2,}\n|"
text_pattern += r"$)"
md.inline.register("text", text_pattern, parse_text)
mistune-3.1.3/src/mistune/plugins/spoiler.py 0000664 0000000 0000000 00000005407 14766552020 0021202 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Match
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState, InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
__all__ = ["spoiler"]
_BLOCK_SPOILER_START = re.compile(r"^ {0,3}! ?", re.M)
_BLOCK_SPOILER_MATCH = re.compile(r"^( {0,3}![^\n]*\n)+$")
INLINE_SPOILER_PATTERN = r">!\s*(?P<spoiler_text>.+?)\s*!<"
def parse_block_spoiler(block: "BlockParser", m: Match[str], state: "BlockState") -> int:
text, end_pos = block.extract_block_quote(m, state)
if not text.endswith("\n"):
# ensure it endswith \n to make sure
# _BLOCK_SPOILER_MATCH.match works
text += "\n"
depth = state.depth()
if not depth and _BLOCK_SPOILER_MATCH.match(text):
text = _BLOCK_SPOILER_START.sub("", text)
tok_type = "block_spoiler"
else:
tok_type = "block_quote"
# scan children state
child = state.child_state(text)
if state.depth() >= block.max_nested_level - 1:
rules = list(block.block_quote_rules)
rules.remove("block_quote")
else:
rules = block.block_quote_rules
block.parse(child, rules)
token = {"type": tok_type, "children": child.tokens}
if end_pos:
state.prepend_token(token)
return end_pos
state.append_token(token)
return state.cursor
def parse_inline_spoiler(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
text = m.group("spoiler_text")
new_state = state.copy()
new_state.src = text
children = inline.render(new_state)
state.append_token({"type": "inline_spoiler", "children": children})
return m.end()
def render_block_spoiler(renderer: "BaseRenderer", text: str) -> str:
return '<div class="spoiler">\n' + text + "</div>\n"
def render_inline_spoiler(renderer: "BaseRenderer", text: str) -> str:
return '<span class="spoiler">' + text + "</span>"
def spoiler(md: "Markdown") -> None:
"""A mistune plugin to support block and inline spoiler. The
syntax is inspired by stackexchange:
.. code-block:: text
Block level spoiler looks like block quote, but with `>!`:
>! this is spoiler
>!
>! the content will be hidden
Inline spoiler is surrounded by `>!` and `!<`, such as >! hide me !<.
:param md: Markdown instance
"""
# reset block quote parser with block spoiler parser
md.block.register("block_quote", None, parse_block_spoiler)
md.inline.register("inline_spoiler", INLINE_SPOILER_PATTERN, parse_inline_spoiler)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("block_spoiler", render_block_spoiler)
md.renderer.register("inline_spoiler", render_inline_spoiler)
mistune-3.1.3/src/mistune/plugins/table.py 0000664 0000000 0000000 00000013132 14766552020 0020606 0 ustar 00root root 0000000 0000000 import re
from typing import (
TYPE_CHECKING,
Any,
Dict,
List,
Match,
Optional,
Tuple,
Union,
)
from ..helpers import PREVENT_BACKSLASH
if TYPE_CHECKING:
from ..block_parser import BlockParser
from ..core import BaseRenderer, BlockState
from ..markdown import Markdown
# https://michelf.ca/projects/php-markdown/extra/#table
__all__ = ["table", "table_in_quote", "table_in_list"]
TABLE_PATTERN = (
r"^ {0,3}\|(?P<table_head>.+)\|[ \t]*\n"
r" {0,3}\|(?P<table_align> *[-:]+[-| :]*)\|[ \t]*\n"
r"(?P<table_body>(?: {0,3}\|.*\|[ \t]*(?:\n|$))*)\n*"
)
NP_TABLE_PATTERN = (
r"^ {0,3}(?P<nptable_head>\S.*\|.*)\n"
r" {0,3}(?P<nptable_align>[-:]+ *\|[-| :]*)\n"
r"(?P<nptable_body>(?:.*\|.*(?:\n|$))*)\n*"
)
TABLE_CELL = re.compile(r"^ {0,3}\|(.+)\|[ \t]*$")
CELL_SPLIT = re.compile(r" *" + PREVENT_BACKSLASH + r"\| *")
ALIGN_CENTER = re.compile(r"^ *:-+: *$")
ALIGN_LEFT = re.compile(r"^ *:-+ *$")
ALIGN_RIGHT = re.compile(r"^ *-+: *$")
def parse_table(block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
pos = m.end()
header = m.group("table_head")
align = m.group("table_align")
thead, aligns = _process_thead(header, align)
if not thead:
return None
assert aligns is not None
rows = []
body = m.group("table_body")
for text in body.splitlines():
m2 = TABLE_CELL.match(text)
if not m2: # pragma: no cover
return None
row = _process_row(m2.group(1), aligns)
if not row:
return None
rows.append(row)
children = [thead, {"type": "table_body", "children": rows}]
state.append_token({"type": "table", "children": children})
return pos
def parse_nptable(block: "BlockParser", m: Match[str], state: "BlockState") -> Optional[int]:
header = m.group("nptable_head")
align = m.group("nptable_align")
thead, aligns = _process_thead(header, align)
if not thead:
return None
assert aligns is not None
rows = []
body = m.group("nptable_body")
for text in body.splitlines():
row = _process_row(text, aligns)
if not row:
return None
rows.append(row)
children = [thead, {"type": "table_body", "children": rows}]
state.append_token({"type": "table", "children": children})
return m.end()
def _process_thead(header: str, align: str) -> Union[Tuple[None, None], Tuple[Dict[str, Any], List[str]]]:
headers = CELL_SPLIT.split(header)
aligns = CELL_SPLIT.split(align)
if len(headers) != len(aligns):
return None, None
for i, v in enumerate(aligns):
if ALIGN_CENTER.match(v):
aligns[i] = "center"
elif ALIGN_LEFT.match(v):
aligns[i] = "left"
elif ALIGN_RIGHT.match(v):
aligns[i] = "right"
else:
aligns[i] = None
children = [
{"type": "table_cell", "text": text.strip(), "attrs": {"align": aligns[i], "head": True}}
for i, text in enumerate(headers)
]
thead = {"type": "table_head", "children": children}
return thead, aligns
def _process_row(text: str, aligns: List[str]) -> Optional[Dict[str, Any]]:
cells = CELL_SPLIT.split(text)
if len(cells) != len(aligns):
return None
children = [
{"type": "table_cell", "text": text.strip(), "attrs": {"align": aligns[i], "head": False}}
for i, text in enumerate(cells)
]
return {"type": "table_row", "children": children}
def render_table(renderer: "BaseRenderer", text: str) -> str:
return "<table>\n" + text + "</table>\n"
def render_table_head(renderer: "BaseRenderer", text: str) -> str:
return "<thead>\n<tr>\n" + text + "</tr>\n</thead>\n"
def render_table_body(renderer: "BaseRenderer", text: str) -> str:
return "<tbody>\n" + text + "</tbody>\n"
def render_table_row(renderer: "BaseRenderer", text: str) -> str:
return "<tr>\n" + text + "</tr>\n"
def render_table_cell(renderer: "BaseRenderer", text: str, align: Optional[str] = None, head: bool = False) -> str:
if head:
tag = "th"
else:
tag = "td"
html = " <" + tag
if align:
html += ' style="text-align:' + align + '"'
return html + ">" + text + "</" + tag + ">\n"
def table(md: "Markdown") -> None:
"""A mistune plugin to support table, spec defined at
https://michelf.ca/projects/php-markdown/extra/#table
Here is an example:
.. code-block:: text
First Header | Second Header
------------- | -------------
Content Cell | Content Cell
Content Cell | Content Cell
:param md: Markdown instance
"""
md.block.register("table", TABLE_PATTERN, parse_table, before="paragraph")
md.block.register("nptable", NP_TABLE_PATTERN, parse_nptable, before="paragraph")
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("table", render_table)
md.renderer.register("table_head", render_table_head)
md.renderer.register("table_body", render_table_body)
md.renderer.register("table_row", render_table_row)
md.renderer.register("table_cell", render_table_cell)
def table_in_quote(md: "Markdown") -> None:
"""Enable table plugin in block quotes."""
md.block.insert_rule(md.block.block_quote_rules, "table", before="paragraph")
md.block.insert_rule(md.block.block_quote_rules, "nptable", before="paragraph")
def table_in_list(md: "Markdown") -> None:
"""Enable table plugin in list."""
md.block.insert_rule(md.block.list_rules, "table", before="paragraph")
md.block.insert_rule(md.block.list_rules, "nptable", before="paragraph")
mistune-3.1.3/src/mistune/plugins/task_lists.py 0000664 0000000 0000000 00000003720 14766552020 0021701 0 ustar 00root root 0000000 0000000 import re
from typing import TYPE_CHECKING, Any, Dict, Iterable
if TYPE_CHECKING:
from ..core import BaseRenderer, BlockState
from ..markdown import Markdown
__all__ = ["task_lists"]
TASK_LIST_ITEM = re.compile(r"^(\[[ xX]\])\s+")
def task_lists_hook(md: "Markdown", state: "BlockState") -> Iterable[Dict[str, Any]]:
return _rewrite_all_list_items(state.tokens)
def render_task_list_item(renderer: "BaseRenderer", text: str, checked: bool = False) -> str:
checkbox = '<input class="task-list-item-checkbox" type="checkbox" disabled'
if checked:
checkbox += " checked/>"
else:
checkbox += "/>"
if text.startswith("<p>"):
text = text.replace("<p>", "<p>" + checkbox, 1)
else:
text = checkbox + text
return '<li class="task-list-item">' + text + "</li>\n"
def task_lists(md: "Markdown") -> None:
"""A mistune plugin to support task lists. Spec defined by
GitHub flavored Markdown and commonly used by many parsers:
.. code-block:: text
- [ ] unchecked task
- [x] checked task
:param md: Markdown instance
"""
md.before_render_hooks.append(task_lists_hook)
if md.renderer and md.renderer.NAME == "html":
md.renderer.register("task_list_item", render_task_list_item)
def _rewrite_all_list_items(tokens: Iterable[Dict[str, Any]]) -> Iterable[Dict[str, Any]]:
for tok in tokens:
if tok["type"] == "list_item":
_rewrite_list_item(tok)
if "children" in tok:
_rewrite_all_list_items(tok["children"])
return tokens
def _rewrite_list_item(tok: Dict[str, Any]) -> None:
children = tok["children"]
if children:
first_child = children[0]
text = first_child.get("text", "")
m = TASK_LIST_ITEM.match(text)
if m:
mark = m.group(1)
first_child["text"] = text[m.end() :]
tok["type"] = "task_list_item"
tok["attrs"] = {"checked": mark != "[ ]"}
mistune-3.1.3/src/mistune/plugins/url.py 0000664 0000000 0000000 00000001440 14766552020 0020320 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Match
from ..util import escape_url
if TYPE_CHECKING:
from ..core import InlineState
from ..inline_parser import InlineParser
from ..markdown import Markdown
__all__ = ["url"]
URL_LINK_PATTERN = r"""https?:\/\/[^\s<]+[^<.,:;"')\]\s]"""
def parse_url_link(inline: "InlineParser", m: Match[str], state: "InlineState") -> int:
text = m.group(0)
pos = m.end()
if state.in_link:
inline.process_text(text, state)
return pos
state.append_token(
{
"type": "link",
"children": [{"type": "text", "raw": text}],
"attrs": {"url": escape_url(text)},
}
)
return pos
def url(md: "Markdown") -> None:
md.inline.register("url_link", URL_LINK_PATTERN, parse_url_link)
mistune-3.1.3/src/mistune/py.typed 0000664 0000000 0000000 00000000265 14766552020 0017166 0 ustar 00root root 0000000 0000000 # when type checking dependents, tell type checkers, e.g. mypy, to use this package's types
# without this file, mypy will write a warning and ignore type annotations from mistune.
mistune-3.1.3/src/mistune/renderers/ 0000775 0000000 0000000 00000000000 14766552020 0017455 5 ustar 00root root 0000000 0000000 mistune-3.1.3/src/mistune/renderers/__init__.py 0000664 0000000 0000000 00000000000 14766552020 0021554 0 ustar 00root root 0000000 0000000 mistune-3.1.3/src/mistune/renderers/_list.py 0000664 0000000 0000000 00000004022 14766552020 0021137 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Any, Dict, Iterable, cast
from ..util import strip_end
if TYPE_CHECKING:
from ..core import BaseRenderer, BlockState
def render_list(renderer: "BaseRenderer", token: Dict[str, Any], state: "BlockState") -> str:
attrs = token["attrs"]
if attrs["ordered"]:
children = _render_ordered_list(renderer, token, state)
else:
children = _render_unordered_list(renderer, token, state)
text = "".join(children)
parent = token.get("parent")
if parent:
if parent["tight"]:
return text
return text + "\n"
return strip_end(text) + "\n"
def _render_list_item(
renderer: "BaseRenderer",
parent: Dict[str, Any],
item: Dict[str, Any],
state: "BlockState",
) -> str:
leading = cast(str, parent["leading"])
text = ""
for tok in item["children"]:
if tok["type"] == "list":
tok["parent"] = parent
elif tok["type"] == "blank_line":
continue
text += renderer.render_token(tok, state)
lines = text.splitlines()
text = (lines[0] if lines else "") + "\n"
prefix = " " * len(leading)
for line in lines[1:]:
if line:
text += prefix + line + "\n"
else:
text += "\n"
return leading + text
def _render_ordered_list(renderer: "BaseRenderer", token: Dict[str, Any], state: "BlockState") -> Iterable[str]:
attrs = token["attrs"]
start = attrs.get("start", 1)
for item in token["children"]:
leading = str(start) + token["bullet"] + " "
parent = {
"leading": leading,
"tight": token["tight"],
}
yield _render_list_item(renderer, parent, item, state)
start += 1
def _render_unordered_list(renderer: "BaseRenderer", token: Dict[str, Any], state: "BlockState") -> Iterable[str]:
parent = {
"leading": token["bullet"] + " ",
"tight": token["tight"],
}
for item in token["children"]:
yield _render_list_item(renderer, parent, item, state)
mistune-3.1.3/src/mistune/renderers/html.py 0000664 0000000 0000000 00000011476 14766552020 0021004 0 ustar 00root root 0000000 0000000 from typing import Any, ClassVar, Dict, Optional, Tuple, Literal
from ..core import BaseRenderer, BlockState
from ..util import escape as escape_text
from ..util import safe_entity, striptags
class HTMLRenderer(BaseRenderer):
"""A renderer for converting Markdown to HTML."""
_escape: bool
NAME: ClassVar[Literal["html"]] = "html"
HARMFUL_PROTOCOLS: ClassVar[Tuple[str, ...]] = (
"javascript:",
"vbscript:",
"file:",
"data:",
)
GOOD_DATA_PROTOCOLS: ClassVar[Tuple[str, ...]] = (
"data:image/gif;",
"data:image/png;",
"data:image/jpeg;",
"data:image/webp;",
)
def __init__(self, escape: bool = True, allow_harmful_protocols: Optional[bool] = None) -> None:
super(HTMLRenderer, self).__init__()
self._allow_harmful_protocols = allow_harmful_protocols
self._escape = escape
def render_token(self, token: Dict[str, Any], state: BlockState) -> str:
# backward compitable with v2
func = self._get_method(token["type"])
attrs = token.get("attrs")
if "raw" in token:
text = token["raw"]
elif "children" in token:
text = self.render_tokens(token["children"], state)
else:
if attrs:
return func(**attrs)
else:
return func()
if attrs:
return func(text, **attrs)
else:
return func(text)
def safe_url(self, url: str) -> str:
"""Ensure the given URL is safe. This method is used for rendering
links, images, and etc.
"""
if self._allow_harmful_protocols is True:
return escape_text(url)
_url = url.lower()
if self._allow_harmful_protocols and _url.startswith(tuple(self._allow_harmful_protocols)):
return escape_text(url)
if _url.startswith(self.HARMFUL_PROTOCOLS) and not _url.startswith(self.GOOD_DATA_PROTOCOLS):
return "#harmful-link"
return escape_text(url)
def text(self, text: str) -> str:
if self._escape:
return escape_text(text)
return safe_entity(text)
def emphasis(self, text: str) -> str:
return "<em>" + text + "</em>"
def strong(self, text: str) -> str:
return "<strong>" + text + "</strong>"
def link(self, text: str, url: str, title: Optional[str] = None) -> str:
s = '<a href="' + self.safe_url(url) + '"'
if title:
s += ' title="' + safe_entity(title) + '"'
return s + ">" + text + "</a>"
def image(self, text: str, url: str, title: Optional[str] = None) -> str:
src = self.safe_url(url)
alt = escape_text(striptags(text))
s = '<img src="' + src + '" alt="' + alt + '"'
if title:
s += ' title="' + safe_entity(title) + '"'
return s + " />"
def codespan(self, text: str) -> str:
return "<code>" + escape_text(text) + "</code>"
def linebreak(self) -> str:
return "<br />\n"
def softbreak(self) -> str:
return "\n"
def inline_html(self, html: str) -> str:
if self._escape:
return escape_text(html)
return html
def paragraph(self, text: str) -> str:
return "<p>" + text + "</p>\n"
def heading(self, text: str, level: int, **attrs: Any) -> str:
tag = "h" + str(level)
html = "<" + tag
_id = attrs.get("id")
if _id:
html += ' id="' + _id + '"'
return html + ">" + text + "</" + tag + ">\n"
def blank_line(self) -> str:
return ""
def thematic_break(self) -> str:
return "<hr />\n"
def block_text(self, text: str) -> str:
return text
def block_code(self, code: str, info: Optional[str] = None) -> str:
html = "<pre><code"
if info is not None:
info = safe_entity(info.strip())
if info:
lang = info.split(None, 1)[0]
html += ' class="language-' + lang + '"'
return html + ">" + escape_text(code) + "</code></pre>\n"
def block_quote(self, text: str) -> str:
return "<blockquote>\n" + text + "</blockquote>\n"
def block_html(self, html: str) -> str:
if self._escape:
return "<p>" + escape_text(html.strip()) + "</p>\n"
return html + "\n"
def block_error(self, text: str) -> str:
return '<div class="error"><pre>' + text + "</pre></div>\n"
def list(self, text: str, ordered: bool, **attrs: Any) -> str:
if ordered:
html = "<ol"
start = attrs.get("start")
if start is not None:
html += ' start="' + str(start) + '"'
return html + ">\n" + text + "</ol>\n"
return "<ul>\n" + text + "</ul>\n"
def list_item(self, text: str) -> str:
return "<li>" + text + "</li>\n"
mistune-3.1.3/src/mistune/renderers/markdown.py 0000664 0000000 0000000 00000011542 14766552020 0021654 0 ustar 00root root 0000000 0000000 import re
from textwrap import indent
from typing import Any, Dict, Iterable, cast
from ..core import BaseRenderer, BlockState
from ..util import strip_end
from ._list import render_list
fenced_re = re.compile(r"^[`~]+", re.M)
class MarkdownRenderer(BaseRenderer):
"""A renderer to re-format Markdown text."""
NAME = "markdown"
def __call__(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str:
out = self.render_tokens(tokens, state)
# special handle for line breaks
out += "\n\n".join(self.render_referrences(state)) + "\n"
return strip_end(out)
def render_referrences(self, state: BlockState) -> Iterable[str]:
ref_links = state.env["ref_links"]
for key in ref_links:
attrs = ref_links[key]
text = "[" + attrs["label"] + "]: " + attrs["url"]
title = attrs.get("title")
if title:
text += ' "' + title + '"'
yield text
def render_children(self, token: Dict[str, Any], state: BlockState) -> str:
children = token["children"]
return self.render_tokens(children, state)
def text(self, token: Dict[str, Any], state: BlockState) -> str:
return cast(str, token["raw"])
def emphasis(self, token: Dict[str, Any], state: BlockState) -> str:
return "*" + self.render_children(token, state) + "*"
def strong(self, token: Dict[str, Any], state: BlockState) -> str:
return "**" + self.render_children(token, state) + "**"
def link(self, token: Dict[str, Any], state: BlockState) -> str:
label = cast(str, token.get("label"))
text = self.render_children(token, state)
out = "[" + text + "]"
if label:
return out + "[" + label + "]"
attrs = token["attrs"]
url = attrs["url"]
title = attrs.get("title")
if text == url and not title:
return "<" + text + ">"
elif "mailto:" + text == url and not title:
return "<" + text + ">"
out += "("
if "(" in url or ")" in url:
out += "<" + url + ">"
else:
out += url
if title:
out += ' "' + title + '"'
return out + ")"
def image(self, token: Dict[str, Any], state: BlockState) -> str:
return "!" + self.link(token, state)
def codespan(self, token: Dict[str, Any], state: BlockState) -> str:
return "`" + cast(str, token["raw"]) + "`"
def linebreak(self, token: Dict[str, Any], state: BlockState) -> str:
return " \n"
def softbreak(self, token: Dict[str, Any], state: BlockState) -> str:
return "\n"
def blank_line(self, token: Dict[str, Any], state: BlockState) -> str:
return ""
def inline_html(self, token: Dict[str, Any], state: BlockState) -> str:
return cast(str, token["raw"])
def paragraph(self, token: Dict[str, Any], state: BlockState) -> str:
text = self.render_children(token, state)
return text + "\n\n"
def heading(self, token: Dict[str, Any], state: BlockState) -> str:
level = cast(int, token["attrs"]["level"])
marker = "#" * level
text = self.render_children(token, state)
return marker + " " + text + "\n\n"
def thematic_break(self, token: Dict[str, Any], state: BlockState) -> str:
return "***\n\n"
def block_text(self, token: Dict[str, Any], state: BlockState) -> str:
return self.render_children(token, state) + "\n"
def block_code(self, token: Dict[str, Any], state: BlockState) -> str:
attrs = token.get("attrs", {})
info = cast(str, attrs.get("info", ""))
code = cast(str, token["raw"])
if code and code[-1] != "\n":
code += "\n"
marker = token.get("marker")
if not marker:
marker = _get_fenced_marker(code)
marker2 = cast(str, marker)
return marker2 + info + "\n" + code + marker2 + "\n\n"
def block_quote(self, token: Dict[str, Any], state: BlockState) -> str:
text = indent(self.render_children(token, state), "> ", lambda _: True)
text = text.rstrip("> \n")
return text + "\n\n"
def block_html(self, token: Dict[str, Any], state: BlockState) -> str:
return cast(str, token["raw"]) + "\n\n"
def block_error(self, token: Dict[str, Any], state: BlockState) -> str:
return ""
def list(self, token: Dict[str, Any], state: BlockState) -> str:
return render_list(self, token, state)
def _get_fenced_marker(code: str) -> str:
found = fenced_re.findall(code)
if not found:
return "```"
ticks = [] # `
waves = [] # ~
for s in found:
if s[0] == "`":
ticks.append(len(s))
else:
waves.append(len(s))
if not ticks:
return "```"
if not waves:
return "~~~"
return "`" * (max(ticks) + 1)
mistune-3.1.3/src/mistune/renderers/rst.py 0000664 0000000 0000000 00000012623 14766552020 0020643 0 ustar 00root root 0000000 0000000 from textwrap import indent
from typing import Any, Dict, Iterable, List, cast
from ..core import BaseRenderer, BlockState
from ..util import strip_end
from ._list import render_list
class RSTRenderer(BaseRenderer):
"""A renderer for converting Markdown to ReST."""
NAME = "rst"
#: marker symbols for heading
HEADING_MARKERS = {
1: "=",
2: "-",
3: "~",
4: "^",
5: '"',
6: "'",
}
INLINE_IMAGE_PREFIX = "img-"
def iter_tokens(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> Iterable[str]:
prev = None
for tok in tokens:
# ignore blank line
if tok["type"] == "blank_line":
continue
tok["prev"] = prev
prev = tok
yield self.render_token(tok, state)
def __call__(self, tokens: Iterable[Dict[str, Any]], state: BlockState) -> str:
state.env["inline_images"] = []
out = self.render_tokens(tokens, state)
# special handle for line breaks
out += "\n\n".join(self.render_referrences(state)) + "\n"
return strip_end(out)
def render_referrences(self, state: BlockState) -> Iterable[str]:
images = state.env["inline_images"]
for index, token in enumerate(images):
attrs = token["attrs"]
alt = self.render_children(token, state)
ident = self.INLINE_IMAGE_PREFIX + str(index)
yield ".. |" + ident + "| image:: " + attrs["url"] + "\n :alt: " + alt
def render_children(self, token: Dict[str, Any], state: BlockState) -> str:
children = token["children"]
return self.render_tokens(children, state)
def text(self, token: Dict[str, Any], state: BlockState) -> str:
text = cast(str, token["raw"])
return text.replace("|", r"\|")
def emphasis(self, token: Dict[str, Any], state: BlockState) -> str:
return "*" + self.render_children(token, state) + "*"
def strong(self, token: Dict[str, Any], state: BlockState) -> str:
return "**" + self.render_children(token, state) + "**"
def link(self, token: Dict[str, Any], state: BlockState) -> str:
attrs = token["attrs"]
text = self.render_children(token, state)
return "`" + text + " <" + cast(str, attrs["url"]) + ">`__"
def image(self, token: Dict[str, Any], state: BlockState) -> str:
refs: List[Dict[str, Any]] = state.env["inline_images"]
index = len(refs)
refs.append(token)
return "|" + self.INLINE_IMAGE_PREFIX + str(index) + "|"
def codespan(self, token: Dict[str, Any], state: BlockState) -> str:
return "``" + cast(str, token["raw"]) + "``"
def linebreak(self, token: Dict[str, Any], state: BlockState) -> str:
return "<linebreak>"
def softbreak(self, token: Dict[str, Any], state: BlockState) -> str:
return " "
def inline_html(self, token: Dict[str, Any], state: BlockState) -> str:
# rst does not support inline html
return ""
def paragraph(self, token: Dict[str, Any], state: BlockState) -> str:
children = token["children"]
if len(children) == 1 and children[0]["type"] == "image":
image = children[0]
attrs = image["attrs"]
title = cast(str, attrs.get("title"))
alt = self.render_children(image, state)
text = ".. figure:: " + cast(str, attrs["url"])
if title:
text += "\n :alt: " + title
text += "\n\n" + indent(alt, " ")
else:
text = self.render_tokens(children, state)
lines = text.split("<linebreak>")
if len(lines) > 1:
text = "\n".join("| " + line for line in lines)
return text + "\n\n"
def heading(self, token: Dict[str, Any], state: BlockState) -> str:
attrs = token["attrs"]
text = self.render_children(token, state)
marker = self.HEADING_MARKERS[attrs["level"]]
return text + "\n" + marker * len(text) + "\n\n"
def thematic_break(self, token: Dict[str, Any], state: BlockState) -> str:
return "--------------\n\n"
def block_text(self, token: Dict[str, Any], state: BlockState) -> str:
return self.render_children(token, state) + "\n"
def block_code(self, token: Dict[str, Any], state: BlockState) -> str:
attrs = token.get("attrs", {})
info = cast(str, attrs.get("info"))
code = indent(cast(str, token["raw"]), " ")
if info:
lang = info.split()[0]
return ".. code:: " + lang + "\n\n" + code + "\n"
else:
return "::\n\n" + code + "\n\n"
def block_quote(self, token: Dict[str, Any], state: BlockState) -> str:
text = indent(self.render_children(token, state), " ")
prev = token["prev"]
ignore_blocks = (
"paragraph",
"thematic_break",
"linebreak",
"heading",
)
if prev and prev["type"] not in ignore_blocks:
text = "..\n\n" + text
return text
def block_html(self, token: Dict[str, Any], state: BlockState) -> str:
raw = token["raw"]
return ".. raw:: html\n\n" + indent(raw, " ") + "\n\n"
def block_error(self, token: Dict[str, Any], state: BlockState) -> str:
return ""
def list(self, token: Dict[str, Any], state: BlockState) -> str:
return render_list(self, token, state)
mistune-3.1.3/src/mistune/toc.py 0000664 0000000 0000000 00000007066 14766552020 0016634 0 ustar 00root root 0000000 0000000 from typing import TYPE_CHECKING, Any, Callable, Dict, Iterable, List, Optional, Tuple
from .core import BlockState
from .util import striptags
if TYPE_CHECKING:
from .markdown import Markdown
def add_toc_hook(
md: "Markdown",
min_level: int = 1,
max_level: int = 3,
heading_id: Optional[Callable[[Dict[str, Any], int], str]] = None,
) -> None:
"""Add a hook to save toc items into ``state.env``. This is
usually helpful for doc generator::
import mistune
from mistune.toc import add_toc_hook, render_toc_ul
md = mistune.create_markdown(...)
add_toc_hook(md)
html, state = md.parse(text)
toc_items = state.env['toc_items']
toc_html = render_toc_ul(toc_items)
:param md: Markdown instance
:param min_level: min heading level
:param max_level: max heading level
:param heading_id: a function to generate heading_id
"""
if heading_id is None:
def heading_id(token: Dict[str, Any], index: int) -> str:
return "toc_" + str(index + 1)
def toc_hook(md: "Markdown", state: "BlockState") -> None:
headings = []
for tok in state.tokens:
if tok["type"] == "heading":
level = tok["attrs"]["level"]
if min_level <= level <= max_level:
headings.append(tok)
toc_items = []
for i, tok in enumerate(headings):
tok["attrs"]["id"] = heading_id(tok, i)
toc_items.append(normalize_toc_item(md, tok))
# save items into state
state.env["toc_items"] = toc_items
md.before_render_hooks.append(toc_hook)
def normalize_toc_item(md: "Markdown", token: Dict[str, Any]) -> Tuple[int, str, str]:
text = token["text"]
tokens = md.inline(text, {})
assert md.renderer is not None
html = md.renderer(tokens, BlockState())
text = striptags(html)
attrs = token["attrs"]
return attrs["level"], attrs["id"], text
def render_toc_ul(toc: Iterable[Tuple[int, str, str]]) -> str:
"""Render a <ul> table of content HTML. The param "toc" should
be formatted into this structure::
[
(level, id, text),
]
For example::
[
(1, 'toc-intro', 'Introduction'),
(2, 'toc-install', 'Install'),
(2, 'toc-upgrade', 'Upgrade'),
(1, 'toc-license', 'License'),
]
"""
if not toc:
return ""
s = ""
levels: List[int] = []
for level, k, text in toc:
item = '<a href="#{}">{}</a>'.format(k, text)
if not levels:
s += "<li>" + item
levels.append(level)
elif level == levels[-1]:
s += "</li>\n<li>" + item
elif level > levels[-1]:
s += "\n<ul>\n<li>" + item
levels.append(level)
else:
levels.pop()
while levels:
last_level = levels.pop()
if level == last_level:
s += "</li>\n</ul>\n</li>\n<li>" + item
levels.append(level)
break
elif level > last_level:
s += "</li>\n<li>" + item
levels.append(last_level)
levels.append(level)
break
else:
s += "</li>\n</ul>\n"
else:
levels.append(level)
s += "</li>\n<li>" + item
while len(levels) > 1:
s += "</li>\n</ul>\n"
levels.pop()
if not s:
return ""
return "<ul>\n" + s + "</li>\n</ul>\n"
mistune-3.1.3/src/mistune/util.py 0000664 0000000 0000000 00000003672 14766552020 0017023 0 ustar 00root root 0000000 0000000 import re
from html import _replace_charref # type: ignore[attr-defined]
from typing import Match
from urllib.parse import quote
_expand_tab_re = re.compile(r"^( {0,3})\t", flags=re.M)
def expand_leading_tab(text: str, width: int = 4) -> str:
def repl(m: Match[str]) -> str:
s = m.group(1)
return s + " " * (width - len(s))
return _expand_tab_re.sub(repl, text)
def expand_tab(text: str, space: str = " ") -> str:
repl = r"\1" + space
return _expand_tab_re.sub(repl, text)
def escape(s: str, quote: bool = True) -> str:
"""Escape characters of ``&<>``. If quote=True, ``"`` will be
converted to ``"e;``."""
s = s.replace("&", "&")
s = s.replace("<", "<")
s = s.replace(">", ">")
if quote:
s = s.replace('"', """)
return s
def escape_url(link: str) -> str:
"""Escape URL for safety."""
safe = (
":/?#@" # gen-delims - '[]' (rfc3986)
"!$&()*+,;=" # sub-delims - "'" (rfc3986)
"%" # leave already-encoded octets alone
)
return quote(unescape(link), safe=safe)
def safe_entity(s: str) -> str:
"""Escape characters for safety."""
return escape(unescape(s))
def unikey(s: str) -> str:
"""Generate a unique key for links and footnotes."""
key = " ".join(s.split()).strip()
return key.lower().upper()
_charref_re = re.compile(
r"&(#[0-9]{1,7};"
r"|#[xX][0-9a-fA-F]+;"
r"|[^\t\n\f <&#;]{1,32};)"
)
def unescape(s: str) -> str:
"""
Copy from `html.unescape`, but `_charref` is different. CommonMark
does not accept entity references without a trailing semicolon
"""
if "&" not in s:
return s
return _charref_re.sub(_replace_charref, s)
_striptags_re = re.compile(r"(<!--.*?-->|<[^>]*>)")
def striptags(s: str) -> str:
return _striptags_re.sub("", s)
_strip_end_re = re.compile(r"\n\s+$")
def strip_end(src: str) -> str:
return _strip_end_re.sub("\n", src)
mistune-3.1.3/tests/ 0000775 0000000 0000000 00000000000 14766552020 0014353 5 ustar 00root root 0000000 0000000 mistune-3.1.3/tests/__init__.py 0000664 0000000 0000000 00000002171 14766552020 0016465 0 ustar 00root root 0000000 0000000 import re
from abc import abstractmethod
from unittest import TestCase
from tests import fixtures
class BaseTestCase(TestCase):
@classmethod
def load_fixtures(cls, case_file: str) -> None:
def attach_case(n: str, text: str, html: str) -> None:
def method(self: "BaseTestCase") -> None:
self.assert_case(n, text, html)
name = "test_{}".format(n)
method.__name__ = name
method.__doc__ = "Run fixture {} - {}".format(case_file, n)
setattr(cls, name, method)
for n, text, html in fixtures.load_examples(case_file):
if cls.ignore_case(n):
continue
attach_case(n, text, html)
@classmethod
def ignore_case(cls, name: str) -> bool:
return False
@abstractmethod
def parse(self, text: str) -> str: ...
def assert_case(self, name: str, text: str, html: str) -> None:
result = self.parse(text)
self.assertEqual(result, html)
def normalize_html(html: str) -> str:
html = re.sub(r">\n+", ">", html)
html = re.sub(r"\n+<", "<", html)
return html.strip()
mistune-3.1.3/tests/fixtures/ 0000775 0000000 0000000 00000000000 14766552020 0016224 5 ustar 00root root 0000000 0000000 mistune-3.1.3/tests/fixtures/__init__.py 0000664 0000000 0000000 00000002734 14766552020 0020343 0 ustar 00root root 0000000 0000000 import os
import re
import json
from typing import Any, Iterable, Tuple
ROOT = os.path.join(os.path.dirname(__file__))
EXAMPLE_PATTERN = re.compile(
r"^`{32} example\n([\s\S]*?)"
r"^\.\n([\s\S]*?)"
r"^`{32}$|^#{1,6} *(.*)$",
flags=re.M,
)
def load_ast(filename: str) -> Any:
with open(os.path.join(ROOT, "ast", filename)) as f:
return json.load(f)
def load_json(filename: str) -> Any:
with open(os.path.join(ROOT, filename)) as f:
return json.load(f)
def load_examples(filename: str) -> Iterable[Tuple[str, str, str]]:
if filename.endswith(".json"):
data = load_json(filename)
for item in data:
section = item["section"].lower().replace(" ", "_")
n = "%s_%03d" % (section, item["example"])
yield n, item["markdown"], item["html"]
else:
with open(os.path.join(ROOT, filename), "rb") as f:
content = f.read()
s = content.decode("utf-8")
yield from parse_examples(s)
def parse_examples(text: str) -> Iterable[Tuple[str, str, str]]:
data = EXAMPLE_PATTERN.findall(text)
section = None
count = 0
for md, html, title in data:
if title:
count = 0
section = title.lower().replace(" ", "_")
if md and html:
count += 1
n = "%s_%03d" % (section, count)
md = md.replace("\u2192", "\t")
html = html.replace("\u2192", "\t")
yield n, md, html
mistune-3.1.3/tests/fixtures/abbr.txt 0000664 0000000 0000000 00000005217 14766552020 0017700 0 ustar 00root root 0000000 0000000 # Abbreviation
## abbreviation
```````````````````````````````` example
HTML
.
<p>HTML</p>
````````````````````````````````
```````````````````````````````` example
HTML
*[HTML]: Hyper Text Markup Language
.
<p><abbr title="Hyper Text Markup Language">HTML</abbr></p>
````````````````````````````````
```````````````````````````````` example
The HTML specification is maintained by the W3C.
*[HTML]: Hyper Text Markup Language
*[W3C]: World Wide Web Consortium
.
<p>The <abbr title="Hyper Text Markup Language">HTML</abbr> specification is maintained by the <abbr title="World Wide Web Consortium">W3C</abbr>.</p>
````````````````````````````````
```````````````````````````````` example
The HTML specification is maintained by the W3C.
*[HTML]:
Hyper Text Markup Language
*[W3C]:
World Wide Web Consortium
.
<p>The <abbr title="Hyper Text Markup Language">HTML</abbr> specification is maintained by the <abbr title="World Wide Web Consortium">W3C</abbr>.</p>
````````````````````````````````
```````````````````````````````` example
The HTML specification is maintained by the W3C.
*[HTML]: Hyper Text Markup Language
*[W3C]: World Wide Web Consortium
There is more text below this one.
.
<p>The <abbr title="Hyper Text Markup Language">HTML</abbr> specification is maintained by the <abbr title="World Wide Web Consortium">W3C</abbr>.</p>
<p>There is more text below this one.</p>
````````````````````````````````
```````````````````````````````` example
The latest spec of HTML is HTML5.
*[HTML]: Hyper Text Markup Language
.
<p>The latest spec of <abbr title="Hyper Text Markup Language">HTML</abbr> is <abbr title="Hyper Text Markup Language">HTML</abbr>5.</p>
````````````````````````````````
```````````````````````````````` example
HTML should always be spelt with capital letters and not spelt html.
*[HTML]: Hyper Text Markup Language
.
<p><abbr title="Hyper Text Markup Language">HTML</abbr> should always be spelt with capital letters and not spelt html.</p>
````````````````````````````````
```````````````````````````````` example
HTML is an abbreviation but nobody knows what it stands for.
*[HTML]:
.
<p><abbr>HTML</abbr> is an abbreviation but nobody knows what it stands for.</p>
````````````````````````````````
```````````````````````````````` example
Foo.* looks like a regular expression.
*[Foo.*]: Just foo
.
<p><abbr title="Just foo">Foo.*</abbr> looks like a regular expression.</p>
````````````````````````````````
```````````````````````````````` example
Untrusted HTML should be escaped.
*[HTML]: <p>This is some HTML</p>
.
<p>Untrusted <abbr title="<p>This is some HTML</p>">HTML</abbr> should be escaped.</p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/commonmark.json 0000664 0000000 0000000 00000422207 14766552020 0021271 0 ustar 00root root 0000000 0000000 [
{
"markdown": "\tfoo\tbaz\t\tbim\n",
"html": "<pre><code>foo\tbaz\t\tbim\n</code></pre>\n",
"example": 1,
"start_line": 356,
"end_line": 361,
"section": "Tabs"
},
{
"markdown": " \tfoo\tbaz\t\tbim\n",
"html": "<pre><code>foo\tbaz\t\tbim\n</code></pre>\n",
"example": 2,
"start_line": 363,
"end_line": 368,
"section": "Tabs"
},
{
"markdown": " a\ta\n ὐ\ta\n",
"html": "<pre><code>a\ta\nὐ\ta\n</code></pre>\n",
"example": 3,
"start_line": 370,
"end_line": 377,
"section": "Tabs"
},
{
"markdown": " - foo\n\n\tbar\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
"example": 4,
"start_line": 383,
"end_line": 394,
"section": "Tabs"
},
{
"markdown": "- foo\n\n\t\tbar\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<pre><code> bar\n</code></pre>\n</li>\n</ul>\n",
"example": 5,
"start_line": 396,
"end_line": 408,
"section": "Tabs"
},
{
"markdown": ">\t\tfoo\n",
"html": "<blockquote>\n<pre><code> foo\n</code></pre>\n</blockquote>\n",
"example": 6,
"start_line": 419,
"end_line": 426,
"section": "Tabs"
},
{
"markdown": "-\t\tfoo\n",
"html": "<ul>\n<li>\n<pre><code> foo\n</code></pre>\n</li>\n</ul>\n",
"example": 7,
"start_line": 428,
"end_line": 437,
"section": "Tabs"
},
{
"markdown": " foo\n\tbar\n",
"html": "<pre><code>foo\nbar\n</code></pre>\n",
"example": 8,
"start_line": 440,
"end_line": 447,
"section": "Tabs"
},
{
"markdown": " - foo\n - bar\n\t - baz\n",
"html": "<ul>\n<li>foo\n<ul>\n<li>bar\n<ul>\n<li>baz</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n",
"example": 9,
"start_line": 449,
"end_line": 465,
"section": "Tabs"
},
{
"markdown": "#\tFoo\n",
"html": "<h1>Foo</h1>\n",
"example": 10,
"start_line": 467,
"end_line": 471,
"section": "Tabs"
},
{
"markdown": "*\t*\t*\t\n",
"html": "<hr />\n",
"example": 11,
"start_line": 473,
"end_line": 477,
"section": "Tabs"
},
{
"markdown": "\\!\\\"\\#\\$\\%\\&\\'\\(\\)\\*\\+\\,\\-\\.\\/\\:\\;\\<\\=\\>\\?\\@\\[\\\\\\]\\^\\_\\`\\{\\|\\}\\~\n",
"html": "<p>!"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~</p>\n",
"example": 12,
"start_line": 490,
"end_line": 494,
"section": "Backslash escapes"
},
{
"markdown": "\\\t\\A\\a\\ \\3\\φ\\«\n",
"html": "<p>\\\t\\A\\a\\ \\3\\φ\\«</p>\n",
"example": 13,
"start_line": 500,
"end_line": 504,
"section": "Backslash escapes"
},
{
"markdown": "\\*not emphasized*\n\\<br/> not a tag\n\\[not a link](/foo)\n\\`not code`\n1\\. not a list\n\\* not a list\n\\# not a heading\n\\[foo]: /url \"not a reference\"\n\\ö not a character entity\n",
"html": "<p>*not emphasized*\n<br/> not a tag\n[not a link](/foo)\n`not code`\n1. not a list\n* not a list\n# not a heading\n[foo]: /url "not a reference"\nö not a character entity</p>\n",
"example": 14,
"start_line": 510,
"end_line": 530,
"section": "Backslash escapes"
},
{
"markdown": "\\\\*emphasis*\n",
"html": "<p>\\<em>emphasis</em></p>\n",
"example": 15,
"start_line": 535,
"end_line": 539,
"section": "Backslash escapes"
},
{
"markdown": "foo\\\nbar\n",
"html": "<p>foo<br />\nbar</p>\n",
"example": 16,
"start_line": 544,
"end_line": 550,
"section": "Backslash escapes"
},
{
"markdown": "`` \\[\\` ``\n",
"html": "<p><code>\\[\\`</code></p>\n",
"example": 17,
"start_line": 556,
"end_line": 560,
"section": "Backslash escapes"
},
{
"markdown": " \\[\\]\n",
"html": "<pre><code>\\[\\]\n</code></pre>\n",
"example": 18,
"start_line": 563,
"end_line": 568,
"section": "Backslash escapes"
},
{
"markdown": "~~~\n\\[\\]\n~~~\n",
"html": "<pre><code>\\[\\]\n</code></pre>\n",
"example": 19,
"start_line": 571,
"end_line": 578,
"section": "Backslash escapes"
},
{
"markdown": "<http://example.com?find=\\*>\n",
"html": "<p><a href=\"http://example.com?find=%5C*\">http://example.com?find=\\*</a></p>\n",
"example": 20,
"start_line": 581,
"end_line": 585,
"section": "Backslash escapes"
},
{
"markdown": "<a href=\"/bar\\/)\">\n",
"html": "<a href=\"/bar\\/)\">\n",
"example": 21,
"start_line": 588,
"end_line": 592,
"section": "Backslash escapes"
},
{
"markdown": "[foo](/bar\\* \"ti\\*tle\")\n",
"html": "<p><a href=\"/bar*\" title=\"ti*tle\">foo</a></p>\n",
"example": 22,
"start_line": 598,
"end_line": 602,
"section": "Backslash escapes"
},
{
"markdown": "[foo]\n\n[foo]: /bar\\* \"ti\\*tle\"\n",
"html": "<p><a href=\"/bar*\" title=\"ti*tle\">foo</a></p>\n",
"example": 23,
"start_line": 605,
"end_line": 611,
"section": "Backslash escapes"
},
{
"markdown": "``` foo\\+bar\nfoo\n```\n",
"html": "<pre><code class=\"language-foo+bar\">foo\n</code></pre>\n",
"example": 24,
"start_line": 614,
"end_line": 621,
"section": "Backslash escapes"
},
{
"markdown": " & © Æ Ď\n¾ ℋ ⅆ\n∲ ≧̸\n",
"html": "<p> & © Æ Ď\n¾ ℋ ⅆ\n∲ ≧̸</p>\n",
"example": 25,
"start_line": 650,
"end_line": 658,
"section": "Entity and numeric character references"
},
{
"markdown": "# Ӓ Ϡ �\n",
"html": "<p># Ӓ Ϡ �</p>\n",
"example": 26,
"start_line": 669,
"end_line": 673,
"section": "Entity and numeric character references"
},
{
"markdown": "" ആ ಫ\n",
"html": "<p>" ആ ಫ</p>\n",
"example": 27,
"start_line": 682,
"end_line": 686,
"section": "Entity and numeric character references"
},
{
"markdown": " &x; &#; &#x;\n�\n&#abcdef0;\n&ThisIsNotDefined; &hi?;\n",
"html": "<p>  &x; &#; &#x;\n�\n&#abcdef0;\n&ThisIsNotDefined; &hi?;</p>\n",
"example": 28,
"start_line": 691,
"end_line": 701,
"section": "Entity and numeric character references"
},
{
"markdown": "©\n",
"html": "<p>©</p>\n",
"example": 29,
"start_line": 708,
"end_line": 712,
"section": "Entity and numeric character references"
},
{
"markdown": "&MadeUpEntity;\n",
"html": "<p>&MadeUpEntity;</p>\n",
"example": 30,
"start_line": 718,
"end_line": 722,
"section": "Entity and numeric character references"
},
{
"markdown": "<a href=\"öö.html\">\n",
"html": "<a href=\"öö.html\">\n",
"example": 31,
"start_line": 729,
"end_line": 733,
"section": "Entity and numeric character references"
},
{
"markdown": "[foo](/föö \"föö\")\n",
"html": "<p><a href=\"/f%C3%B6%C3%B6\" title=\"föö\">foo</a></p>\n",
"example": 32,
"start_line": 736,
"end_line": 740,
"section": "Entity and numeric character references"
},
{
"markdown": "[foo]\n\n[foo]: /föö \"föö\"\n",
"html": "<p><a href=\"/f%C3%B6%C3%B6\" title=\"föö\">foo</a></p>\n",
"example": 33,
"start_line": 743,
"end_line": 749,
"section": "Entity and numeric character references"
},
{
"markdown": "``` föö\nfoo\n```\n",
"html": "<pre><code class=\"language-föö\">foo\n</code></pre>\n",
"example": 34,
"start_line": 752,
"end_line": 759,
"section": "Entity and numeric character references"
},
{
"markdown": "`föö`\n",
"html": "<p><code>föö</code></p>\n",
"example": 35,
"start_line": 765,
"end_line": 769,
"section": "Entity and numeric character references"
},
{
"markdown": " föfö\n",
"html": "<pre><code>föfö\n</code></pre>\n",
"example": 36,
"start_line": 772,
"end_line": 777,
"section": "Entity and numeric character references"
},
{
"markdown": "*foo*\n*foo*\n",
"html": "<p>*foo*\n<em>foo</em></p>\n",
"example": 37,
"start_line": 784,
"end_line": 790,
"section": "Entity and numeric character references"
},
{
"markdown": "* foo\n\n* foo\n",
"html": "<p>* foo</p>\n<ul>\n<li>foo</li>\n</ul>\n",
"example": 38,
"start_line": 792,
"end_line": 801,
"section": "Entity and numeric character references"
},
{
"markdown": "foo
bar\n",
"html": "<p>foo\n\nbar</p>\n",
"example": 39,
"start_line": 803,
"end_line": 809,
"section": "Entity and numeric character references"
},
{
"markdown": " foo\n",
"html": "<p>\tfoo</p>\n",
"example": 40,
"start_line": 811,
"end_line": 815,
"section": "Entity and numeric character references"
},
{
"markdown": "[a](url "tit")\n",
"html": "<p>[a](url "tit")</p>\n",
"example": 41,
"start_line": 818,
"end_line": 822,
"section": "Entity and numeric character references"
},
{
"markdown": "- `one\n- two`\n",
"html": "<ul>\n<li>`one</li>\n<li>two`</li>\n</ul>\n",
"example": 42,
"start_line": 841,
"end_line": 849,
"section": "Precedence"
},
{
"markdown": "***\n---\n___\n",
"html": "<hr />\n<hr />\n<hr />\n",
"example": 43,
"start_line": 880,
"end_line": 888,
"section": "Thematic breaks"
},
{
"markdown": "+++\n",
"html": "<p>+++</p>\n",
"example": 44,
"start_line": 893,
"end_line": 897,
"section": "Thematic breaks"
},
{
"markdown": "===\n",
"html": "<p>===</p>\n",
"example": 45,
"start_line": 900,
"end_line": 904,
"section": "Thematic breaks"
},
{
"markdown": "--\n**\n__\n",
"html": "<p>--\n**\n__</p>\n",
"example": 46,
"start_line": 909,
"end_line": 917,
"section": "Thematic breaks"
},
{
"markdown": " ***\n ***\n ***\n",
"html": "<hr />\n<hr />\n<hr />\n",
"example": 47,
"start_line": 922,
"end_line": 930,
"section": "Thematic breaks"
},
{
"markdown": " ***\n",
"html": "<pre><code>***\n</code></pre>\n",
"example": 48,
"start_line": 935,
"end_line": 940,
"section": "Thematic breaks"
},
{
"markdown": "Foo\n ***\n",
"html": "<p>Foo\n***</p>\n",
"example": 49,
"start_line": 943,
"end_line": 949,
"section": "Thematic breaks"
},
{
"markdown": "_____________________________________\n",
"html": "<hr />\n",
"example": 50,
"start_line": 954,
"end_line": 958,
"section": "Thematic breaks"
},
{
"markdown": " - - -\n",
"html": "<hr />\n",
"example": 51,
"start_line": 963,
"end_line": 967,
"section": "Thematic breaks"
},
{
"markdown": " ** * ** * ** * **\n",
"html": "<hr />\n",
"example": 52,
"start_line": 970,
"end_line": 974,
"section": "Thematic breaks"
},
{
"markdown": "- - - -\n",
"html": "<hr />\n",
"example": 53,
"start_line": 977,
"end_line": 981,
"section": "Thematic breaks"
},
{
"markdown": "- - - - \n",
"html": "<hr />\n",
"example": 54,
"start_line": 986,
"end_line": 990,
"section": "Thematic breaks"
},
{
"markdown": "_ _ _ _ a\n\na------\n\n---a---\n",
"html": "<p>_ _ _ _ a</p>\n<p>a------</p>\n<p>---a---</p>\n",
"example": 55,
"start_line": 995,
"end_line": 1005,
"section": "Thematic breaks"
},
{
"markdown": " *-*\n",
"html": "<p><em>-</em></p>\n",
"example": 56,
"start_line": 1011,
"end_line": 1015,
"section": "Thematic breaks"
},
{
"markdown": "- foo\n***\n- bar\n",
"html": "<ul>\n<li>foo</li>\n</ul>\n<hr />\n<ul>\n<li>bar</li>\n</ul>\n",
"example": 57,
"start_line": 1020,
"end_line": 1032,
"section": "Thematic breaks"
},
{
"markdown": "Foo\n***\nbar\n",
"html": "<p>Foo</p>\n<hr />\n<p>bar</p>\n",
"example": 58,
"start_line": 1037,
"end_line": 1045,
"section": "Thematic breaks"
},
{
"markdown": "Foo\n---\nbar\n",
"html": "<h2>Foo</h2>\n<p>bar</p>\n",
"example": 59,
"start_line": 1054,
"end_line": 1061,
"section": "Thematic breaks"
},
{
"markdown": "* Foo\n* * *\n* Bar\n",
"html": "<ul>\n<li>Foo</li>\n</ul>\n<hr />\n<ul>\n<li>Bar</li>\n</ul>\n",
"example": 60,
"start_line": 1067,
"end_line": 1079,
"section": "Thematic breaks"
},
{
"markdown": "- Foo\n- * * *\n",
"html": "<ul>\n<li>Foo</li>\n<li>\n<hr />\n</li>\n</ul>\n",
"example": 61,
"start_line": 1084,
"end_line": 1094,
"section": "Thematic breaks"
},
{
"markdown": "# foo\n## foo\n### foo\n#### foo\n##### foo\n###### foo\n",
"html": "<h1>foo</h1>\n<h2>foo</h2>\n<h3>foo</h3>\n<h4>foo</h4>\n<h5>foo</h5>\n<h6>foo</h6>\n",
"example": 62,
"start_line": 1113,
"end_line": 1127,
"section": "ATX headings"
},
{
"markdown": "####### foo\n",
"html": "<p>####### foo</p>\n",
"example": 63,
"start_line": 1132,
"end_line": 1136,
"section": "ATX headings"
},
{
"markdown": "#5 bolt\n\n#hashtag\n",
"html": "<p>#5 bolt</p>\n<p>#hashtag</p>\n",
"example": 64,
"start_line": 1147,
"end_line": 1154,
"section": "ATX headings"
},
{
"markdown": "\\## foo\n",
"html": "<p>## foo</p>\n",
"example": 65,
"start_line": 1159,
"end_line": 1163,
"section": "ATX headings"
},
{
"markdown": "# foo *bar* \\*baz\\*\n",
"html": "<h1>foo <em>bar</em> *baz*</h1>\n",
"example": 66,
"start_line": 1168,
"end_line": 1172,
"section": "ATX headings"
},
{
"markdown": "# foo \n",
"html": "<h1>foo</h1>\n",
"example": 67,
"start_line": 1177,
"end_line": 1181,
"section": "ATX headings"
},
{
"markdown": " ### foo\n ## foo\n # foo\n",
"html": "<h3>foo</h3>\n<h2>foo</h2>\n<h1>foo</h1>\n",
"example": 68,
"start_line": 1186,
"end_line": 1194,
"section": "ATX headings"
},
{
"markdown": " # foo\n",
"html": "<pre><code># foo\n</code></pre>\n",
"example": 69,
"start_line": 1199,
"end_line": 1204,
"section": "ATX headings"
},
{
"markdown": "foo\n # bar\n",
"html": "<p>foo\n# bar</p>\n",
"example": 70,
"start_line": 1207,
"end_line": 1213,
"section": "ATX headings"
},
{
"markdown": "## foo ##\n ### bar ###\n",
"html": "<h2>foo</h2>\n<h3>bar</h3>\n",
"example": 71,
"start_line": 1218,
"end_line": 1224,
"section": "ATX headings"
},
{
"markdown": "# foo ##################################\n##### foo ##\n",
"html": "<h1>foo</h1>\n<h5>foo</h5>\n",
"example": 72,
"start_line": 1229,
"end_line": 1235,
"section": "ATX headings"
},
{
"markdown": "### foo ### \n",
"html": "<h3>foo</h3>\n",
"example": 73,
"start_line": 1240,
"end_line": 1244,
"section": "ATX headings"
},
{
"markdown": "### foo ### b\n",
"html": "<h3>foo ### b</h3>\n",
"example": 74,
"start_line": 1251,
"end_line": 1255,
"section": "ATX headings"
},
{
"markdown": "# foo#\n",
"html": "<h1>foo#</h1>\n",
"example": 75,
"start_line": 1260,
"end_line": 1264,
"section": "ATX headings"
},
{
"markdown": "### foo \\###\n## foo #\\##\n# foo \\#\n",
"html": "<h3>foo ###</h3>\n<h2>foo ###</h2>\n<h1>foo #</h1>\n",
"example": 76,
"start_line": 1270,
"end_line": 1278,
"section": "ATX headings"
},
{
"markdown": "****\n## foo\n****\n",
"html": "<hr />\n<h2>foo</h2>\n<hr />\n",
"example": 77,
"start_line": 1284,
"end_line": 1292,
"section": "ATX headings"
},
{
"markdown": "Foo bar\n# baz\nBar foo\n",
"html": "<p>Foo bar</p>\n<h1>baz</h1>\n<p>Bar foo</p>\n",
"example": 78,
"start_line": 1295,
"end_line": 1303,
"section": "ATX headings"
},
{
"markdown": "## \n#\n### ###\n",
"html": "<h2></h2>\n<h1></h1>\n<h3></h3>\n",
"example": 79,
"start_line": 1308,
"end_line": 1316,
"section": "ATX headings"
},
{
"markdown": "Foo *bar*\n=========\n\nFoo *bar*\n---------\n",
"html": "<h1>Foo <em>bar</em></h1>\n<h2>Foo <em>bar</em></h2>\n",
"example": 80,
"start_line": 1351,
"end_line": 1360,
"section": "Setext headings"
},
{
"markdown": "Foo *bar\nbaz*\n====\n",
"html": "<h1>Foo <em>bar\nbaz</em></h1>\n",
"example": 81,
"start_line": 1365,
"end_line": 1372,
"section": "Setext headings"
},
{
"markdown": " Foo *bar\nbaz*\t\n====\n",
"html": "<h1>Foo <em>bar\nbaz</em></h1>\n",
"example": 82,
"start_line": 1379,
"end_line": 1386,
"section": "Setext headings"
},
{
"markdown": "Foo\n-------------------------\n\nFoo\n=\n",
"html": "<h2>Foo</h2>\n<h1>Foo</h1>\n",
"example": 83,
"start_line": 1391,
"end_line": 1400,
"section": "Setext headings"
},
{
"markdown": " Foo\n---\n\n Foo\n-----\n\n Foo\n ===\n",
"html": "<h2>Foo</h2>\n<h2>Foo</h2>\n<h1>Foo</h1>\n",
"example": 84,
"start_line": 1406,
"end_line": 1419,
"section": "Setext headings"
},
{
"markdown": " Foo\n ---\n\n Foo\n---\n",
"html": "<pre><code>Foo\n---\n\nFoo\n</code></pre>\n<hr />\n",
"example": 85,
"start_line": 1424,
"end_line": 1437,
"section": "Setext headings"
},
{
"markdown": "Foo\n ---- \n",
"html": "<h2>Foo</h2>\n",
"example": 86,
"start_line": 1443,
"end_line": 1448,
"section": "Setext headings"
},
{
"markdown": "Foo\n ---\n",
"html": "<p>Foo\n---</p>\n",
"example": 87,
"start_line": 1453,
"end_line": 1459,
"section": "Setext headings"
},
{
"markdown": "Foo\n= =\n\nFoo\n--- -\n",
"html": "<p>Foo\n= =</p>\n<p>Foo</p>\n<hr />\n",
"example": 88,
"start_line": 1464,
"end_line": 1475,
"section": "Setext headings"
},
{
"markdown": "Foo \n-----\n",
"html": "<h2>Foo</h2>\n",
"example": 89,
"start_line": 1480,
"end_line": 1485,
"section": "Setext headings"
},
{
"markdown": "Foo\\\n----\n",
"html": "<h2>Foo\\</h2>\n",
"example": 90,
"start_line": 1490,
"end_line": 1495,
"section": "Setext headings"
},
{
"markdown": "`Foo\n----\n`\n\n<a title=\"a lot\n---\nof dashes\"/>\n",
"html": "<h2>`Foo</h2>\n<p>`</p>\n<h2><a title="a lot</h2>\n<p>of dashes"/></p>\n",
"example": 91,
"start_line": 1501,
"end_line": 1514,
"section": "Setext headings"
},
{
"markdown": "> Foo\n---\n",
"html": "<blockquote>\n<p>Foo</p>\n</blockquote>\n<hr />\n",
"example": 92,
"start_line": 1520,
"end_line": 1528,
"section": "Setext headings"
},
{
"markdown": "> foo\nbar\n===\n",
"html": "<blockquote>\n<p>foo\nbar\n===</p>\n</blockquote>\n",
"example": 93,
"start_line": 1531,
"end_line": 1541,
"section": "Setext headings"
},
{
"markdown": "- Foo\n---\n",
"html": "<ul>\n<li>Foo</li>\n</ul>\n<hr />\n",
"example": 94,
"start_line": 1544,
"end_line": 1552,
"section": "Setext headings"
},
{
"markdown": "Foo\nBar\n---\n",
"html": "<h2>Foo\nBar</h2>\n",
"example": 95,
"start_line": 1559,
"end_line": 1566,
"section": "Setext headings"
},
{
"markdown": "---\nFoo\n---\nBar\n---\nBaz\n",
"html": "<hr />\n<h2>Foo</h2>\n<h2>Bar</h2>\n<p>Baz</p>\n",
"example": 96,
"start_line": 1572,
"end_line": 1584,
"section": "Setext headings"
},
{
"markdown": "\n====\n",
"html": "<p>====</p>\n",
"example": 97,
"start_line": 1589,
"end_line": 1594,
"section": "Setext headings"
},
{
"markdown": "---\n---\n",
"html": "<hr />\n<hr />\n",
"example": 98,
"start_line": 1601,
"end_line": 1607,
"section": "Setext headings"
},
{
"markdown": "- foo\n-----\n",
"html": "<ul>\n<li>foo</li>\n</ul>\n<hr />\n",
"example": 99,
"start_line": 1610,
"end_line": 1618,
"section": "Setext headings"
},
{
"markdown": " foo\n---\n",
"html": "<pre><code>foo\n</code></pre>\n<hr />\n",
"example": 100,
"start_line": 1621,
"end_line": 1628,
"section": "Setext headings"
},
{
"markdown": "> foo\n-----\n",
"html": "<blockquote>\n<p>foo</p>\n</blockquote>\n<hr />\n",
"example": 101,
"start_line": 1631,
"end_line": 1639,
"section": "Setext headings"
},
{
"markdown": "\\> foo\n------\n",
"html": "<h2>> foo</h2>\n",
"example": 102,
"start_line": 1645,
"end_line": 1650,
"section": "Setext headings"
},
{
"markdown": "Foo\n\nbar\n---\nbaz\n",
"html": "<p>Foo</p>\n<h2>bar</h2>\n<p>baz</p>\n",
"example": 103,
"start_line": 1676,
"end_line": 1686,
"section": "Setext headings"
},
{
"markdown": "Foo\nbar\n\n---\n\nbaz\n",
"html": "<p>Foo\nbar</p>\n<hr />\n<p>baz</p>\n",
"example": 104,
"start_line": 1692,
"end_line": 1704,
"section": "Setext headings"
},
{
"markdown": "Foo\nbar\n* * *\nbaz\n",
"html": "<p>Foo\nbar</p>\n<hr />\n<p>baz</p>\n",
"example": 105,
"start_line": 1710,
"end_line": 1720,
"section": "Setext headings"
},
{
"markdown": "Foo\nbar\n\\---\nbaz\n",
"html": "<p>Foo\nbar\n---\nbaz</p>\n",
"example": 106,
"start_line": 1725,
"end_line": 1735,
"section": "Setext headings"
},
{
"markdown": " a simple\n indented code block\n",
"html": "<pre><code>a simple\n indented code block\n</code></pre>\n",
"example": 107,
"start_line": 1753,
"end_line": 1760,
"section": "Indented code blocks"
},
{
"markdown": " - foo\n\n bar\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
"example": 108,
"start_line": 1767,
"end_line": 1778,
"section": "Indented code blocks"
},
{
"markdown": "1. foo\n\n - bar\n",
"html": "<ol>\n<li>\n<p>foo</p>\n<ul>\n<li>bar</li>\n</ul>\n</li>\n</ol>\n",
"example": 109,
"start_line": 1781,
"end_line": 1794,
"section": "Indented code blocks"
},
{
"markdown": " <a/>\n *hi*\n\n - one\n",
"html": "<pre><code><a/>\n*hi*\n\n- one\n</code></pre>\n",
"example": 110,
"start_line": 1801,
"end_line": 1812,
"section": "Indented code blocks"
},
{
"markdown": " chunk1\n\n chunk2\n \n \n \n chunk3\n",
"html": "<pre><code>chunk1\n\nchunk2\n\n\n\nchunk3\n</code></pre>\n",
"example": 111,
"start_line": 1817,
"end_line": 1834,
"section": "Indented code blocks"
},
{
"markdown": " chunk1\n \n chunk2\n",
"html": "<pre><code>chunk1\n \n chunk2\n</code></pre>\n",
"example": 112,
"start_line": 1840,
"end_line": 1849,
"section": "Indented code blocks"
},
{
"markdown": "Foo\n bar\n\n",
"html": "<p>Foo\nbar</p>\n",
"example": 113,
"start_line": 1855,
"end_line": 1862,
"section": "Indented code blocks"
},
{
"markdown": " foo\nbar\n",
"html": "<pre><code>foo\n</code></pre>\n<p>bar</p>\n",
"example": 114,
"start_line": 1869,
"end_line": 1876,
"section": "Indented code blocks"
},
{
"markdown": "# Heading\n foo\nHeading\n------\n foo\n----\n",
"html": "<h1>Heading</h1>\n<pre><code>foo\n</code></pre>\n<h2>Heading</h2>\n<pre><code>foo\n</code></pre>\n<hr />\n",
"example": 115,
"start_line": 1882,
"end_line": 1897,
"section": "Indented code blocks"
},
{
"markdown": " foo\n bar\n",
"html": "<pre><code> foo\nbar\n</code></pre>\n",
"example": 116,
"start_line": 1902,
"end_line": 1909,
"section": "Indented code blocks"
},
{
"markdown": "\n \n foo\n \n\n",
"html": "<pre><code>foo\n</code></pre>\n",
"example": 117,
"start_line": 1915,
"end_line": 1924,
"section": "Indented code blocks"
},
{
"markdown": " foo \n",
"html": "<pre><code>foo \n</code></pre>\n",
"example": 118,
"start_line": 1929,
"end_line": 1934,
"section": "Indented code blocks"
},
{
"markdown": "```\n<\n >\n```\n",
"html": "<pre><code><\n >\n</code></pre>\n",
"example": 119,
"start_line": 1984,
"end_line": 1993,
"section": "Fenced code blocks"
},
{
"markdown": "~~~\n<\n >\n~~~\n",
"html": "<pre><code><\n >\n</code></pre>\n",
"example": 120,
"start_line": 1998,
"end_line": 2007,
"section": "Fenced code blocks"
},
{
"markdown": "``\nfoo\n``\n",
"html": "<p><code>foo</code></p>\n",
"example": 121,
"start_line": 2011,
"end_line": 2017,
"section": "Fenced code blocks"
},
{
"markdown": "```\naaa\n~~~\n```\n",
"html": "<pre><code>aaa\n~~~\n</code></pre>\n",
"example": 122,
"start_line": 2022,
"end_line": 2031,
"section": "Fenced code blocks"
},
{
"markdown": "~~~\naaa\n```\n~~~\n",
"html": "<pre><code>aaa\n```\n</code></pre>\n",
"example": 123,
"start_line": 2034,
"end_line": 2043,
"section": "Fenced code blocks"
},
{
"markdown": "````\naaa\n```\n``````\n",
"html": "<pre><code>aaa\n```\n</code></pre>\n",
"example": 124,
"start_line": 2048,
"end_line": 2057,
"section": "Fenced code blocks"
},
{
"markdown": "~~~~\naaa\n~~~\n~~~~\n",
"html": "<pre><code>aaa\n~~~\n</code></pre>\n",
"example": 125,
"start_line": 2060,
"end_line": 2069,
"section": "Fenced code blocks"
},
{
"markdown": "```\n",
"html": "<pre><code></code></pre>\n",
"example": 126,
"start_line": 2075,
"end_line": 2079,
"section": "Fenced code blocks"
},
{
"markdown": "`````\n\n```\naaa\n",
"html": "<pre><code>\n```\naaa\n</code></pre>\n",
"example": 127,
"start_line": 2082,
"end_line": 2092,
"section": "Fenced code blocks"
},
{
"markdown": "> ```\n> aaa\n\nbbb\n",
"html": "<blockquote>\n<pre><code>aaa\n</code></pre>\n</blockquote>\n<p>bbb</p>\n",
"example": 128,
"start_line": 2095,
"end_line": 2106,
"section": "Fenced code blocks"
},
{
"markdown": "```\n\n \n```\n",
"html": "<pre><code>\n \n</code></pre>\n",
"example": 129,
"start_line": 2111,
"end_line": 2120,
"section": "Fenced code blocks"
},
{
"markdown": "```\n```\n",
"html": "<pre><code></code></pre>\n",
"example": 130,
"start_line": 2125,
"end_line": 2130,
"section": "Fenced code blocks"
},
{
"markdown": " ```\n aaa\naaa\n```\n",
"html": "<pre><code>aaa\naaa\n</code></pre>\n",
"example": 131,
"start_line": 2137,
"end_line": 2146,
"section": "Fenced code blocks"
},
{
"markdown": " ```\naaa\n aaa\naaa\n ```\n",
"html": "<pre><code>aaa\naaa\naaa\n</code></pre>\n",
"example": 132,
"start_line": 2149,
"end_line": 2160,
"section": "Fenced code blocks"
},
{
"markdown": " ```\n aaa\n aaa\n aaa\n ```\n",
"html": "<pre><code>aaa\n aaa\naaa\n</code></pre>\n",
"example": 133,
"start_line": 2163,
"end_line": 2174,
"section": "Fenced code blocks"
},
{
"markdown": " ```\n aaa\n ```\n",
"html": "<pre><code>```\naaa\n```\n</code></pre>\n",
"example": 134,
"start_line": 2179,
"end_line": 2188,
"section": "Fenced code blocks"
},
{
"markdown": "```\naaa\n ```\n",
"html": "<pre><code>aaa\n</code></pre>\n",
"example": 135,
"start_line": 2194,
"end_line": 2201,
"section": "Fenced code blocks"
},
{
"markdown": " ```\naaa\n ```\n",
"html": "<pre><code>aaa\n</code></pre>\n",
"example": 136,
"start_line": 2204,
"end_line": 2211,
"section": "Fenced code blocks"
},
{
"markdown": "```\naaa\n ```\n",
"html": "<pre><code>aaa\n ```\n</code></pre>\n",
"example": 137,
"start_line": 2216,
"end_line": 2224,
"section": "Fenced code blocks"
},
{
"markdown": "``` ```\naaa\n",
"html": "<p><code> </code>\naaa</p>\n",
"example": 138,
"start_line": 2230,
"end_line": 2236,
"section": "Fenced code blocks"
},
{
"markdown": "~~~~~~\naaa\n~~~ ~~\n",
"html": "<pre><code>aaa\n~~~ ~~\n</code></pre>\n",
"example": 139,
"start_line": 2239,
"end_line": 2247,
"section": "Fenced code blocks"
},
{
"markdown": "foo\n```\nbar\n```\nbaz\n",
"html": "<p>foo</p>\n<pre><code>bar\n</code></pre>\n<p>baz</p>\n",
"example": 140,
"start_line": 2253,
"end_line": 2264,
"section": "Fenced code blocks"
},
{
"markdown": "foo\n---\n~~~\nbar\n~~~\n# baz\n",
"html": "<h2>foo</h2>\n<pre><code>bar\n</code></pre>\n<h1>baz</h1>\n",
"example": 141,
"start_line": 2270,
"end_line": 2282,
"section": "Fenced code blocks"
},
{
"markdown": "```ruby\ndef foo(x)\n return 3\nend\n```\n",
"html": "<pre><code class=\"language-ruby\">def foo(x)\n return 3\nend\n</code></pre>\n",
"example": 142,
"start_line": 2292,
"end_line": 2303,
"section": "Fenced code blocks"
},
{
"markdown": "~~~~ ruby startline=3 $%@#$\ndef foo(x)\n return 3\nend\n~~~~~~~\n",
"html": "<pre><code class=\"language-ruby\">def foo(x)\n return 3\nend\n</code></pre>\n",
"example": 143,
"start_line": 2306,
"end_line": 2317,
"section": "Fenced code blocks"
},
{
"markdown": "````;\n````\n",
"html": "<pre><code class=\"language-;\"></code></pre>\n",
"example": 144,
"start_line": 2320,
"end_line": 2325,
"section": "Fenced code blocks"
},
{
"markdown": "``` aa ```\nfoo\n",
"html": "<p><code>aa</code>\nfoo</p>\n",
"example": 145,
"start_line": 2330,
"end_line": 2336,
"section": "Fenced code blocks"
},
{
"markdown": "~~~ aa ``` ~~~\nfoo\n~~~\n",
"html": "<pre><code class=\"language-aa\">foo\n</code></pre>\n",
"example": 146,
"start_line": 2341,
"end_line": 2348,
"section": "Fenced code blocks"
},
{
"markdown": "```\n``` aaa\n```\n",
"html": "<pre><code>``` aaa\n</code></pre>\n",
"example": 147,
"start_line": 2353,
"end_line": 2360,
"section": "Fenced code blocks"
},
{
"markdown": "<table><tr><td>\n<pre>\n**Hello**,\n\n_world_.\n</pre>\n</td></tr></table>\n",
"html": "<table><tr><td>\n<pre>\n**Hello**,\n<p><em>world</em>.\n</pre></p>\n</td></tr></table>\n",
"example": 148,
"start_line": 2432,
"end_line": 2447,
"section": "HTML blocks"
},
{
"markdown": "<table>\n <tr>\n <td>\n hi\n </td>\n </tr>\n</table>\n\nokay.\n",
"html": "<table>\n <tr>\n <td>\n hi\n </td>\n </tr>\n</table>\n<p>okay.</p>\n",
"example": 149,
"start_line": 2461,
"end_line": 2480,
"section": "HTML blocks"
},
{
"markdown": " <div>\n *hello*\n <foo><a>\n",
"html": " <div>\n *hello*\n <foo><a>\n",
"example": 150,
"start_line": 2483,
"end_line": 2491,
"section": "HTML blocks"
},
{
"markdown": "</div>\n*foo*\n",
"html": "</div>\n*foo*\n",
"example": 151,
"start_line": 2496,
"end_line": 2502,
"section": "HTML blocks"
},
{
"markdown": "<DIV CLASS=\"foo\">\n\n*Markdown*\n\n</DIV>\n",
"html": "<DIV CLASS=\"foo\">\n<p><em>Markdown</em></p>\n</DIV>\n",
"example": 152,
"start_line": 2507,
"end_line": 2517,
"section": "HTML blocks"
},
{
"markdown": "<div id=\"foo\"\n class=\"bar\">\n</div>\n",
"html": "<div id=\"foo\"\n class=\"bar\">\n</div>\n",
"example": 153,
"start_line": 2523,
"end_line": 2531,
"section": "HTML blocks"
},
{
"markdown": "<div id=\"foo\" class=\"bar\n baz\">\n</div>\n",
"html": "<div id=\"foo\" class=\"bar\n baz\">\n</div>\n",
"example": 154,
"start_line": 2534,
"end_line": 2542,
"section": "HTML blocks"
},
{
"markdown": "<div>\n*foo*\n\n*bar*\n",
"html": "<div>\n*foo*\n<p><em>bar</em></p>\n",
"example": 155,
"start_line": 2546,
"end_line": 2555,
"section": "HTML blocks"
},
{
"markdown": "<div id=\"foo\"\n*hi*\n",
"html": "<div id=\"foo\"\n*hi*\n",
"example": 156,
"start_line": 2562,
"end_line": 2568,
"section": "HTML blocks"
},
{
"markdown": "<div class\nfoo\n",
"html": "<div class\nfoo\n",
"example": 157,
"start_line": 2571,
"end_line": 2577,
"section": "HTML blocks"
},
{
"markdown": "<div *???-&&&-<---\n*foo*\n",
"html": "<div *???-&&&-<---\n*foo*\n",
"example": 158,
"start_line": 2583,
"end_line": 2589,
"section": "HTML blocks"
},
{
"markdown": "<div><a href=\"bar\">*foo*</a></div>\n",
"html": "<div><a href=\"bar\">*foo*</a></div>\n",
"example": 159,
"start_line": 2595,
"end_line": 2599,
"section": "HTML blocks"
},
{
"markdown": "<table><tr><td>\nfoo\n</td></tr></table>\n",
"html": "<table><tr><td>\nfoo\n</td></tr></table>\n",
"example": 160,
"start_line": 2602,
"end_line": 2610,
"section": "HTML blocks"
},
{
"markdown": "<div></div>\n``` c\nint x = 33;\n```\n",
"html": "<div></div>\n``` c\nint x = 33;\n```\n",
"example": 161,
"start_line": 2619,
"end_line": 2629,
"section": "HTML blocks"
},
{
"markdown": "<a href=\"foo\">\n*bar*\n</a>\n",
"html": "<a href=\"foo\">\n*bar*\n</a>\n",
"example": 162,
"start_line": 2636,
"end_line": 2644,
"section": "HTML blocks"
},
{
"markdown": "<Warning>\n*bar*\n</Warning>\n",
"html": "<Warning>\n*bar*\n</Warning>\n",
"example": 163,
"start_line": 2649,
"end_line": 2657,
"section": "HTML blocks"
},
{
"markdown": "<i class=\"foo\">\n*bar*\n</i>\n",
"html": "<i class=\"foo\">\n*bar*\n</i>\n",
"example": 164,
"start_line": 2660,
"end_line": 2668,
"section": "HTML blocks"
},
{
"markdown": "</ins>\n*bar*\n",
"html": "</ins>\n*bar*\n",
"example": 165,
"start_line": 2671,
"end_line": 2677,
"section": "HTML blocks"
},
{
"markdown": "<del>\n*foo*\n</del>\n",
"html": "<del>\n*foo*\n</del>\n",
"example": 166,
"start_line": 2686,
"end_line": 2694,
"section": "HTML blocks"
},
{
"markdown": "<del>\n\n*foo*\n\n</del>\n",
"html": "<del>\n<p><em>foo</em></p>\n</del>\n",
"example": 167,
"start_line": 2701,
"end_line": 2711,
"section": "HTML blocks"
},
{
"markdown": "<del>*foo*</del>\n",
"html": "<p><del><em>foo</em></del></p>\n",
"example": 168,
"start_line": 2719,
"end_line": 2723,
"section": "HTML blocks"
},
{
"markdown": "<pre language=\"haskell\"><code>\nimport Text.HTML.TagSoup\n\nmain :: IO ()\nmain = print $ parseTags tags\n</code></pre>\nokay\n",
"html": "<pre language=\"haskell\"><code>\nimport Text.HTML.TagSoup\n\nmain :: IO ()\nmain = print $ parseTags tags\n</code></pre>\n<p>okay</p>\n",
"example": 169,
"start_line": 2735,
"end_line": 2751,
"section": "HTML blocks"
},
{
"markdown": "<script type=\"text/javascript\">\n// JavaScript example\n\ndocument.getElementById(\"demo\").innerHTML = \"Hello JavaScript!\";\n</script>\nokay\n",
"html": "<script type=\"text/javascript\">\n// JavaScript example\n\ndocument.getElementById(\"demo\").innerHTML = \"Hello JavaScript!\";\n</script>\n<p>okay</p>\n",
"example": 170,
"start_line": 2756,
"end_line": 2770,
"section": "HTML blocks"
},
{
"markdown": "<textarea>\n\n*foo*\n\n_bar_\n\n</textarea>\n",
"html": "<textarea>\n\n*foo*\n\n_bar_\n\n</textarea>\n",
"example": 171,
"start_line": 2775,
"end_line": 2791,
"section": "HTML blocks"
},
{
"markdown": "<style\n type=\"text/css\">\nh1 {color:red;}\n\np {color:blue;}\n</style>\nokay\n",
"html": "<style\n type=\"text/css\">\nh1 {color:red;}\n\np {color:blue;}\n</style>\n<p>okay</p>\n",
"example": 172,
"start_line": 2795,
"end_line": 2811,
"section": "HTML blocks"
},
{
"markdown": "<style\n type=\"text/css\">\n\nfoo\n",
"html": "<style\n type=\"text/css\">\n\nfoo\n",
"example": 173,
"start_line": 2818,
"end_line": 2828,
"section": "HTML blocks"
},
{
"markdown": "> <div>\n> foo\n\nbar\n",
"html": "<blockquote>\n<div>\nfoo\n</blockquote>\n<p>bar</p>\n",
"example": 174,
"start_line": 2831,
"end_line": 2842,
"section": "HTML blocks"
},
{
"markdown": "- <div>\n- foo\n",
"html": "<ul>\n<li>\n<div>\n</li>\n<li>foo</li>\n</ul>\n",
"example": 175,
"start_line": 2845,
"end_line": 2855,
"section": "HTML blocks"
},
{
"markdown": "<style>p{color:red;}</style>\n*foo*\n",
"html": "<style>p{color:red;}</style>\n<p><em>foo</em></p>\n",
"example": 176,
"start_line": 2860,
"end_line": 2866,
"section": "HTML blocks"
},
{
"markdown": "<!-- foo -->*bar*\n*baz*\n",
"html": "<!-- foo -->*bar*\n<p><em>baz</em></p>\n",
"example": 177,
"start_line": 2869,
"end_line": 2875,
"section": "HTML blocks"
},
{
"markdown": "<script>\nfoo\n</script>1. *bar*\n",
"html": "<script>\nfoo\n</script>1. *bar*\n",
"example": 178,
"start_line": 2881,
"end_line": 2889,
"section": "HTML blocks"
},
{
"markdown": "<!-- Foo\n\nbar\n baz -->\nokay\n",
"html": "<!-- Foo\n\nbar\n baz -->\n<p>okay</p>\n",
"example": 179,
"start_line": 2894,
"end_line": 2906,
"section": "HTML blocks"
},
{
"markdown": "<?php\n\n echo '>';\n\n?>\nokay\n",
"html": "<?php\n\n echo '>';\n\n?>\n<p>okay</p>\n",
"example": 180,
"start_line": 2912,
"end_line": 2926,
"section": "HTML blocks"
},
{
"markdown": "<!DOCTYPE html>\n",
"html": "<!DOCTYPE html>\n",
"example": 181,
"start_line": 2931,
"end_line": 2935,
"section": "HTML blocks"
},
{
"markdown": "<![CDATA[\nfunction matchwo(a,b)\n{\n if (a < b && a < 0) then {\n return 1;\n\n } else {\n\n return 0;\n }\n}\n]]>\nokay\n",
"html": "<![CDATA[\nfunction matchwo(a,b)\n{\n if (a < b && a < 0) then {\n return 1;\n\n } else {\n\n return 0;\n }\n}\n]]>\n<p>okay</p>\n",
"example": 182,
"start_line": 2940,
"end_line": 2968,
"section": "HTML blocks"
},
{
"markdown": " <!-- foo -->\n\n <!-- foo -->\n",
"html": " <!-- foo -->\n<pre><code><!-- foo -->\n</code></pre>\n",
"example": 183,
"start_line": 2974,
"end_line": 2982,
"section": "HTML blocks"
},
{
"markdown": " <div>\n\n <div>\n",
"html": " <div>\n<pre><code><div>\n</code></pre>\n",
"example": 184,
"start_line": 2985,
"end_line": 2993,
"section": "HTML blocks"
},
{
"markdown": "Foo\n<div>\nbar\n</div>\n",
"html": "<p>Foo</p>\n<div>\nbar\n</div>\n",
"example": 185,
"start_line": 2999,
"end_line": 3009,
"section": "HTML blocks"
},
{
"markdown": "<div>\nbar\n</div>\n*foo*\n",
"html": "<div>\nbar\n</div>\n*foo*\n",
"example": 186,
"start_line": 3016,
"end_line": 3026,
"section": "HTML blocks"
},
{
"markdown": "Foo\n<a href=\"bar\">\nbaz\n",
"html": "<p>Foo\n<a href=\"bar\">\nbaz</p>\n",
"example": 187,
"start_line": 3031,
"end_line": 3039,
"section": "HTML blocks"
},
{
"markdown": "<div>\n\n*Emphasized* text.\n\n</div>\n",
"html": "<div>\n<p><em>Emphasized</em> text.</p>\n</div>\n",
"example": 188,
"start_line": 3072,
"end_line": 3082,
"section": "HTML blocks"
},
{
"markdown": "<div>\n*Emphasized* text.\n</div>\n",
"html": "<div>\n*Emphasized* text.\n</div>\n",
"example": 189,
"start_line": 3085,
"end_line": 3093,
"section": "HTML blocks"
},
{
"markdown": "<table>\n\n<tr>\n\n<td>\nHi\n</td>\n\n</tr>\n\n</table>\n",
"html": "<table>\n<tr>\n<td>\nHi\n</td>\n</tr>\n</table>\n",
"example": 190,
"start_line": 3107,
"end_line": 3127,
"section": "HTML blocks"
},
{
"markdown": "<table>\n\n <tr>\n\n <td>\n Hi\n </td>\n\n </tr>\n\n</table>\n",
"html": "<table>\n <tr>\n<pre><code><td>\n Hi\n</td>\n</code></pre>\n </tr>\n</table>\n",
"example": 191,
"start_line": 3134,
"end_line": 3155,
"section": "HTML blocks"
},
{
"markdown": "[foo]: /url \"title\"\n\n[foo]\n",
"html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
"example": 192,
"start_line": 3183,
"end_line": 3189,
"section": "Link reference definitions"
},
{
"markdown": " [foo]: \n /url \n 'the title' \n\n[foo]\n",
"html": "<p><a href=\"/url\" title=\"the title\">foo</a></p>\n",
"example": 193,
"start_line": 3192,
"end_line": 3200,
"section": "Link reference definitions"
},
{
"markdown": "[Foo*bar\\]]:my_(url) 'title (with parens)'\n\n[Foo*bar\\]]\n",
"html": "<p><a href=\"my_(url)\" title=\"title (with parens)\">Foo*bar]</a></p>\n",
"example": 194,
"start_line": 3203,
"end_line": 3209,
"section": "Link reference definitions"
},
{
"markdown": "[Foo bar]:\n<my url>\n'title'\n\n[Foo bar]\n",
"html": "<p><a href=\"my%20url\" title=\"title\">Foo bar</a></p>\n",
"example": 195,
"start_line": 3212,
"end_line": 3220,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url '\ntitle\nline1\nline2\n'\n\n[foo]\n",
"html": "<p><a href=\"/url\" title=\"\ntitle\nline1\nline2\n\">foo</a></p>\n",
"example": 196,
"start_line": 3225,
"end_line": 3239,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url 'title\n\nwith blank line'\n\n[foo]\n",
"html": "<p>[foo]: /url 'title</p>\n<p>with blank line'</p>\n<p>[foo]</p>\n",
"example": 197,
"start_line": 3244,
"end_line": 3254,
"section": "Link reference definitions"
},
{
"markdown": "[foo]:\n/url\n\n[foo]\n",
"html": "<p><a href=\"/url\">foo</a></p>\n",
"example": 198,
"start_line": 3259,
"end_line": 3266,
"section": "Link reference definitions"
},
{
"markdown": "[foo]:\n\n[foo]\n",
"html": "<p>[foo]:</p>\n<p>[foo]</p>\n",
"example": 199,
"start_line": 3271,
"end_line": 3278,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: <>\n\n[foo]\n",
"html": "<p><a href=\"\">foo</a></p>\n",
"example": 200,
"start_line": 3283,
"end_line": 3289,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: <bar>(baz)\n\n[foo]\n",
"html": "<p>[foo]: <bar>(baz)</p>\n<p>[foo]</p>\n",
"example": 201,
"start_line": 3294,
"end_line": 3301,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url\\bar\\*baz \"foo\\\"bar\\baz\"\n\n[foo]\n",
"html": "<p><a href=\"/url%5Cbar*baz\" title=\"foo"bar\\baz\">foo</a></p>\n",
"example": 202,
"start_line": 3307,
"end_line": 3313,
"section": "Link reference definitions"
},
{
"markdown": "[foo]\n\n[foo]: url\n",
"html": "<p><a href=\"url\">foo</a></p>\n",
"example": 203,
"start_line": 3318,
"end_line": 3324,
"section": "Link reference definitions"
},
{
"markdown": "[foo]\n\n[foo]: first\n[foo]: second\n",
"html": "<p><a href=\"first\">foo</a></p>\n",
"example": 204,
"start_line": 3330,
"end_line": 3337,
"section": "Link reference definitions"
},
{
"markdown": "[FOO]: /url\n\n[Foo]\n",
"html": "<p><a href=\"/url\">Foo</a></p>\n",
"example": 205,
"start_line": 3343,
"end_line": 3349,
"section": "Link reference definitions"
},
{
"markdown": "[ΑΓΩ]: /φου\n\n[αγω]\n",
"html": "<p><a href=\"/%CF%86%CE%BF%CF%85\">αγω</a></p>\n",
"example": 206,
"start_line": 3352,
"end_line": 3358,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url\n",
"html": "",
"example": 207,
"start_line": 3367,
"end_line": 3370,
"section": "Link reference definitions"
},
{
"markdown": "[\nfoo\n]: /url\nbar\n",
"html": "<p>bar</p>\n",
"example": 208,
"start_line": 3375,
"end_line": 3382,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url \"title\" ok\n",
"html": "<p>[foo]: /url "title" ok</p>\n",
"example": 209,
"start_line": 3388,
"end_line": 3392,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url\n\"title\" ok\n",
"html": "<p>"title" ok</p>\n",
"example": 210,
"start_line": 3397,
"end_line": 3402,
"section": "Link reference definitions"
},
{
"markdown": " [foo]: /url \"title\"\n\n[foo]\n",
"html": "<pre><code>[foo]: /url "title"\n</code></pre>\n<p>[foo]</p>\n",
"example": 211,
"start_line": 3408,
"end_line": 3416,
"section": "Link reference definitions"
},
{
"markdown": "```\n[foo]: /url\n```\n\n[foo]\n",
"html": "<pre><code>[foo]: /url\n</code></pre>\n<p>[foo]</p>\n",
"example": 212,
"start_line": 3422,
"end_line": 3432,
"section": "Link reference definitions"
},
{
"markdown": "Foo\n[bar]: /baz\n\n[bar]\n",
"html": "<p>Foo\n[bar]: /baz</p>\n<p>[bar]</p>\n",
"example": 213,
"start_line": 3437,
"end_line": 3446,
"section": "Link reference definitions"
},
{
"markdown": "# [Foo]\n[foo]: /url\n> bar\n",
"html": "<h1><a href=\"/url\">Foo</a></h1>\n<blockquote>\n<p>bar</p>\n</blockquote>\n",
"example": 214,
"start_line": 3452,
"end_line": 3461,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url\nbar\n===\n[foo]\n",
"html": "<h1>bar</h1>\n<p><a href=\"/url\">foo</a></p>\n",
"example": 215,
"start_line": 3463,
"end_line": 3471,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /url\n===\n[foo]\n",
"html": "<p>===\n<a href=\"/url\">foo</a></p>\n",
"example": 216,
"start_line": 3473,
"end_line": 3480,
"section": "Link reference definitions"
},
{
"markdown": "[foo]: /foo-url \"foo\"\n[bar]: /bar-url\n \"bar\"\n[baz]: /baz-url\n\n[foo],\n[bar],\n[baz]\n",
"html": "<p><a href=\"/foo-url\" title=\"foo\">foo</a>,\n<a href=\"/bar-url\" title=\"bar\">bar</a>,\n<a href=\"/baz-url\">baz</a></p>\n",
"example": 217,
"start_line": 3486,
"end_line": 3499,
"section": "Link reference definitions"
},
{
"markdown": "[foo]\n\n> [foo]: /url\n",
"html": "<p><a href=\"/url\">foo</a></p>\n<blockquote>\n</blockquote>\n",
"example": 218,
"start_line": 3507,
"end_line": 3515,
"section": "Link reference definitions"
},
{
"markdown": "aaa\n\nbbb\n",
"html": "<p>aaa</p>\n<p>bbb</p>\n",
"example": 219,
"start_line": 3529,
"end_line": 3536,
"section": "Paragraphs"
},
{
"markdown": "aaa\nbbb\n\nccc\nddd\n",
"html": "<p>aaa\nbbb</p>\n<p>ccc\nddd</p>\n",
"example": 220,
"start_line": 3541,
"end_line": 3552,
"section": "Paragraphs"
},
{
"markdown": "aaa\n\n\nbbb\n",
"html": "<p>aaa</p>\n<p>bbb</p>\n",
"example": 221,
"start_line": 3557,
"end_line": 3565,
"section": "Paragraphs"
},
{
"markdown": " aaa\n bbb\n",
"html": "<p>aaa\nbbb</p>\n",
"example": 222,
"start_line": 3570,
"end_line": 3576,
"section": "Paragraphs"
},
{
"markdown": "aaa\n bbb\n ccc\n",
"html": "<p>aaa\nbbb\nccc</p>\n",
"example": 223,
"start_line": 3582,
"end_line": 3590,
"section": "Paragraphs"
},
{
"markdown": " aaa\nbbb\n",
"html": "<p>aaa\nbbb</p>\n",
"example": 224,
"start_line": 3596,
"end_line": 3602,
"section": "Paragraphs"
},
{
"markdown": " aaa\nbbb\n",
"html": "<pre><code>aaa\n</code></pre>\n<p>bbb</p>\n",
"example": 225,
"start_line": 3605,
"end_line": 3612,
"section": "Paragraphs"
},
{
"markdown": "aaa \nbbb \n",
"html": "<p>aaa<br />\nbbb</p>\n",
"example": 226,
"start_line": 3619,
"end_line": 3625,
"section": "Paragraphs"
},
{
"markdown": " \n\naaa\n \n\n# aaa\n\n \n",
"html": "<p>aaa</p>\n<h1>aaa</h1>\n",
"example": 227,
"start_line": 3636,
"end_line": 3648,
"section": "Blank lines"
},
{
"markdown": "> # Foo\n> bar\n> baz\n",
"html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
"example": 228,
"start_line": 3704,
"end_line": 3714,
"section": "Block quotes"
},
{
"markdown": "># Foo\n>bar\n> baz\n",
"html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
"example": 229,
"start_line": 3719,
"end_line": 3729,
"section": "Block quotes"
},
{
"markdown": " > # Foo\n > bar\n > baz\n",
"html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
"example": 230,
"start_line": 3734,
"end_line": 3744,
"section": "Block quotes"
},
{
"markdown": " > # Foo\n > bar\n > baz\n",
"html": "<pre><code>> # Foo\n> bar\n> baz\n</code></pre>\n",
"example": 231,
"start_line": 3749,
"end_line": 3758,
"section": "Block quotes"
},
{
"markdown": "> # Foo\n> bar\nbaz\n",
"html": "<blockquote>\n<h1>Foo</h1>\n<p>bar\nbaz</p>\n</blockquote>\n",
"example": 232,
"start_line": 3764,
"end_line": 3774,
"section": "Block quotes"
},
{
"markdown": "> bar\nbaz\n> foo\n",
"html": "<blockquote>\n<p>bar\nbaz\nfoo</p>\n</blockquote>\n",
"example": 233,
"start_line": 3780,
"end_line": 3790,
"section": "Block quotes"
},
{
"markdown": "> foo\n---\n",
"html": "<blockquote>\n<p>foo</p>\n</blockquote>\n<hr />\n",
"example": 234,
"start_line": 3804,
"end_line": 3812,
"section": "Block quotes"
},
{
"markdown": "> - foo\n- bar\n",
"html": "<blockquote>\n<ul>\n<li>foo</li>\n</ul>\n</blockquote>\n<ul>\n<li>bar</li>\n</ul>\n",
"example": 235,
"start_line": 3824,
"end_line": 3836,
"section": "Block quotes"
},
{
"markdown": "> foo\n bar\n",
"html": "<blockquote>\n<pre><code>foo\n</code></pre>\n</blockquote>\n<pre><code>bar\n</code></pre>\n",
"example": 236,
"start_line": 3842,
"end_line": 3852,
"section": "Block quotes"
},
{
"markdown": "> ```\nfoo\n```\n",
"html": "<blockquote>\n<pre><code></code></pre>\n</blockquote>\n<p>foo</p>\n<pre><code></code></pre>\n",
"example": 237,
"start_line": 3855,
"end_line": 3865,
"section": "Block quotes"
},
{
"markdown": "> foo\n - bar\n",
"html": "<blockquote>\n<p>foo\n- bar</p>\n</blockquote>\n",
"example": 238,
"start_line": 3871,
"end_line": 3879,
"section": "Block quotes"
},
{
"markdown": ">\n",
"html": "<blockquote>\n</blockquote>\n",
"example": 239,
"start_line": 3895,
"end_line": 3900,
"section": "Block quotes"
},
{
"markdown": ">\n> \n> \n",
"html": "<blockquote>\n</blockquote>\n",
"example": 240,
"start_line": 3903,
"end_line": 3910,
"section": "Block quotes"
},
{
"markdown": ">\n> foo\n> \n",
"html": "<blockquote>\n<p>foo</p>\n</blockquote>\n",
"example": 241,
"start_line": 3915,
"end_line": 3923,
"section": "Block quotes"
},
{
"markdown": "> foo\n\n> bar\n",
"html": "<blockquote>\n<p>foo</p>\n</blockquote>\n<blockquote>\n<p>bar</p>\n</blockquote>\n",
"example": 242,
"start_line": 3928,
"end_line": 3939,
"section": "Block quotes"
},
{
"markdown": "> foo\n> bar\n",
"html": "<blockquote>\n<p>foo\nbar</p>\n</blockquote>\n",
"example": 243,
"start_line": 3950,
"end_line": 3958,
"section": "Block quotes"
},
{
"markdown": "> foo\n>\n> bar\n",
"html": "<blockquote>\n<p>foo</p>\n<p>bar</p>\n</blockquote>\n",
"example": 244,
"start_line": 3963,
"end_line": 3972,
"section": "Block quotes"
},
{
"markdown": "foo\n> bar\n",
"html": "<p>foo</p>\n<blockquote>\n<p>bar</p>\n</blockquote>\n",
"example": 245,
"start_line": 3977,
"end_line": 3985,
"section": "Block quotes"
},
{
"markdown": "> aaa\n***\n> bbb\n",
"html": "<blockquote>\n<p>aaa</p>\n</blockquote>\n<hr />\n<blockquote>\n<p>bbb</p>\n</blockquote>\n",
"example": 246,
"start_line": 3991,
"end_line": 4003,
"section": "Block quotes"
},
{
"markdown": "> bar\nbaz\n",
"html": "<blockquote>\n<p>bar\nbaz</p>\n</blockquote>\n",
"example": 247,
"start_line": 4009,
"end_line": 4017,
"section": "Block quotes"
},
{
"markdown": "> bar\n\nbaz\n",
"html": "<blockquote>\n<p>bar</p>\n</blockquote>\n<p>baz</p>\n",
"example": 248,
"start_line": 4020,
"end_line": 4029,
"section": "Block quotes"
},
{
"markdown": "> bar\n>\nbaz\n",
"html": "<blockquote>\n<p>bar</p>\n</blockquote>\n<p>baz</p>\n",
"example": 249,
"start_line": 4032,
"end_line": 4041,
"section": "Block quotes"
},
{
"markdown": "> > > foo\nbar\n",
"html": "<blockquote>\n<blockquote>\n<blockquote>\n<p>foo\nbar</p>\n</blockquote>\n</blockquote>\n</blockquote>\n",
"example": 250,
"start_line": 4048,
"end_line": 4060,
"section": "Block quotes"
},
{
"markdown": ">>> foo\n> bar\n>>baz\n",
"html": "<blockquote>\n<blockquote>\n<blockquote>\n<p>foo\nbar\nbaz</p>\n</blockquote>\n</blockquote>\n</blockquote>\n",
"example": 251,
"start_line": 4063,
"end_line": 4077,
"section": "Block quotes"
},
{
"markdown": "> code\n\n> not code\n",
"html": "<blockquote>\n<pre><code>code\n</code></pre>\n</blockquote>\n<blockquote>\n<p>not code</p>\n</blockquote>\n",
"example": 252,
"start_line": 4085,
"end_line": 4097,
"section": "Block quotes"
},
{
"markdown": "A paragraph\nwith two lines.\n\n indented code\n\n> A block quote.\n",
"html": "<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n",
"example": 253,
"start_line": 4139,
"end_line": 4154,
"section": "List items"
},
{
"markdown": "1. A paragraph\n with two lines.\n\n indented code\n\n > A block quote.\n",
"html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
"example": 254,
"start_line": 4161,
"end_line": 4180,
"section": "List items"
},
{
"markdown": "- one\n\n two\n",
"html": "<ul>\n<li>one</li>\n</ul>\n<p>two</p>\n",
"example": 255,
"start_line": 4194,
"end_line": 4203,
"section": "List items"
},
{
"markdown": "- one\n\n two\n",
"html": "<ul>\n<li>\n<p>one</p>\n<p>two</p>\n</li>\n</ul>\n",
"example": 256,
"start_line": 4206,
"end_line": 4217,
"section": "List items"
},
{
"markdown": " - one\n\n two\n",
"html": "<ul>\n<li>one</li>\n</ul>\n<pre><code> two\n</code></pre>\n",
"example": 257,
"start_line": 4220,
"end_line": 4230,
"section": "List items"
},
{
"markdown": " - one\n\n two\n",
"html": "<ul>\n<li>\n<p>one</p>\n<p>two</p>\n</li>\n</ul>\n",
"example": 258,
"start_line": 4233,
"end_line": 4244,
"section": "List items"
},
{
"markdown": " > > 1. one\n>>\n>> two\n",
"html": "<blockquote>\n<blockquote>\n<ol>\n<li>\n<p>one</p>\n<p>two</p>\n</li>\n</ol>\n</blockquote>\n</blockquote>\n",
"example": 259,
"start_line": 4255,
"end_line": 4270,
"section": "List items"
},
{
"markdown": ">>- one\n>>\n > > two\n",
"html": "<blockquote>\n<blockquote>\n<ul>\n<li>one</li>\n</ul>\n<p>two</p>\n</blockquote>\n</blockquote>\n",
"example": 260,
"start_line": 4282,
"end_line": 4295,
"section": "List items"
},
{
"markdown": "-one\n\n2.two\n",
"html": "<p>-one</p>\n<p>2.two</p>\n",
"example": 261,
"start_line": 4301,
"end_line": 4308,
"section": "List items"
},
{
"markdown": "- foo\n\n\n bar\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
"example": 262,
"start_line": 4314,
"end_line": 4326,
"section": "List items"
},
{
"markdown": "1. foo\n\n ```\n bar\n ```\n\n baz\n\n > bam\n",
"html": "<ol>\n<li>\n<p>foo</p>\n<pre><code>bar\n</code></pre>\n<p>baz</p>\n<blockquote>\n<p>bam</p>\n</blockquote>\n</li>\n</ol>\n",
"example": 263,
"start_line": 4331,
"end_line": 4353,
"section": "List items"
},
{
"markdown": "- Foo\n\n bar\n\n\n baz\n",
"html": "<ul>\n<li>\n<p>Foo</p>\n<pre><code>bar\n\n\nbaz\n</code></pre>\n</li>\n</ul>\n",
"example": 264,
"start_line": 4359,
"end_line": 4377,
"section": "List items"
},
{
"markdown": "123456789. ok\n",
"html": "<ol start=\"123456789\">\n<li>ok</li>\n</ol>\n",
"example": 265,
"start_line": 4381,
"end_line": 4387,
"section": "List items"
},
{
"markdown": "1234567890. not ok\n",
"html": "<p>1234567890. not ok</p>\n",
"example": 266,
"start_line": 4390,
"end_line": 4394,
"section": "List items"
},
{
"markdown": "0. ok\n",
"html": "<ol start=\"0\">\n<li>ok</li>\n</ol>\n",
"example": 267,
"start_line": 4399,
"end_line": 4405,
"section": "List items"
},
{
"markdown": "003. ok\n",
"html": "<ol start=\"3\">\n<li>ok</li>\n</ol>\n",
"example": 268,
"start_line": 4408,
"end_line": 4414,
"section": "List items"
},
{
"markdown": "-1. not ok\n",
"html": "<p>-1. not ok</p>\n",
"example": 269,
"start_line": 4419,
"end_line": 4423,
"section": "List items"
},
{
"markdown": "- foo\n\n bar\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<pre><code>bar\n</code></pre>\n</li>\n</ul>\n",
"example": 270,
"start_line": 4442,
"end_line": 4454,
"section": "List items"
},
{
"markdown": " 10. foo\n\n bar\n",
"html": "<ol start=\"10\">\n<li>\n<p>foo</p>\n<pre><code>bar\n</code></pre>\n</li>\n</ol>\n",
"example": 271,
"start_line": 4459,
"end_line": 4471,
"section": "List items"
},
{
"markdown": " indented code\n\nparagraph\n\n more code\n",
"html": "<pre><code>indented code\n</code></pre>\n<p>paragraph</p>\n<pre><code>more code\n</code></pre>\n",
"example": 272,
"start_line": 4478,
"end_line": 4490,
"section": "List items"
},
{
"markdown": "1. indented code\n\n paragraph\n\n more code\n",
"html": "<ol>\n<li>\n<pre><code>indented code\n</code></pre>\n<p>paragraph</p>\n<pre><code>more code\n</code></pre>\n</li>\n</ol>\n",
"example": 273,
"start_line": 4493,
"end_line": 4509,
"section": "List items"
},
{
"markdown": "1. indented code\n\n paragraph\n\n more code\n",
"html": "<ol>\n<li>\n<pre><code> indented code\n</code></pre>\n<p>paragraph</p>\n<pre><code>more code\n</code></pre>\n</li>\n</ol>\n",
"example": 274,
"start_line": 4515,
"end_line": 4531,
"section": "List items"
},
{
"markdown": " foo\n\nbar\n",
"html": "<p>foo</p>\n<p>bar</p>\n",
"example": 275,
"start_line": 4542,
"end_line": 4549,
"section": "List items"
},
{
"markdown": "- foo\n\n bar\n",
"html": "<ul>\n<li>foo</li>\n</ul>\n<p>bar</p>\n",
"example": 276,
"start_line": 4552,
"end_line": 4561,
"section": "List items"
},
{
"markdown": "- foo\n\n bar\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<p>bar</p>\n</li>\n</ul>\n",
"example": 277,
"start_line": 4569,
"end_line": 4580,
"section": "List items"
},
{
"markdown": "-\n foo\n-\n ```\n bar\n ```\n-\n baz\n",
"html": "<ul>\n<li>foo</li>\n<li>\n<pre><code>bar\n</code></pre>\n</li>\n<li>\n<pre><code>baz\n</code></pre>\n</li>\n</ul>\n",
"example": 278,
"start_line": 4596,
"end_line": 4617,
"section": "List items"
},
{
"markdown": "- \n foo\n",
"html": "<ul>\n<li>foo</li>\n</ul>\n",
"example": 279,
"start_line": 4622,
"end_line": 4629,
"section": "List items"
},
{
"markdown": "-\n\n foo\n",
"html": "<ul>\n<li></li>\n</ul>\n<p>foo</p>\n",
"example": 280,
"start_line": 4636,
"end_line": 4645,
"section": "List items"
},
{
"markdown": "- foo\n-\n- bar\n",
"html": "<ul>\n<li>foo</li>\n<li></li>\n<li>bar</li>\n</ul>\n",
"example": 281,
"start_line": 4650,
"end_line": 4660,
"section": "List items"
},
{
"markdown": "- foo\n- \n- bar\n",
"html": "<ul>\n<li>foo</li>\n<li></li>\n<li>bar</li>\n</ul>\n",
"example": 282,
"start_line": 4665,
"end_line": 4675,
"section": "List items"
},
{
"markdown": "1. foo\n2.\n3. bar\n",
"html": "<ol>\n<li>foo</li>\n<li></li>\n<li>bar</li>\n</ol>\n",
"example": 283,
"start_line": 4680,
"end_line": 4690,
"section": "List items"
},
{
"markdown": "*\n",
"html": "<ul>\n<li></li>\n</ul>\n",
"example": 284,
"start_line": 4695,
"end_line": 4701,
"section": "List items"
},
{
"markdown": "foo\n*\n\nfoo\n1.\n",
"html": "<p>foo\n*</p>\n<p>foo\n1.</p>\n",
"example": 285,
"start_line": 4705,
"end_line": 4716,
"section": "List items"
},
{
"markdown": " 1. A paragraph\n with two lines.\n\n indented code\n\n > A block quote.\n",
"html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
"example": 286,
"start_line": 4727,
"end_line": 4746,
"section": "List items"
},
{
"markdown": " 1. A paragraph\n with two lines.\n\n indented code\n\n > A block quote.\n",
"html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
"example": 287,
"start_line": 4751,
"end_line": 4770,
"section": "List items"
},
{
"markdown": " 1. A paragraph\n with two lines.\n\n indented code\n\n > A block quote.\n",
"html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
"example": 288,
"start_line": 4775,
"end_line": 4794,
"section": "List items"
},
{
"markdown": " 1. A paragraph\n with two lines.\n\n indented code\n\n > A block quote.\n",
"html": "<pre><code>1. A paragraph\n with two lines.\n\n indented code\n\n > A block quote.\n</code></pre>\n",
"example": 289,
"start_line": 4799,
"end_line": 4814,
"section": "List items"
},
{
"markdown": " 1. A paragraph\nwith two lines.\n\n indented code\n\n > A block quote.\n",
"html": "<ol>\n<li>\n<p>A paragraph\nwith two lines.</p>\n<pre><code>indented code\n</code></pre>\n<blockquote>\n<p>A block quote.</p>\n</blockquote>\n</li>\n</ol>\n",
"example": 290,
"start_line": 4829,
"end_line": 4848,
"section": "List items"
},
{
"markdown": " 1. A paragraph\n with two lines.\n",
"html": "<ol>\n<li>A paragraph\nwith two lines.</li>\n</ol>\n",
"example": 291,
"start_line": 4853,
"end_line": 4861,
"section": "List items"
},
{
"markdown": "> 1. > Blockquote\ncontinued here.\n",
"html": "<blockquote>\n<ol>\n<li>\n<blockquote>\n<p>Blockquote\ncontinued here.</p>\n</blockquote>\n</li>\n</ol>\n</blockquote>\n",
"example": 292,
"start_line": 4866,
"end_line": 4880,
"section": "List items"
},
{
"markdown": "> 1. > Blockquote\n> continued here.\n",
"html": "<blockquote>\n<ol>\n<li>\n<blockquote>\n<p>Blockquote\ncontinued here.</p>\n</blockquote>\n</li>\n</ol>\n</blockquote>\n",
"example": 293,
"start_line": 4883,
"end_line": 4897,
"section": "List items"
},
{
"markdown": "- foo\n - bar\n - baz\n - boo\n",
"html": "<ul>\n<li>foo\n<ul>\n<li>bar\n<ul>\n<li>baz\n<ul>\n<li>boo</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n",
"example": 294,
"start_line": 4911,
"end_line": 4932,
"section": "List items"
},
{
"markdown": "- foo\n - bar\n - baz\n - boo\n",
"html": "<ul>\n<li>foo</li>\n<li>bar</li>\n<li>baz</li>\n<li>boo</li>\n</ul>\n",
"example": 295,
"start_line": 4937,
"end_line": 4949,
"section": "List items"
},
{
"markdown": "10) foo\n - bar\n",
"html": "<ol start=\"10\">\n<li>foo\n<ul>\n<li>bar</li>\n</ul>\n</li>\n</ol>\n",
"example": 296,
"start_line": 4954,
"end_line": 4965,
"section": "List items"
},
{
"markdown": "10) foo\n - bar\n",
"html": "<ol start=\"10\">\n<li>foo</li>\n</ol>\n<ul>\n<li>bar</li>\n</ul>\n",
"example": 297,
"start_line": 4970,
"end_line": 4980,
"section": "List items"
},
{
"markdown": "- - foo\n",
"html": "<ul>\n<li>\n<ul>\n<li>foo</li>\n</ul>\n</li>\n</ul>\n",
"example": 298,
"start_line": 4985,
"end_line": 4995,
"section": "List items"
},
{
"markdown": "1. - 2. foo\n",
"html": "<ol>\n<li>\n<ul>\n<li>\n<ol start=\"2\">\n<li>foo</li>\n</ol>\n</li>\n</ul>\n</li>\n</ol>\n",
"example": 299,
"start_line": 4998,
"end_line": 5012,
"section": "List items"
},
{
"markdown": "- # Foo\n- Bar\n ---\n baz\n",
"html": "<ul>\n<li>\n<h1>Foo</h1>\n</li>\n<li>\n<h2>Bar</h2>\nbaz</li>\n</ul>\n",
"example": 300,
"start_line": 5017,
"end_line": 5031,
"section": "List items"
},
{
"markdown": "- foo\n- bar\n+ baz\n",
"html": "<ul>\n<li>foo</li>\n<li>bar</li>\n</ul>\n<ul>\n<li>baz</li>\n</ul>\n",
"example": 301,
"start_line": 5253,
"end_line": 5265,
"section": "Lists"
},
{
"markdown": "1. foo\n2. bar\n3) baz\n",
"html": "<ol>\n<li>foo</li>\n<li>bar</li>\n</ol>\n<ol start=\"3\">\n<li>baz</li>\n</ol>\n",
"example": 302,
"start_line": 5268,
"end_line": 5280,
"section": "Lists"
},
{
"markdown": "Foo\n- bar\n- baz\n",
"html": "<p>Foo</p>\n<ul>\n<li>bar</li>\n<li>baz</li>\n</ul>\n",
"example": 303,
"start_line": 5287,
"end_line": 5297,
"section": "Lists"
},
{
"markdown": "The number of windows in my house is\n14. The number of doors is 6.\n",
"html": "<p>The number of windows in my house is\n14. The number of doors is 6.</p>\n",
"example": 304,
"start_line": 5364,
"end_line": 5370,
"section": "Lists"
},
{
"markdown": "The number of windows in my house is\n1. The number of doors is 6.\n",
"html": "<p>The number of windows in my house is</p>\n<ol>\n<li>The number of doors is 6.</li>\n</ol>\n",
"example": 305,
"start_line": 5374,
"end_line": 5382,
"section": "Lists"
},
{
"markdown": "- foo\n\n- bar\n\n\n- baz\n",
"html": "<ul>\n<li>\n<p>foo</p>\n</li>\n<li>\n<p>bar</p>\n</li>\n<li>\n<p>baz</p>\n</li>\n</ul>\n",
"example": 306,
"start_line": 5388,
"end_line": 5407,
"section": "Lists"
},
{
"markdown": "- foo\n - bar\n - baz\n\n\n bim\n",
"html": "<ul>\n<li>foo\n<ul>\n<li>bar\n<ul>\n<li>\n<p>baz</p>\n<p>bim</p>\n</li>\n</ul>\n</li>\n</ul>\n</li>\n</ul>\n",
"example": 307,
"start_line": 5409,
"end_line": 5431,
"section": "Lists"
},
{
"markdown": "- foo\n- bar\n\n<!-- -->\n\n- baz\n- bim\n",
"html": "<ul>\n<li>foo</li>\n<li>bar</li>\n</ul>\n<!-- -->\n<ul>\n<li>baz</li>\n<li>bim</li>\n</ul>\n",
"example": 308,
"start_line": 5439,
"end_line": 5457,
"section": "Lists"
},
{
"markdown": "- foo\n\n notcode\n\n- foo\n\n<!-- -->\n\n code\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<p>notcode</p>\n</li>\n<li>\n<p>foo</p>\n</li>\n</ul>\n<!-- -->\n<pre><code>code\n</code></pre>\n",
"example": 309,
"start_line": 5460,
"end_line": 5483,
"section": "Lists"
},
{
"markdown": "- a\n - b\n - c\n - d\n - e\n - f\n- g\n",
"html": "<ul>\n<li>a</li>\n<li>b</li>\n<li>c</li>\n<li>d</li>\n<li>e</li>\n<li>f</li>\n<li>g</li>\n</ul>\n",
"example": 310,
"start_line": 5491,
"end_line": 5509,
"section": "Lists"
},
{
"markdown": "1. a\n\n 2. b\n\n 3. c\n",
"html": "<ol>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n<li>\n<p>c</p>\n</li>\n</ol>\n",
"example": 311,
"start_line": 5512,
"end_line": 5530,
"section": "Lists"
},
{
"markdown": "- a\n - b\n - c\n - d\n - e\n",
"html": "<ul>\n<li>a</li>\n<li>b</li>\n<li>c</li>\n<li>d\n- e</li>\n</ul>\n",
"example": 312,
"start_line": 5536,
"end_line": 5550,
"section": "Lists"
},
{
"markdown": "1. a\n\n 2. b\n\n 3. c\n",
"html": "<ol>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n</ol>\n<pre><code>3. c\n</code></pre>\n",
"example": 313,
"start_line": 5556,
"end_line": 5573,
"section": "Lists"
},
{
"markdown": "- a\n- b\n\n- c\n",
"html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n<li>\n<p>c</p>\n</li>\n</ul>\n",
"example": 314,
"start_line": 5579,
"end_line": 5596,
"section": "Lists"
},
{
"markdown": "* a\n*\n\n* c\n",
"html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li></li>\n<li>\n<p>c</p>\n</li>\n</ul>\n",
"example": 315,
"start_line": 5601,
"end_line": 5616,
"section": "Lists"
},
{
"markdown": "- a\n- b\n\n c\n- d\n",
"html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n<p>c</p>\n</li>\n<li>\n<p>d</p>\n</li>\n</ul>\n",
"example": 316,
"start_line": 5623,
"end_line": 5642,
"section": "Lists"
},
{
"markdown": "- a\n- b\n\n [ref]: /url\n- d\n",
"html": "<ul>\n<li>\n<p>a</p>\n</li>\n<li>\n<p>b</p>\n</li>\n<li>\n<p>d</p>\n</li>\n</ul>\n",
"example": 317,
"start_line": 5645,
"end_line": 5663,
"section": "Lists"
},
{
"markdown": "- a\n- ```\n b\n\n\n ```\n- c\n",
"html": "<ul>\n<li>a</li>\n<li>\n<pre><code>b\n\n\n</code></pre>\n</li>\n<li>c</li>\n</ul>\n",
"example": 318,
"start_line": 5668,
"end_line": 5687,
"section": "Lists"
},
{
"markdown": "- a\n - b\n\n c\n- d\n",
"html": "<ul>\n<li>a\n<ul>\n<li>\n<p>b</p>\n<p>c</p>\n</li>\n</ul>\n</li>\n<li>d</li>\n</ul>\n",
"example": 319,
"start_line": 5694,
"end_line": 5712,
"section": "Lists"
},
{
"markdown": "* a\n > b\n >\n* c\n",
"html": "<ul>\n<li>a\n<blockquote>\n<p>b</p>\n</blockquote>\n</li>\n<li>c</li>\n</ul>\n",
"example": 320,
"start_line": 5718,
"end_line": 5732,
"section": "Lists"
},
{
"markdown": "- a\n > b\n ```\n c\n ```\n- d\n",
"html": "<ul>\n<li>a\n<blockquote>\n<p>b</p>\n</blockquote>\n<pre><code>c\n</code></pre>\n</li>\n<li>d</li>\n</ul>\n",
"example": 321,
"start_line": 5738,
"end_line": 5756,
"section": "Lists"
},
{
"markdown": "- a\n",
"html": "<ul>\n<li>a</li>\n</ul>\n",
"example": 322,
"start_line": 5761,
"end_line": 5767,
"section": "Lists"
},
{
"markdown": "- a\n - b\n",
"html": "<ul>\n<li>a\n<ul>\n<li>b</li>\n</ul>\n</li>\n</ul>\n",
"example": 323,
"start_line": 5770,
"end_line": 5781,
"section": "Lists"
},
{
"markdown": "1. ```\n foo\n ```\n\n bar\n",
"html": "<ol>\n<li>\n<pre><code>foo\n</code></pre>\n<p>bar</p>\n</li>\n</ol>\n",
"example": 324,
"start_line": 5787,
"end_line": 5801,
"section": "Lists"
},
{
"markdown": "* foo\n * bar\n\n baz\n",
"html": "<ul>\n<li>\n<p>foo</p>\n<ul>\n<li>bar</li>\n</ul>\n<p>baz</p>\n</li>\n</ul>\n",
"example": 325,
"start_line": 5806,
"end_line": 5821,
"section": "Lists"
},
{
"markdown": "- a\n - b\n - c\n\n- d\n - e\n - f\n",
"html": "<ul>\n<li>\n<p>a</p>\n<ul>\n<li>b</li>\n<li>c</li>\n</ul>\n</li>\n<li>\n<p>d</p>\n<ul>\n<li>e</li>\n<li>f</li>\n</ul>\n</li>\n</ul>\n",
"example": 326,
"start_line": 5824,
"end_line": 5849,
"section": "Lists"
},
{
"markdown": "`hi`lo`\n",
"html": "<p><code>hi</code>lo`</p>\n",
"example": 327,
"start_line": 5858,
"end_line": 5862,
"section": "Inlines"
},
{
"markdown": "`foo`\n",
"html": "<p><code>foo</code></p>\n",
"example": 328,
"start_line": 5890,
"end_line": 5894,
"section": "Code spans"
},
{
"markdown": "`` foo ` bar ``\n",
"html": "<p><code>foo ` bar</code></p>\n",
"example": 329,
"start_line": 5901,
"end_line": 5905,
"section": "Code spans"
},
{
"markdown": "` `` `\n",
"html": "<p><code>``</code></p>\n",
"example": 330,
"start_line": 5911,
"end_line": 5915,
"section": "Code spans"
},
{
"markdown": "` `` `\n",
"html": "<p><code> `` </code></p>\n",
"example": 331,
"start_line": 5919,
"end_line": 5923,
"section": "Code spans"
},
{
"markdown": "` a`\n",
"html": "<p><code> a</code></p>\n",
"example": 332,
"start_line": 5928,
"end_line": 5932,
"section": "Code spans"
},
{
"markdown": "` b `\n",
"html": "<p><code> b </code></p>\n",
"example": 333,
"start_line": 5937,
"end_line": 5941,
"section": "Code spans"
},
{
"markdown": "` `\n` `\n",
"html": "<p><code> </code>\n<code> </code></p>\n",
"example": 334,
"start_line": 5945,
"end_line": 5951,
"section": "Code spans"
},
{
"markdown": "``\nfoo\nbar \nbaz\n``\n",
"html": "<p><code>foo bar baz</code></p>\n",
"example": 335,
"start_line": 5956,
"end_line": 5964,
"section": "Code spans"
},
{
"markdown": "``\nfoo \n``\n",
"html": "<p><code>foo </code></p>\n",
"example": 336,
"start_line": 5966,
"end_line": 5972,
"section": "Code spans"
},
{
"markdown": "`foo bar \nbaz`\n",
"html": "<p><code>foo bar baz</code></p>\n",
"example": 337,
"start_line": 5977,
"end_line": 5982,
"section": "Code spans"
},
{
"markdown": "`foo\\`bar`\n",
"html": "<p><code>foo\\</code>bar`</p>\n",
"example": 338,
"start_line": 5994,
"end_line": 5998,
"section": "Code spans"
},
{
"markdown": "``foo`bar``\n",
"html": "<p><code>foo`bar</code></p>\n",
"example": 339,
"start_line": 6005,
"end_line": 6009,
"section": "Code spans"
},
{
"markdown": "` foo `` bar `\n",
"html": "<p><code>foo `` bar</code></p>\n",
"example": 340,
"start_line": 6011,
"end_line": 6015,
"section": "Code spans"
},
{
"markdown": "*foo`*`\n",
"html": "<p>*foo<code>*</code></p>\n",
"example": 341,
"start_line": 6023,
"end_line": 6027,
"section": "Code spans"
},
{
"markdown": "[not a `link](/foo`)\n",
"html": "<p>[not a <code>link](/foo</code>)</p>\n",
"example": 342,
"start_line": 6032,
"end_line": 6036,
"section": "Code spans"
},
{
"markdown": "`<a href=\"`\">`\n",
"html": "<p><code><a href="</code>">`</p>\n",
"example": 343,
"start_line": 6042,
"end_line": 6046,
"section": "Code spans"
},
{
"markdown": "<a href=\"`\">`\n",
"html": "<p><a href=\"`\">`</p>\n",
"example": 344,
"start_line": 6051,
"end_line": 6055,
"section": "Code spans"
},
{
"markdown": "`<http://foo.bar.`baz>`\n",
"html": "<p><code><http://foo.bar.</code>baz>`</p>\n",
"example": 345,
"start_line": 6060,
"end_line": 6064,
"section": "Code spans"
},
{
"markdown": "<http://foo.bar.`baz>`\n",
"html": "<p><a href=\"http://foo.bar.%60baz\">http://foo.bar.`baz</a>`</p>\n",
"example": 346,
"start_line": 6069,
"end_line": 6073,
"section": "Code spans"
},
{
"markdown": "```foo``\n",
"html": "<p>```foo``</p>\n",
"example": 347,
"start_line": 6079,
"end_line": 6083,
"section": "Code spans"
},
{
"markdown": "`foo\n",
"html": "<p>`foo</p>\n",
"example": 348,
"start_line": 6086,
"end_line": 6090,
"section": "Code spans"
},
{
"markdown": "`foo``bar``\n",
"html": "<p>`foo<code>bar</code></p>\n",
"example": 349,
"start_line": 6095,
"end_line": 6099,
"section": "Code spans"
},
{
"markdown": "*foo bar*\n",
"html": "<p><em>foo bar</em></p>\n",
"example": 350,
"start_line": 6312,
"end_line": 6316,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "a * foo bar*\n",
"html": "<p>a * foo bar*</p>\n",
"example": 351,
"start_line": 6322,
"end_line": 6326,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "a*\"foo\"*\n",
"html": "<p>a*"foo"*</p>\n",
"example": 352,
"start_line": 6333,
"end_line": 6337,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "* a *\n",
"html": "<p>* a *</p>\n",
"example": 353,
"start_line": 6342,
"end_line": 6346,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo*bar*\n",
"html": "<p>foo<em>bar</em></p>\n",
"example": 354,
"start_line": 6351,
"end_line": 6355,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "5*6*78\n",
"html": "<p>5<em>6</em>78</p>\n",
"example": 355,
"start_line": 6358,
"end_line": 6362,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo bar_\n",
"html": "<p><em>foo bar</em></p>\n",
"example": 356,
"start_line": 6367,
"end_line": 6371,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_ foo bar_\n",
"html": "<p>_ foo bar_</p>\n",
"example": 357,
"start_line": 6377,
"end_line": 6381,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "a_\"foo\"_\n",
"html": "<p>a_"foo"_</p>\n",
"example": 358,
"start_line": 6387,
"end_line": 6391,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo_bar_\n",
"html": "<p>foo_bar_</p>\n",
"example": 359,
"start_line": 6396,
"end_line": 6400,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "5_6_78\n",
"html": "<p>5_6_78</p>\n",
"example": 360,
"start_line": 6403,
"end_line": 6407,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "пристаням_стремятся_\n",
"html": "<p>пристаням_стремятся_</p>\n",
"example": 361,
"start_line": 6410,
"end_line": 6414,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "aa_\"bb\"_cc\n",
"html": "<p>aa_"bb"_cc</p>\n",
"example": 362,
"start_line": 6420,
"end_line": 6424,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo-_(bar)_\n",
"html": "<p>foo-<em>(bar)</em></p>\n",
"example": 363,
"start_line": 6431,
"end_line": 6435,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo*\n",
"html": "<p>_foo*</p>\n",
"example": 364,
"start_line": 6443,
"end_line": 6447,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo bar *\n",
"html": "<p>*foo bar *</p>\n",
"example": 365,
"start_line": 6453,
"end_line": 6457,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo bar\n*\n",
"html": "<p>*foo bar\n*</p>\n",
"example": 366,
"start_line": 6462,
"end_line": 6468,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*(*foo)\n",
"html": "<p>*(*foo)</p>\n",
"example": 367,
"start_line": 6475,
"end_line": 6479,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*(*foo*)*\n",
"html": "<p><em>(<em>foo</em>)</em></p>\n",
"example": 368,
"start_line": 6485,
"end_line": 6489,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo*bar\n",
"html": "<p><em>foo</em>bar</p>\n",
"example": 369,
"start_line": 6494,
"end_line": 6498,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo bar _\n",
"html": "<p>_foo bar _</p>\n",
"example": 370,
"start_line": 6507,
"end_line": 6511,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_(_foo)\n",
"html": "<p>_(_foo)</p>\n",
"example": 371,
"start_line": 6517,
"end_line": 6521,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_(_foo_)_\n",
"html": "<p><em>(<em>foo</em>)</em></p>\n",
"example": 372,
"start_line": 6526,
"end_line": 6530,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo_bar\n",
"html": "<p>_foo_bar</p>\n",
"example": 373,
"start_line": 6535,
"end_line": 6539,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_пристаням_стремятся\n",
"html": "<p>_пристаням_стремятся</p>\n",
"example": 374,
"start_line": 6542,
"end_line": 6546,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo_bar_baz_\n",
"html": "<p><em>foo_bar_baz</em></p>\n",
"example": 375,
"start_line": 6549,
"end_line": 6553,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_(bar)_.\n",
"html": "<p><em>(bar)</em>.</p>\n",
"example": 376,
"start_line": 6560,
"end_line": 6564,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo bar**\n",
"html": "<p><strong>foo bar</strong></p>\n",
"example": 377,
"start_line": 6569,
"end_line": 6573,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "** foo bar**\n",
"html": "<p>** foo bar**</p>\n",
"example": 378,
"start_line": 6579,
"end_line": 6583,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "a**\"foo\"**\n",
"html": "<p>a**"foo"**</p>\n",
"example": 379,
"start_line": 6590,
"end_line": 6594,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo**bar**\n",
"html": "<p>foo<strong>bar</strong></p>\n",
"example": 380,
"start_line": 6599,
"end_line": 6603,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo bar__\n",
"html": "<p><strong>foo bar</strong></p>\n",
"example": 381,
"start_line": 6608,
"end_line": 6612,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__ foo bar__\n",
"html": "<p>__ foo bar__</p>\n",
"example": 382,
"start_line": 6618,
"end_line": 6622,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__\nfoo bar__\n",
"html": "<p>__\nfoo bar__</p>\n",
"example": 383,
"start_line": 6626,
"end_line": 6632,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "a__\"foo\"__\n",
"html": "<p>a__"foo"__</p>\n",
"example": 384,
"start_line": 6638,
"end_line": 6642,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo__bar__\n",
"html": "<p>foo__bar__</p>\n",
"example": 385,
"start_line": 6647,
"end_line": 6651,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "5__6__78\n",
"html": "<p>5__6__78</p>\n",
"example": 386,
"start_line": 6654,
"end_line": 6658,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "пристаням__стремятся__\n",
"html": "<p>пристаням__стремятся__</p>\n",
"example": 387,
"start_line": 6661,
"end_line": 6665,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo, __bar__, baz__\n",
"html": "<p><strong>foo, <strong>bar</strong>, baz</strong></p>\n",
"example": 388,
"start_line": 6668,
"end_line": 6672,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo-__(bar)__\n",
"html": "<p>foo-<strong>(bar)</strong></p>\n",
"example": 389,
"start_line": 6679,
"end_line": 6683,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo bar **\n",
"html": "<p>**foo bar **</p>\n",
"example": 390,
"start_line": 6692,
"end_line": 6696,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**(**foo)\n",
"html": "<p>**(**foo)</p>\n",
"example": 391,
"start_line": 6705,
"end_line": 6709,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*(**foo**)*\n",
"html": "<p><em>(<strong>foo</strong>)</em></p>\n",
"example": 392,
"start_line": 6715,
"end_line": 6719,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**Gomphocarpus (*Gomphocarpus physocarpus*, syn.\n*Asclepias physocarpa*)**\n",
"html": "<p><strong>Gomphocarpus (<em>Gomphocarpus physocarpus</em>, syn.\n<em>Asclepias physocarpa</em>)</strong></p>\n",
"example": 393,
"start_line": 6722,
"end_line": 6728,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo \"*bar*\" foo**\n",
"html": "<p><strong>foo "<em>bar</em>" foo</strong></p>\n",
"example": 394,
"start_line": 6731,
"end_line": 6735,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo**bar\n",
"html": "<p><strong>foo</strong>bar</p>\n",
"example": 395,
"start_line": 6740,
"end_line": 6744,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo bar __\n",
"html": "<p>__foo bar __</p>\n",
"example": 396,
"start_line": 6752,
"end_line": 6756,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__(__foo)\n",
"html": "<p>__(__foo)</p>\n",
"example": 397,
"start_line": 6762,
"end_line": 6766,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_(__foo__)_\n",
"html": "<p><em>(<strong>foo</strong>)</em></p>\n",
"example": 398,
"start_line": 6772,
"end_line": 6776,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo__bar\n",
"html": "<p>__foo__bar</p>\n",
"example": 399,
"start_line": 6781,
"end_line": 6785,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__пристаням__стремятся\n",
"html": "<p>__пристаням__стремятся</p>\n",
"example": 400,
"start_line": 6788,
"end_line": 6792,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo__bar__baz__\n",
"html": "<p><strong>foo__bar__baz</strong></p>\n",
"example": 401,
"start_line": 6795,
"end_line": 6799,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__(bar)__.\n",
"html": "<p><strong>(bar)</strong>.</p>\n",
"example": 402,
"start_line": 6806,
"end_line": 6810,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo [bar](/url)*\n",
"html": "<p><em>foo <a href=\"/url\">bar</a></em></p>\n",
"example": 403,
"start_line": 6818,
"end_line": 6822,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo\nbar*\n",
"html": "<p><em>foo\nbar</em></p>\n",
"example": 404,
"start_line": 6825,
"end_line": 6831,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo __bar__ baz_\n",
"html": "<p><em>foo <strong>bar</strong> baz</em></p>\n",
"example": 405,
"start_line": 6837,
"end_line": 6841,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo _bar_ baz_\n",
"html": "<p><em>foo <em>bar</em> baz</em></p>\n",
"example": 406,
"start_line": 6844,
"end_line": 6848,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo_ bar_\n",
"html": "<p><em><em>foo</em> bar</em></p>\n",
"example": 407,
"start_line": 6851,
"end_line": 6855,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo *bar**\n",
"html": "<p><em>foo <em>bar</em></em></p>\n",
"example": 408,
"start_line": 6858,
"end_line": 6862,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo **bar** baz*\n",
"html": "<p><em>foo <strong>bar</strong> baz</em></p>\n",
"example": 409,
"start_line": 6865,
"end_line": 6869,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo**bar**baz*\n",
"html": "<p><em>foo<strong>bar</strong>baz</em></p>\n",
"example": 410,
"start_line": 6871,
"end_line": 6875,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo**bar*\n",
"html": "<p><em>foo**bar</em></p>\n",
"example": 411,
"start_line": 6895,
"end_line": 6899,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "***foo** bar*\n",
"html": "<p><em><strong>foo</strong> bar</em></p>\n",
"example": 412,
"start_line": 6908,
"end_line": 6912,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo **bar***\n",
"html": "<p><em>foo <strong>bar</strong></em></p>\n",
"example": 413,
"start_line": 6915,
"end_line": 6919,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo**bar***\n",
"html": "<p><em>foo<strong>bar</strong></em></p>\n",
"example": 414,
"start_line": 6922,
"end_line": 6926,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo***bar***baz\n",
"html": "<p>foo<em><strong>bar</strong></em>baz</p>\n",
"example": 415,
"start_line": 6933,
"end_line": 6937,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo******bar*********baz\n",
"html": "<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>\n",
"example": 416,
"start_line": 6939,
"end_line": 6943,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo **bar *baz* bim** bop*\n",
"html": "<p><em>foo <strong>bar <em>baz</em> bim</strong> bop</em></p>\n",
"example": 417,
"start_line": 6948,
"end_line": 6952,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo [*bar*](/url)*\n",
"html": "<p><em>foo <a href=\"/url\"><em>bar</em></a></em></p>\n",
"example": 418,
"start_line": 6955,
"end_line": 6959,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "** is not an empty emphasis\n",
"html": "<p>** is not an empty emphasis</p>\n",
"example": 419,
"start_line": 6964,
"end_line": 6968,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**** is not an empty strong emphasis\n",
"html": "<p>**** is not an empty strong emphasis</p>\n",
"example": 420,
"start_line": 6971,
"end_line": 6975,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo [bar](/url)**\n",
"html": "<p><strong>foo <a href=\"/url\">bar</a></strong></p>\n",
"example": 421,
"start_line": 6984,
"end_line": 6988,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo\nbar**\n",
"html": "<p><strong>foo\nbar</strong></p>\n",
"example": 422,
"start_line": 6991,
"end_line": 6997,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo _bar_ baz__\n",
"html": "<p><strong>foo <em>bar</em> baz</strong></p>\n",
"example": 423,
"start_line": 7003,
"end_line": 7007,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo __bar__ baz__\n",
"html": "<p><strong>foo <strong>bar</strong> baz</strong></p>\n",
"example": 424,
"start_line": 7010,
"end_line": 7014,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "____foo__ bar__\n",
"html": "<p><strong><strong>foo</strong> bar</strong></p>\n",
"example": 425,
"start_line": 7017,
"end_line": 7021,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo **bar****\n",
"html": "<p><strong>foo <strong>bar</strong></strong></p>\n",
"example": 426,
"start_line": 7024,
"end_line": 7028,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo *bar* baz**\n",
"html": "<p><strong>foo <em>bar</em> baz</strong></p>\n",
"example": 427,
"start_line": 7031,
"end_line": 7035,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo*bar*baz**\n",
"html": "<p><strong>foo<em>bar</em>baz</strong></p>\n",
"example": 428,
"start_line": 7038,
"end_line": 7042,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "***foo* bar**\n",
"html": "<p><strong><em>foo</em> bar</strong></p>\n",
"example": 429,
"start_line": 7045,
"end_line": 7049,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo *bar***\n",
"html": "<p><strong>foo <em>bar</em></strong></p>\n",
"example": 430,
"start_line": 7052,
"end_line": 7056,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo *bar **baz**\nbim* bop**\n",
"html": "<p><strong>foo <em>bar <strong>baz</strong>\nbim</em> bop</strong></p>\n",
"example": 431,
"start_line": 7061,
"end_line": 7067,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo [*bar*](/url)**\n",
"html": "<p><strong>foo <a href=\"/url\"><em>bar</em></a></strong></p>\n",
"example": 432,
"start_line": 7070,
"end_line": 7074,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__ is not an empty emphasis\n",
"html": "<p>__ is not an empty emphasis</p>\n",
"example": 433,
"start_line": 7079,
"end_line": 7083,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "____ is not an empty strong emphasis\n",
"html": "<p>____ is not an empty strong emphasis</p>\n",
"example": 434,
"start_line": 7086,
"end_line": 7090,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo ***\n",
"html": "<p>foo ***</p>\n",
"example": 435,
"start_line": 7096,
"end_line": 7100,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo *\\**\n",
"html": "<p>foo <em>*</em></p>\n",
"example": 436,
"start_line": 7103,
"end_line": 7107,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo *_*\n",
"html": "<p>foo <em>_</em></p>\n",
"example": 437,
"start_line": 7110,
"end_line": 7114,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo *****\n",
"html": "<p>foo *****</p>\n",
"example": 438,
"start_line": 7117,
"end_line": 7121,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo **\\***\n",
"html": "<p>foo <strong>*</strong></p>\n",
"example": 439,
"start_line": 7124,
"end_line": 7128,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo **_**\n",
"html": "<p>foo <strong>_</strong></p>\n",
"example": 440,
"start_line": 7131,
"end_line": 7135,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo*\n",
"html": "<p>*<em>foo</em></p>\n",
"example": 441,
"start_line": 7142,
"end_line": 7146,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo**\n",
"html": "<p><em>foo</em>*</p>\n",
"example": 442,
"start_line": 7149,
"end_line": 7153,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "***foo**\n",
"html": "<p>*<strong>foo</strong></p>\n",
"example": 443,
"start_line": 7156,
"end_line": 7160,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "****foo*\n",
"html": "<p>***<em>foo</em></p>\n",
"example": 444,
"start_line": 7163,
"end_line": 7167,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo***\n",
"html": "<p><strong>foo</strong>*</p>\n",
"example": 445,
"start_line": 7170,
"end_line": 7174,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo****\n",
"html": "<p><em>foo</em>***</p>\n",
"example": 446,
"start_line": 7177,
"end_line": 7181,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo ___\n",
"html": "<p>foo ___</p>\n",
"example": 447,
"start_line": 7187,
"end_line": 7191,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo _\\__\n",
"html": "<p>foo <em>_</em></p>\n",
"example": 448,
"start_line": 7194,
"end_line": 7198,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo _*_\n",
"html": "<p>foo <em>*</em></p>\n",
"example": 449,
"start_line": 7201,
"end_line": 7205,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo _____\n",
"html": "<p>foo _____</p>\n",
"example": 450,
"start_line": 7208,
"end_line": 7212,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo __\\___\n",
"html": "<p>foo <strong>_</strong></p>\n",
"example": 451,
"start_line": 7215,
"end_line": 7219,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "foo __*__\n",
"html": "<p>foo <strong>*</strong></p>\n",
"example": 452,
"start_line": 7222,
"end_line": 7226,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo_\n",
"html": "<p>_<em>foo</em></p>\n",
"example": 453,
"start_line": 7229,
"end_line": 7233,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo__\n",
"html": "<p><em>foo</em>_</p>\n",
"example": 454,
"start_line": 7240,
"end_line": 7244,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "___foo__\n",
"html": "<p>_<strong>foo</strong></p>\n",
"example": 455,
"start_line": 7247,
"end_line": 7251,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "____foo_\n",
"html": "<p>___<em>foo</em></p>\n",
"example": 456,
"start_line": 7254,
"end_line": 7258,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo___\n",
"html": "<p><strong>foo</strong>_</p>\n",
"example": 457,
"start_line": 7261,
"end_line": 7265,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo____\n",
"html": "<p><em>foo</em>___</p>\n",
"example": 458,
"start_line": 7268,
"end_line": 7272,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo**\n",
"html": "<p><strong>foo</strong></p>\n",
"example": 459,
"start_line": 7278,
"end_line": 7282,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*_foo_*\n",
"html": "<p><em><em>foo</em></em></p>\n",
"example": 460,
"start_line": 7285,
"end_line": 7289,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__foo__\n",
"html": "<p><strong>foo</strong></p>\n",
"example": 461,
"start_line": 7292,
"end_line": 7296,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_*foo*_\n",
"html": "<p><em><em>foo</em></em></p>\n",
"example": 462,
"start_line": 7299,
"end_line": 7303,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "****foo****\n",
"html": "<p><strong><strong>foo</strong></strong></p>\n",
"example": 463,
"start_line": 7309,
"end_line": 7313,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "____foo____\n",
"html": "<p><strong><strong>foo</strong></strong></p>\n",
"example": 464,
"start_line": 7316,
"end_line": 7320,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "******foo******\n",
"html": "<p><strong><strong><strong>foo</strong></strong></strong></p>\n",
"example": 465,
"start_line": 7327,
"end_line": 7331,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "***foo***\n",
"html": "<p><em><strong>foo</strong></em></p>\n",
"example": 466,
"start_line": 7336,
"end_line": 7340,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_____foo_____\n",
"html": "<p><em><strong><strong>foo</strong></strong></em></p>\n",
"example": 467,
"start_line": 7343,
"end_line": 7347,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo _bar* baz_\n",
"html": "<p><em>foo _bar</em> baz_</p>\n",
"example": 468,
"start_line": 7352,
"end_line": 7356,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo __bar *baz bim__ bam*\n",
"html": "<p><em>foo <strong>bar *baz bim</strong> bam</em></p>\n",
"example": 469,
"start_line": 7359,
"end_line": 7363,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**foo **bar baz**\n",
"html": "<p>**foo <strong>bar baz</strong></p>\n",
"example": 470,
"start_line": 7368,
"end_line": 7372,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*foo *bar baz*\n",
"html": "<p>*foo <em>bar baz</em></p>\n",
"example": 471,
"start_line": 7375,
"end_line": 7379,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*[bar*](/url)\n",
"html": "<p>*<a href=\"/url\">bar*</a></p>\n",
"example": 472,
"start_line": 7384,
"end_line": 7388,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_foo [bar_](/url)\n",
"html": "<p>_foo <a href=\"/url\">bar_</a></p>\n",
"example": 473,
"start_line": 7391,
"end_line": 7395,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*<img src=\"foo\" title=\"*\"/>\n",
"html": "<p>*<img src=\"foo\" title=\"*\"/></p>\n",
"example": 474,
"start_line": 7398,
"end_line": 7402,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**<a href=\"**\">\n",
"html": "<p>**<a href=\"**\"></p>\n",
"example": 475,
"start_line": 7405,
"end_line": 7409,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__<a href=\"__\">\n",
"html": "<p>__<a href=\"__\"></p>\n",
"example": 476,
"start_line": 7412,
"end_line": 7416,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "*a `*`*\n",
"html": "<p><em>a <code>*</code></em></p>\n",
"example": 477,
"start_line": 7419,
"end_line": 7423,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "_a `_`_\n",
"html": "<p><em>a <code>_</code></em></p>\n",
"example": 478,
"start_line": 7426,
"end_line": 7430,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "**a<http://foo.bar/?q=**>\n",
"html": "<p>**a<a href=\"http://foo.bar/?q=**\">http://foo.bar/?q=**</a></p>\n",
"example": 479,
"start_line": 7433,
"end_line": 7437,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "__a<http://foo.bar/?q=__>\n",
"html": "<p>__a<a href=\"http://foo.bar/?q=__\">http://foo.bar/?q=__</a></p>\n",
"example": 480,
"start_line": 7440,
"end_line": 7444,
"section": "Emphasis and strong emphasis"
},
{
"markdown": "[link](/uri \"title\")\n",
"html": "<p><a href=\"/uri\" title=\"title\">link</a></p>\n",
"example": 481,
"start_line": 7528,
"end_line": 7532,
"section": "Links"
},
{
"markdown": "[link](/uri)\n",
"html": "<p><a href=\"/uri\">link</a></p>\n",
"example": 482,
"start_line": 7538,
"end_line": 7542,
"section": "Links"
},
{
"markdown": "[](./target.md)\n",
"html": "<p><a href=\"./target.md\"></a></p>\n",
"example": 483,
"start_line": 7544,
"end_line": 7548,
"section": "Links"
},
{
"markdown": "[link]()\n",
"html": "<p><a href=\"\">link</a></p>\n",
"example": 484,
"start_line": 7551,
"end_line": 7555,
"section": "Links"
},
{
"markdown": "[link](<>)\n",
"html": "<p><a href=\"\">link</a></p>\n",
"example": 485,
"start_line": 7558,
"end_line": 7562,
"section": "Links"
},
{
"markdown": "[]()\n",
"html": "<p><a href=\"\"></a></p>\n",
"example": 486,
"start_line": 7565,
"end_line": 7569,
"section": "Links"
},
{
"markdown": "[link](/my uri)\n",
"html": "<p>[link](/my uri)</p>\n",
"example": 487,
"start_line": 7574,
"end_line": 7578,
"section": "Links"
},
{
"markdown": "[link](</my uri>)\n",
"html": "<p><a href=\"/my%20uri\">link</a></p>\n",
"example": 488,
"start_line": 7580,
"end_line": 7584,
"section": "Links"
},
{
"markdown": "[link](foo\nbar)\n",
"html": "<p>[link](foo\nbar)</p>\n",
"example": 489,
"start_line": 7589,
"end_line": 7595,
"section": "Links"
},
{
"markdown": "[link](<foo\nbar>)\n",
"html": "<p>[link](<foo\nbar>)</p>\n",
"example": 490,
"start_line": 7597,
"end_line": 7603,
"section": "Links"
},
{
"markdown": "[a](<b)c>)\n",
"html": "<p><a href=\"b)c\">a</a></p>\n",
"example": 491,
"start_line": 7608,
"end_line": 7612,
"section": "Links"
},
{
"markdown": "[link](<foo\\>)\n",
"html": "<p>[link](<foo>)</p>\n",
"example": 492,
"start_line": 7616,
"end_line": 7620,
"section": "Links"
},
{
"markdown": "[a](<b)c\n[a](<b)c>\n[a](<b>c)\n",
"html": "<p>[a](<b)c\n[a](<b)c>\n[a](<b>c)</p>\n",
"example": 493,
"start_line": 7625,
"end_line": 7633,
"section": "Links"
},
{
"markdown": "[link](\\(foo\\))\n",
"html": "<p><a href=\"(foo)\">link</a></p>\n",
"example": 494,
"start_line": 7637,
"end_line": 7641,
"section": "Links"
},
{
"markdown": "[link](foo(and(bar)))\n",
"html": "<p><a href=\"foo(and(bar))\">link</a></p>\n",
"example": 495,
"start_line": 7646,
"end_line": 7650,
"section": "Links"
},
{
"markdown": "[link](foo(and(bar))\n",
"html": "<p>[link](foo(and(bar))</p>\n",
"example": 496,
"start_line": 7655,
"end_line": 7659,
"section": "Links"
},
{
"markdown": "[link](foo\\(and\\(bar\\))\n",
"html": "<p><a href=\"foo(and(bar)\">link</a></p>\n",
"example": 497,
"start_line": 7662,
"end_line": 7666,
"section": "Links"
},
{
"markdown": "[link](<foo(and(bar)>)\n",
"html": "<p><a href=\"foo(and(bar)\">link</a></p>\n",
"example": 498,
"start_line": 7669,
"end_line": 7673,
"section": "Links"
},
{
"markdown": "[link](foo\\)\\:)\n",
"html": "<p><a href=\"foo):\">link</a></p>\n",
"example": 499,
"start_line": 7679,
"end_line": 7683,
"section": "Links"
},
{
"markdown": "[link](#fragment)\n\n[link](http://example.com#fragment)\n\n[link](http://example.com?foo=3#frag)\n",
"html": "<p><a href=\"#fragment\">link</a></p>\n<p><a href=\"http://example.com#fragment\">link</a></p>\n<p><a href=\"http://example.com?foo=3#frag\">link</a></p>\n",
"example": 500,
"start_line": 7688,
"end_line": 7698,
"section": "Links"
},
{
"markdown": "[link](foo\\bar)\n",
"html": "<p><a href=\"foo%5Cbar\">link</a></p>\n",
"example": 501,
"start_line": 7704,
"end_line": 7708,
"section": "Links"
},
{
"markdown": "[link](foo%20bä)\n",
"html": "<p><a href=\"foo%20b%C3%A4\">link</a></p>\n",
"example": 502,
"start_line": 7720,
"end_line": 7724,
"section": "Links"
},
{
"markdown": "[link](\"title\")\n",
"html": "<p><a href=\"%22title%22\">link</a></p>\n",
"example": 503,
"start_line": 7731,
"end_line": 7735,
"section": "Links"
},
{
"markdown": "[link](/url \"title\")\n[link](/url 'title')\n[link](/url (title))\n",
"html": "<p><a href=\"/url\" title=\"title\">link</a>\n<a href=\"/url\" title=\"title\">link</a>\n<a href=\"/url\" title=\"title\">link</a></p>\n",
"example": 504,
"start_line": 7740,
"end_line": 7748,
"section": "Links"
},
{
"markdown": "[link](/url \"title \\\""\")\n",
"html": "<p><a href=\"/url\" title=\"title ""\">link</a></p>\n",
"example": 505,
"start_line": 7754,
"end_line": 7758,
"section": "Links"
},
{
"markdown": "[link](/url \"title\")\n",
"html": "<p><a href=\"/url%C2%A0%22title%22\">link</a></p>\n",
"example": 506,
"start_line": 7765,
"end_line": 7769,
"section": "Links"
},
{
"markdown": "[link](/url \"title \"and\" title\")\n",
"html": "<p>[link](/url "title "and" title")</p>\n",
"example": 507,
"start_line": 7774,
"end_line": 7778,
"section": "Links"
},
{
"markdown": "[link](/url 'title \"and\" title')\n",
"html": "<p><a href=\"/url\" title=\"title "and" title\">link</a></p>\n",
"example": 508,
"start_line": 7783,
"end_line": 7787,
"section": "Links"
},
{
"markdown": "[link]( /uri\n \"title\" )\n",
"html": "<p><a href=\"/uri\" title=\"title\">link</a></p>\n",
"example": 509,
"start_line": 7808,
"end_line": 7813,
"section": "Links"
},
{
"markdown": "[link] (/uri)\n",
"html": "<p>[link] (/uri)</p>\n",
"example": 510,
"start_line": 7819,
"end_line": 7823,
"section": "Links"
},
{
"markdown": "[link [foo [bar]]](/uri)\n",
"html": "<p><a href=\"/uri\">link [foo [bar]]</a></p>\n",
"example": 511,
"start_line": 7829,
"end_line": 7833,
"section": "Links"
},
{
"markdown": "[link] bar](/uri)\n",
"html": "<p>[link] bar](/uri)</p>\n",
"example": 512,
"start_line": 7836,
"end_line": 7840,
"section": "Links"
},
{
"markdown": "[link [bar](/uri)\n",
"html": "<p>[link <a href=\"/uri\">bar</a></p>\n",
"example": 513,
"start_line": 7843,
"end_line": 7847,
"section": "Links"
},
{
"markdown": "[link \\[bar](/uri)\n",
"html": "<p><a href=\"/uri\">link [bar</a></p>\n",
"example": 514,
"start_line": 7850,
"end_line": 7854,
"section": "Links"
},
{
"markdown": "[link *foo **bar** `#`*](/uri)\n",
"html": "<p><a href=\"/uri\">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>\n",
"example": 515,
"start_line": 7859,
"end_line": 7863,
"section": "Links"
},
{
"markdown": "[](/uri)\n",
"html": "<p><a href=\"/uri\"><img src=\"moon.jpg\" alt=\"moon\" /></a></p>\n",
"example": 516,
"start_line": 7866,
"end_line": 7870,
"section": "Links"
},
{
"markdown": "[foo [bar](/uri)](/uri)\n",
"html": "<p>[foo <a href=\"/uri\">bar</a>](/uri)</p>\n",
"example": 517,
"start_line": 7875,
"end_line": 7879,
"section": "Links"
},
{
"markdown": "[foo *[bar [baz](/uri)](/uri)*](/uri)\n",
"html": "<p>[foo <em>[bar <a href=\"/uri\">baz</a>](/uri)</em>](/uri)</p>\n",
"example": 518,
"start_line": 7882,
"end_line": 7886,
"section": "Links"
},
{
"markdown": "](uri2)](uri3)\n",
"html": "<p><img src=\"uri3\" alt=\"[foo](uri2)\" /></p>\n",
"example": 519,
"start_line": 7889,
"end_line": 7893,
"section": "Links"
},
{
"markdown": "*[foo*](/uri)\n",
"html": "<p>*<a href=\"/uri\">foo*</a></p>\n",
"example": 520,
"start_line": 7899,
"end_line": 7903,
"section": "Links"
},
{
"markdown": "[foo *bar](baz*)\n",
"html": "<p><a href=\"baz*\">foo *bar</a></p>\n",
"example": 521,
"start_line": 7906,
"end_line": 7910,
"section": "Links"
},
{
"markdown": "*foo [bar* baz]\n",
"html": "<p><em>foo [bar</em> baz]</p>\n",
"example": 522,
"start_line": 7916,
"end_line": 7920,
"section": "Links"
},
{
"markdown": "[foo <bar attr=\"](baz)\">\n",
"html": "<p>[foo <bar attr=\"](baz)\"></p>\n",
"example": 523,
"start_line": 7926,
"end_line": 7930,
"section": "Links"
},
{
"markdown": "[foo`](/uri)`\n",
"html": "<p>[foo<code>](/uri)</code></p>\n",
"example": 524,
"start_line": 7933,
"end_line": 7937,
"section": "Links"
},
{
"markdown": "[foo<http://example.com/?search=](uri)>\n",
"html": "<p>[foo<a href=\"http://example.com/?search=%5D(uri)\">http://example.com/?search=](uri)</a></p>\n",
"example": 525,
"start_line": 7940,
"end_line": 7944,
"section": "Links"
},
{
"markdown": "[foo][bar]\n\n[bar]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
"example": 526,
"start_line": 7978,
"end_line": 7984,
"section": "Links"
},
{
"markdown": "[link [foo [bar]]][ref]\n\n[ref]: /uri\n",
"html": "<p><a href=\"/uri\">link [foo [bar]]</a></p>\n",
"example": 527,
"start_line": 7993,
"end_line": 7999,
"section": "Links"
},
{
"markdown": "[link \\[bar][ref]\n\n[ref]: /uri\n",
"html": "<p><a href=\"/uri\">link [bar</a></p>\n",
"example": 528,
"start_line": 8002,
"end_line": 8008,
"section": "Links"
},
{
"markdown": "[link *foo **bar** `#`*][ref]\n\n[ref]: /uri\n",
"html": "<p><a href=\"/uri\">link <em>foo <strong>bar</strong> <code>#</code></em></a></p>\n",
"example": 529,
"start_line": 8013,
"end_line": 8019,
"section": "Links"
},
{
"markdown": "[][ref]\n\n[ref]: /uri\n",
"html": "<p><a href=\"/uri\"><img src=\"moon.jpg\" alt=\"moon\" /></a></p>\n",
"example": 530,
"start_line": 8022,
"end_line": 8028,
"section": "Links"
},
{
"markdown": "[foo [bar](/uri)][ref]\n\n[ref]: /uri\n",
"html": "<p>[foo <a href=\"/uri\">bar</a>]<a href=\"/uri\">ref</a></p>\n",
"example": 531,
"start_line": 8033,
"end_line": 8039,
"section": "Links"
},
{
"markdown": "[foo *bar [baz][ref]*][ref]\n\n[ref]: /uri\n",
"html": "<p>[foo <em>bar <a href=\"/uri\">baz</a></em>]<a href=\"/uri\">ref</a></p>\n",
"example": 532,
"start_line": 8042,
"end_line": 8048,
"section": "Links"
},
{
"markdown": "*[foo*][ref]\n\n[ref]: /uri\n",
"html": "<p>*<a href=\"/uri\">foo*</a></p>\n",
"example": 533,
"start_line": 8057,
"end_line": 8063,
"section": "Links"
},
{
"markdown": "[foo *bar][ref]*\n\n[ref]: /uri\n",
"html": "<p><a href=\"/uri\">foo *bar</a>*</p>\n",
"example": 534,
"start_line": 8066,
"end_line": 8072,
"section": "Links"
},
{
"markdown": "[foo <bar attr=\"][ref]\">\n\n[ref]: /uri\n",
"html": "<p>[foo <bar attr=\"][ref]\"></p>\n",
"example": 535,
"start_line": 8078,
"end_line": 8084,
"section": "Links"
},
{
"markdown": "[foo`][ref]`\n\n[ref]: /uri\n",
"html": "<p>[foo<code>][ref]</code></p>\n",
"example": 536,
"start_line": 8087,
"end_line": 8093,
"section": "Links"
},
{
"markdown": "[foo<http://example.com/?search=][ref]>\n\n[ref]: /uri\n",
"html": "<p>[foo<a href=\"http://example.com/?search=%5D%5Bref%5D\">http://example.com/?search=][ref]</a></p>\n",
"example": 537,
"start_line": 8096,
"end_line": 8102,
"section": "Links"
},
{
"markdown": "[foo][BaR]\n\n[bar]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
"example": 538,
"start_line": 8107,
"end_line": 8113,
"section": "Links"
},
{
"markdown": "[ẞ]\n\n[SS]: /url\n",
"html": "<p><a href=\"/url\">ẞ</a></p>\n",
"example": 539,
"start_line": 8118,
"end_line": 8124,
"section": "Links"
},
{
"markdown": "[Foo\n bar]: /url\n\n[Baz][Foo bar]\n",
"html": "<p><a href=\"/url\">Baz</a></p>\n",
"example": 540,
"start_line": 8130,
"end_line": 8137,
"section": "Links"
},
{
"markdown": "[foo] [bar]\n\n[bar]: /url \"title\"\n",
"html": "<p>[foo] <a href=\"/url\" title=\"title\">bar</a></p>\n",
"example": 541,
"start_line": 8143,
"end_line": 8149,
"section": "Links"
},
{
"markdown": "[foo]\n[bar]\n\n[bar]: /url \"title\"\n",
"html": "<p>[foo]\n<a href=\"/url\" title=\"title\">bar</a></p>\n",
"example": 542,
"start_line": 8152,
"end_line": 8160,
"section": "Links"
},
{
"markdown": "[foo]: /url1\n\n[foo]: /url2\n\n[bar][foo]\n",
"html": "<p><a href=\"/url1\">bar</a></p>\n",
"example": 543,
"start_line": 8193,
"end_line": 8201,
"section": "Links"
},
{
"markdown": "[bar][foo\\!]\n\n[foo!]: /url\n",
"html": "<p>[bar][foo!]</p>\n",
"example": 544,
"start_line": 8208,
"end_line": 8214,
"section": "Links"
},
{
"markdown": "[foo][ref[]\n\n[ref[]: /uri\n",
"html": "<p>[foo][ref[]</p>\n<p>[ref[]: /uri</p>\n",
"example": 545,
"start_line": 8220,
"end_line": 8227,
"section": "Links"
},
{
"markdown": "[foo][ref[bar]]\n\n[ref[bar]]: /uri\n",
"html": "<p>[foo][ref[bar]]</p>\n<p>[ref[bar]]: /uri</p>\n",
"example": 546,
"start_line": 8230,
"end_line": 8237,
"section": "Links"
},
{
"markdown": "[[[foo]]]\n\n[[[foo]]]: /url\n",
"html": "<p>[[[foo]]]</p>\n<p>[[[foo]]]: /url</p>\n",
"example": 547,
"start_line": 8240,
"end_line": 8247,
"section": "Links"
},
{
"markdown": "[foo][ref\\[]\n\n[ref\\[]: /uri\n",
"html": "<p><a href=\"/uri\">foo</a></p>\n",
"example": 548,
"start_line": 8250,
"end_line": 8256,
"section": "Links"
},
{
"markdown": "[bar\\\\]: /uri\n\n[bar\\\\]\n",
"html": "<p><a href=\"/uri\">bar\\</a></p>\n",
"example": 549,
"start_line": 8261,
"end_line": 8267,
"section": "Links"
},
{
"markdown": "[]\n\n[]: /uri\n",
"html": "<p>[]</p>\n<p>[]: /uri</p>\n",
"example": 550,
"start_line": 8273,
"end_line": 8280,
"section": "Links"
},
{
"markdown": "[\n ]\n\n[\n ]: /uri\n",
"html": "<p>[\n]</p>\n<p>[\n]: /uri</p>\n",
"example": 551,
"start_line": 8283,
"end_line": 8294,
"section": "Links"
},
{
"markdown": "[foo][]\n\n[foo]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
"example": 552,
"start_line": 8306,
"end_line": 8312,
"section": "Links"
},
{
"markdown": "[*foo* bar][]\n\n[*foo* bar]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>\n",
"example": 553,
"start_line": 8315,
"end_line": 8321,
"section": "Links"
},
{
"markdown": "[Foo][]\n\n[foo]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">Foo</a></p>\n",
"example": 554,
"start_line": 8326,
"end_line": 8332,
"section": "Links"
},
{
"markdown": "[foo] \n[]\n\n[foo]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">foo</a>\n[]</p>\n",
"example": 555,
"start_line": 8339,
"end_line": 8347,
"section": "Links"
},
{
"markdown": "[foo]\n\n[foo]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">foo</a></p>\n",
"example": 556,
"start_line": 8359,
"end_line": 8365,
"section": "Links"
},
{
"markdown": "[*foo* bar]\n\n[*foo* bar]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\"><em>foo</em> bar</a></p>\n",
"example": 557,
"start_line": 8368,
"end_line": 8374,
"section": "Links"
},
{
"markdown": "[[*foo* bar]]\n\n[*foo* bar]: /url \"title\"\n",
"html": "<p>[<a href=\"/url\" title=\"title\"><em>foo</em> bar</a>]</p>\n",
"example": 558,
"start_line": 8377,
"end_line": 8383,
"section": "Links"
},
{
"markdown": "[[bar [foo]\n\n[foo]: /url\n",
"html": "<p>[[bar <a href=\"/url\">foo</a></p>\n",
"example": 559,
"start_line": 8386,
"end_line": 8392,
"section": "Links"
},
{
"markdown": "[Foo]\n\n[foo]: /url \"title\"\n",
"html": "<p><a href=\"/url\" title=\"title\">Foo</a></p>\n",
"example": 560,
"start_line": 8397,
"end_line": 8403,
"section": "Links"
},
{
"markdown": "[foo] bar\n\n[foo]: /url\n",
"html": "<p><a href=\"/url\">foo</a> bar</p>\n",
"example": 561,
"start_line": 8408,
"end_line": 8414,
"section": "Links"
},
{
"markdown": "\\[foo]\n\n[foo]: /url \"title\"\n",
"html": "<p>[foo]</p>\n",
"example": 562,
"start_line": 8420,
"end_line": 8426,
"section": "Links"
},
{
"markdown": "[foo*]: /url\n\n*[foo*]\n",
"html": "<p>*<a href=\"/url\">foo*</a></p>\n",
"example": 563,
"start_line": 8432,
"end_line": 8438,
"section": "Links"
},
{
"markdown": "[foo][bar]\n\n[foo]: /url1\n[bar]: /url2\n",
"html": "<p><a href=\"/url2\">foo</a></p>\n",
"example": 564,
"start_line": 8444,
"end_line": 8451,
"section": "Links"
},
{
"markdown": "[foo][]\n\n[foo]: /url1\n",
"html": "<p><a href=\"/url1\">foo</a></p>\n",
"example": 565,
"start_line": 8453,
"end_line": 8459,
"section": "Links"
},
{
"markdown": "[foo]()\n\n[foo]: /url1\n",
"html": "<p><a href=\"\">foo</a></p>\n",
"example": 566,
"start_line": 8463,
"end_line": 8469,
"section": "Links"
},
{
"markdown": "[foo](not a link)\n\n[foo]: /url1\n",
"html": "<p><a href=\"/url1\">foo</a>(not a link)</p>\n",
"example": 567,
"start_line": 8471,
"end_line": 8477,
"section": "Links"
},
{
"markdown": "[foo][bar][baz]\n\n[baz]: /url\n",
"html": "<p>[foo]<a href=\"/url\">bar</a></p>\n",
"example": 568,
"start_line": 8482,
"end_line": 8488,
"section": "Links"
},
{
"markdown": "[foo][bar][baz]\n\n[baz]: /url1\n[bar]: /url2\n",
"html": "<p><a href=\"/url2\">foo</a><a href=\"/url1\">baz</a></p>\n",
"example": 569,
"start_line": 8494,
"end_line": 8501,
"section": "Links"
},
{
"markdown": "[foo][bar][baz]\n\n[baz]: /url1\n[foo]: /url2\n",
"html": "<p>[foo]<a href=\"/url1\">bar</a></p>\n",
"example": 570,
"start_line": 8507,
"end_line": 8514,
"section": "Links"
},
{
"markdown": "![foo](/url \"title\")\n",
"html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" /></p>\n",
"example": 571,
"start_line": 8530,
"end_line": 8534,
"section": "Images"
},
{
"markdown": "![foo *bar*]\n\n[foo *bar*]: train.jpg \"train & tracks\"\n",
"html": "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train & tracks\" /></p>\n",
"example": 572,
"start_line": 8537,
"end_line": 8543,
"section": "Images"
},
{
"markdown": "](/url2)\n",
"html": "<p><img src=\"/url2\" alt=\"foo bar\" /></p>\n",
"example": 573,
"start_line": 8546,
"end_line": 8550,
"section": "Images"
},
{
"markdown": "](/url2)\n",
"html": "<p><img src=\"/url2\" alt=\"foo bar\" /></p>\n",
"example": 574,
"start_line": 8553,
"end_line": 8557,
"section": "Images"
},
{
"markdown": "![foo *bar*][]\n\n[foo *bar*]: train.jpg \"train & tracks\"\n",
"html": "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train & tracks\" /></p>\n",
"example": 575,
"start_line": 8567,
"end_line": 8573,
"section": "Images"
},
{
"markdown": "![foo *bar*][foobar]\n\n[FOOBAR]: train.jpg \"train & tracks\"\n",
"html": "<p><img src=\"train.jpg\" alt=\"foo bar\" title=\"train & tracks\" /></p>\n",
"example": 576,
"start_line": 8576,
"end_line": 8582,
"section": "Images"
},
{
"markdown": "\n",
"html": "<p><img src=\"train.jpg\" alt=\"foo\" /></p>\n",
"example": 577,
"start_line": 8585,
"end_line": 8589,
"section": "Images"
},
{
"markdown": "My ![foo bar](/path/to/train.jpg \"title\" )\n",
"html": "<p>My <img src=\"/path/to/train.jpg\" alt=\"foo bar\" title=\"title\" /></p>\n",
"example": 578,
"start_line": 8592,
"end_line": 8596,
"section": "Images"
},
{
"markdown": "\n",
"html": "<p><img src=\"url\" alt=\"foo\" /></p>\n",
"example": 579,
"start_line": 8599,
"end_line": 8603,
"section": "Images"
},
{
"markdown": "\n",
"html": "<p><img src=\"/url\" alt=\"\" /></p>\n",
"example": 580,
"start_line": 8606,
"end_line": 8610,
"section": "Images"
},
{
"markdown": "![foo][bar]\n\n[bar]: /url\n",
"html": "<p><img src=\"/url\" alt=\"foo\" /></p>\n",
"example": 581,
"start_line": 8615,
"end_line": 8621,
"section": "Images"
},
{
"markdown": "![foo][bar]\n\n[BAR]: /url\n",
"html": "<p><img src=\"/url\" alt=\"foo\" /></p>\n",
"example": 582,
"start_line": 8624,
"end_line": 8630,
"section": "Images"
},
{
"markdown": "![foo][]\n\n[foo]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" /></p>\n",
"example": 583,
"start_line": 8635,
"end_line": 8641,
"section": "Images"
},
{
"markdown": "![*foo* bar][]\n\n[*foo* bar]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>\n",
"example": 584,
"start_line": 8644,
"end_line": 8650,
"section": "Images"
},
{
"markdown": "![Foo][]\n\n[foo]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"Foo\" title=\"title\" /></p>\n",
"example": 585,
"start_line": 8655,
"end_line": 8661,
"section": "Images"
},
{
"markdown": "![foo] \n[]\n\n[foo]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" />\n[]</p>\n",
"example": 586,
"start_line": 8667,
"end_line": 8675,
"section": "Images"
},
{
"markdown": "![foo]\n\n[foo]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"foo\" title=\"title\" /></p>\n",
"example": 587,
"start_line": 8680,
"end_line": 8686,
"section": "Images"
},
{
"markdown": "![*foo* bar]\n\n[*foo* bar]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"foo bar\" title=\"title\" /></p>\n",
"example": 588,
"start_line": 8689,
"end_line": 8695,
"section": "Images"
},
{
"markdown": "![[foo]]\n\n[[foo]]: /url \"title\"\n",
"html": "<p>![[foo]]</p>\n<p>[[foo]]: /url "title"</p>\n",
"example": 589,
"start_line": 8700,
"end_line": 8707,
"section": "Images"
},
{
"markdown": "![Foo]\n\n[foo]: /url \"title\"\n",
"html": "<p><img src=\"/url\" alt=\"Foo\" title=\"title\" /></p>\n",
"example": 590,
"start_line": 8712,
"end_line": 8718,
"section": "Images"
},
{
"markdown": "!\\[foo]\n\n[foo]: /url \"title\"\n",
"html": "<p>![foo]</p>\n",
"example": 591,
"start_line": 8724,
"end_line": 8730,
"section": "Images"
},
{
"markdown": "\\![foo]\n\n[foo]: /url \"title\"\n",
"html": "<p>!<a href=\"/url\" title=\"title\">foo</a></p>\n",
"example": 592,
"start_line": 8736,
"end_line": 8742,
"section": "Images"
},
{
"markdown": "<http://foo.bar.baz>\n",
"html": "<p><a href=\"http://foo.bar.baz\">http://foo.bar.baz</a></p>\n",
"example": 593,
"start_line": 8769,
"end_line": 8773,
"section": "Autolinks"
},
{
"markdown": "<http://foo.bar.baz/test?q=hello&id=22&boolean>\n",
"html": "<p><a href=\"http://foo.bar.baz/test?q=hello&id=22&boolean\">http://foo.bar.baz/test?q=hello&id=22&boolean</a></p>\n",
"example": 594,
"start_line": 8776,
"end_line": 8780,
"section": "Autolinks"
},
{
"markdown": "<irc://foo.bar:2233/baz>\n",
"html": "<p><a href=\"irc://foo.bar:2233/baz\">irc://foo.bar:2233/baz</a></p>\n",
"example": 595,
"start_line": 8783,
"end_line": 8787,
"section": "Autolinks"
},
{
"markdown": "<MAILTO:FOO@BAR.BAZ>\n",
"html": "<p><a href=\"MAILTO:FOO@BAR.BAZ\">MAILTO:FOO@BAR.BAZ</a></p>\n",
"example": 596,
"start_line": 8792,
"end_line": 8796,
"section": "Autolinks"
},
{
"markdown": "<a+b+c:d>\n",
"html": "<p><a href=\"a+b+c:d\">a+b+c:d</a></p>\n",
"example": 597,
"start_line": 8804,
"end_line": 8808,
"section": "Autolinks"
},
{
"markdown": "<made-up-scheme://foo,bar>\n",
"html": "<p><a href=\"made-up-scheme://foo,bar\">made-up-scheme://foo,bar</a></p>\n",
"example": 598,
"start_line": 8811,
"end_line": 8815,
"section": "Autolinks"
},
{
"markdown": "<http://../>\n",
"html": "<p><a href=\"http://../\">http://../</a></p>\n",
"example": 599,
"start_line": 8818,
"end_line": 8822,
"section": "Autolinks"
},
{
"markdown": "<localhost:5001/foo>\n",
"html": "<p><a href=\"localhost:5001/foo\">localhost:5001/foo</a></p>\n",
"example": 600,
"start_line": 8825,
"end_line": 8829,
"section": "Autolinks"
},
{
"markdown": "<http://foo.bar/baz bim>\n",
"html": "<p><http://foo.bar/baz bim></p>\n",
"example": 601,
"start_line": 8834,
"end_line": 8838,
"section": "Autolinks"
},
{
"markdown": "<http://example.com/\\[\\>\n",
"html": "<p><a href=\"http://example.com/%5C%5B%5C\">http://example.com/\\[\\</a></p>\n",
"example": 602,
"start_line": 8843,
"end_line": 8847,
"section": "Autolinks"
},
{
"markdown": "<foo@bar.example.com>\n",
"html": "<p><a href=\"mailto:foo@bar.example.com\">foo@bar.example.com</a></p>\n",
"example": 603,
"start_line": 8865,
"end_line": 8869,
"section": "Autolinks"
},
{
"markdown": "<foo+special@Bar.baz-bar0.com>\n",
"html": "<p><a href=\"mailto:foo+special@Bar.baz-bar0.com\">foo+special@Bar.baz-bar0.com</a></p>\n",
"example": 604,
"start_line": 8872,
"end_line": 8876,
"section": "Autolinks"
},
{
"markdown": "<foo\\+@bar.example.com>\n",
"html": "<p><foo+@bar.example.com></p>\n",
"example": 605,
"start_line": 8881,
"end_line": 8885,
"section": "Autolinks"
},
{
"markdown": "<>\n",
"html": "<p><></p>\n",
"example": 606,
"start_line": 8890,
"end_line": 8894,
"section": "Autolinks"
},
{
"markdown": "< http://foo.bar >\n",
"html": "<p>< http://foo.bar ></p>\n",
"example": 607,
"start_line": 8897,
"end_line": 8901,
"section": "Autolinks"
},
{
"markdown": "<m:abc>\n",
"html": "<p><m:abc></p>\n",
"example": 608,
"start_line": 8904,
"end_line": 8908,
"section": "Autolinks"
},
{
"markdown": "<foo.bar.baz>\n",
"html": "<p><foo.bar.baz></p>\n",
"example": 609,
"start_line": 8911,
"end_line": 8915,
"section": "Autolinks"
},
{
"markdown": "http://example.com\n",
"html": "<p>http://example.com</p>\n",
"example": 610,
"start_line": 8918,
"end_line": 8922,
"section": "Autolinks"
},
{
"markdown": "foo@bar.example.com\n",
"html": "<p>foo@bar.example.com</p>\n",
"example": 611,
"start_line": 8925,
"end_line": 8929,
"section": "Autolinks"
},
{
"markdown": "<a><bab><c2c>\n",
"html": "<p><a><bab><c2c></p>\n",
"example": 612,
"start_line": 9006,
"end_line": 9010,
"section": "Raw HTML"
},
{
"markdown": "<a/><b2/>\n",
"html": "<p><a/><b2/></p>\n",
"example": 613,
"start_line": 9015,
"end_line": 9019,
"section": "Raw HTML"
},
{
"markdown": "<a /><b2\ndata=\"foo\" >\n",
"html": "<p><a /><b2\ndata=\"foo\" ></p>\n",
"example": 614,
"start_line": 9024,
"end_line": 9030,
"section": "Raw HTML"
},
{
"markdown": "<a foo=\"bar\" bam = 'baz <em>\"</em>'\n_boolean zoop:33=zoop:33 />\n",
"html": "<p><a foo=\"bar\" bam = 'baz <em>\"</em>'\n_boolean zoop:33=zoop:33 /></p>\n",
"example": 615,
"start_line": 9035,
"end_line": 9041,
"section": "Raw HTML"
},
{
"markdown": "Foo <responsive-image src=\"foo.jpg\" />\n",
"html": "<p>Foo <responsive-image src=\"foo.jpg\" /></p>\n",
"example": 616,
"start_line": 9046,
"end_line": 9050,
"section": "Raw HTML"
},
{
"markdown": "<33> <__>\n",
"html": "<p><33> <__></p>\n",
"example": 617,
"start_line": 9055,
"end_line": 9059,
"section": "Raw HTML"
},
{
"markdown": "<a h*#ref=\"hi\">\n",
"html": "<p><a h*#ref="hi"></p>\n",
"example": 618,
"start_line": 9064,
"end_line": 9068,
"section": "Raw HTML"
},
{
"markdown": "<a href=\"hi'> <a href=hi'>\n",
"html": "<p><a href="hi'> <a href=hi'></p>\n",
"example": 619,
"start_line": 9073,
"end_line": 9077,
"section": "Raw HTML"
},
{
"markdown": "< a><\nfoo><bar/ >\n<foo bar=baz\nbim!bop />\n",
"html": "<p>< a><\nfoo><bar/ >\n<foo bar=baz\nbim!bop /></p>\n",
"example": 620,
"start_line": 9082,
"end_line": 9092,
"section": "Raw HTML"
},
{
"markdown": "<a href='bar'title=title>\n",
"html": "<p><a href='bar'title=title></p>\n",
"example": 621,
"start_line": 9097,
"end_line": 9101,
"section": "Raw HTML"
},
{
"markdown": "</a></foo >\n",
"html": "<p></a></foo ></p>\n",
"example": 622,
"start_line": 9106,
"end_line": 9110,
"section": "Raw HTML"
},
{
"markdown": "</a href=\"foo\">\n",
"html": "<p></a href="foo"></p>\n",
"example": 623,
"start_line": 9115,
"end_line": 9119,
"section": "Raw HTML"
},
{
"markdown": "foo <!-- this is a\ncomment - with hyphen -->\n",
"html": "<p>foo <!-- this is a\ncomment - with hyphen --></p>\n",
"example": 624,
"start_line": 9124,
"end_line": 9130,
"section": "Raw HTML"
},
{
"markdown": "foo <!-- not a comment -- two hyphens -->\n",
"html": "<p>foo <!-- not a comment -- two hyphens --></p>\n",
"example": 625,
"start_line": 9133,
"end_line": 9137,
"section": "Raw HTML"
},
{
"markdown": "foo <!--> foo -->\n\nfoo <!-- foo--->\n",
"html": "<p>foo <!--> foo --></p>\n<p>foo <!-- foo---></p>\n",
"example": 626,
"start_line": 9142,
"end_line": 9149,
"section": "Raw HTML"
},
{
"markdown": "foo <?php echo $a; ?>\n",
"html": "<p>foo <?php echo $a; ?></p>\n",
"example": 627,
"start_line": 9154,
"end_line": 9158,
"section": "Raw HTML"
},
{
"markdown": "foo <!ELEMENT br EMPTY>\n",
"html": "<p>foo <!ELEMENT br EMPTY></p>\n",
"example": 628,
"start_line": 9163,
"end_line": 9167,
"section": "Raw HTML"
},
{
"markdown": "foo <![CDATA[>&<]]>\n",
"html": "<p>foo <![CDATA[>&<]]></p>\n",
"example": 629,
"start_line": 9172,
"end_line": 9176,
"section": "Raw HTML"
},
{
"markdown": "foo <a href=\"ö\">\n",
"html": "<p>foo <a href=\"ö\"></p>\n",
"example": 630,
"start_line": 9182,
"end_line": 9186,
"section": "Raw HTML"
},
{
"markdown": "foo <a href=\"\\*\">\n",
"html": "<p>foo <a href=\"\\*\"></p>\n",
"example": 631,
"start_line": 9191,
"end_line": 9195,
"section": "Raw HTML"
},
{
"markdown": "<a href=\"\\\"\">\n",
"html": "<p><a href="""></p>\n",
"example": 632,
"start_line": 9198,
"end_line": 9202,
"section": "Raw HTML"
},
{
"markdown": "foo \nbaz\n",
"html": "<p>foo<br />\nbaz</p>\n",
"example": 633,
"start_line": 9212,
"end_line": 9218,
"section": "Hard line breaks"
},
{
"markdown": "foo\\\nbaz\n",
"html": "<p>foo<br />\nbaz</p>\n",
"example": 634,
"start_line": 9224,
"end_line": 9230,
"section": "Hard line breaks"
},
{
"markdown": "foo \nbaz\n",
"html": "<p>foo<br />\nbaz</p>\n",
"example": 635,
"start_line": 9235,
"end_line": 9241,
"section": "Hard line breaks"
},
{
"markdown": "foo \n bar\n",
"html": "<p>foo<br />\nbar</p>\n",
"example": 636,
"start_line": 9246,
"end_line": 9252,
"section": "Hard line breaks"
},
{
"markdown": "foo\\\n bar\n",
"html": "<p>foo<br />\nbar</p>\n",
"example": 637,
"start_line": 9255,
"end_line": 9261,
"section": "Hard line breaks"
},
{
"markdown": "*foo \nbar*\n",
"html": "<p><em>foo<br />\nbar</em></p>\n",
"example": 638,
"start_line": 9267,
"end_line": 9273,
"section": "Hard line breaks"
},
{
"markdown": "*foo\\\nbar*\n",
"html": "<p><em>foo<br />\nbar</em></p>\n",
"example": 639,
"start_line": 9276,
"end_line": 9282,
"section": "Hard line breaks"
},
{
"markdown": "`code \nspan`\n",
"html": "<p><code>code span</code></p>\n",
"example": 640,
"start_line": 9287,
"end_line": 9292,
"section": "Hard line breaks"
},
{
"markdown": "`code\\\nspan`\n",
"html": "<p><code>code\\ span</code></p>\n",
"example": 641,
"start_line": 9295,
"end_line": 9300,
"section": "Hard line breaks"
},
{
"markdown": "<a href=\"foo \nbar\">\n",
"html": "<p><a href=\"foo \nbar\"></p>\n",
"example": 642,
"start_line": 9305,
"end_line": 9311,
"section": "Hard line breaks"
},
{
"markdown": "<a href=\"foo\\\nbar\">\n",
"html": "<p><a href=\"foo\\\nbar\"></p>\n",
"example": 643,
"start_line": 9314,
"end_line": 9320,
"section": "Hard line breaks"
},
{
"markdown": "foo\\\n",
"html": "<p>foo\\</p>\n",
"example": 644,
"start_line": 9327,
"end_line": 9331,
"section": "Hard line breaks"
},
{
"markdown": "foo \n",
"html": "<p>foo</p>\n",
"example": 645,
"start_line": 9334,
"end_line": 9338,
"section": "Hard line breaks"
},
{
"markdown": "### foo\\\n",
"html": "<h3>foo\\</h3>\n",
"example": 646,
"start_line": 9341,
"end_line": 9345,
"section": "Hard line breaks"
},
{
"markdown": "### foo \n",
"html": "<h3>foo</h3>\n",
"example": 647,
"start_line": 9348,
"end_line": 9352,
"section": "Hard line breaks"
},
{
"markdown": "foo\nbaz\n",
"html": "<p>foo\nbaz</p>\n",
"example": 648,
"start_line": 9363,
"end_line": 9369,
"section": "Soft line breaks"
},
{
"markdown": "foo \n baz\n",
"html": "<p>foo\nbaz</p>\n",
"example": 649,
"start_line": 9375,
"end_line": 9381,
"section": "Soft line breaks"
},
{
"markdown": "hello $.;'there\n",
"html": "<p>hello $.;'there</p>\n",
"example": 650,
"start_line": 9395,
"end_line": 9399,
"section": "Textual content"
},
{
"markdown": "Foo χρῆν\n",
"html": "<p>Foo χρῆν</p>\n",
"example": 651,
"start_line": 9402,
"end_line": 9406,
"section": "Textual content"
},
{
"markdown": "Multiple spaces\n",
"html": "<p>Multiple spaces</p>\n",
"example": 652,
"start_line": 9411,
"end_line": 9415,
"section": "Textual content"
}
] mistune-3.1.3/tests/fixtures/def_list.txt 0000664 0000000 0000000 00000005422 14766552020 0020561 0 ustar 00root root 0000000 0000000 # Definition Lists
```````````````````````````````` example
Term
: definition
.
<dl>
<dt>Term</dt>
<dd>definition</dd>
</dl>
````````````````````````````````
```````````````````````````````` example
Term
: definition1
: definition2
.
<dl>
<dt>Term</dt>
<dd>definition1</dd>
<dd>definition2</dd>
</dl>
````````````````````````````````
```````````````````````````````` example
Term
: definition1
: definition2
paragraph
.
<dl>
<dt>Term</dt>
<dd>definition1</dd>
<dd>definition2</dd>
</dl>
<p>paragraph</p>
````````````````````````````````
```````````````````````````````` example
First Term
: This is the definition of the first term.
Second Term
: This is one definition of the second term.
: This is another definition of the second term.
.
<dl>
<dt>First Term</dt>
<dd>This is the definition of the first term.</dd>
<dt>Second Term</dt>
<dd>This is one definition of the second term.</dd>
<dd>This is another definition of the second term.</dd>
</dl>
````````````````````````````````
```````````````````````````````` example
First Term
: This is the definition of the first term.
Second Term
: This is one definition of the second term.
: This is another definition of the second term.
paragraph
.
<dl>
<dt>First Term</dt>
<dd>This is the definition of the first term.</dd>
<dt>Second Term</dt>
<dd>This is one definition of the second term.</dd>
<dd>This is another definition of the second term.</dd>
</dl>
<p>paragraph</p>
````````````````````````````````
```````````````````````````````` example
First Term
: This is the definition of the first term.
Not Second Term
: This is one definition of the second term.
: This is another definition of the second term.
paragraph
.
<dl>
<dt>First Term</dt>
<dd>This is the definition of the first term.
Not Second Term</dd>
<dd>This is one definition of the second term.</dd>
<dd>This is another definition of the second term.</dd>
</dl>
<p>paragraph</p>
````````````````````````````````
## Definition with Multiple Lines
```````````````````````````````` example
Term
: definition
.
<dl>
<dt>Term</dt>
<dd><p>definition</p>
</dd>
</dl>
````````````````````````````````
```````````````````````````````` example
Term
: foo
bar
.
<dl>
<dt>Term</dt>
<dd><p>foo</p>
<p>bar</p>
</dd>
</dl>
````````````````````````````````
Leading 4 white spaces
```````````````````````````````` example
Term
: foo
bar
.
<dl>
<dt>Term</dt>
<dd><p>foo</p>
<p>bar</p>
</dd>
</dl>
````````````````````````````````
```````````````````````````````` example
Term
: foo
bar
.
<dl>
<dt>Term</dt>
<dd><p>foo</p>
<pre><code>bar</code></pre>
</dd>
</dl>
````````````````````````````````
```````````````````````````````` example
Term
: foo
- bar
- baz
.
<dl>
<dt>Term</dt>
<dd><p>foo</p>
<ul>
<li>bar</li>
<li>baz</li>
</ul>
</dd>
</dl>
````````````````````````````````
mistune-3.1.3/tests/fixtures/diff-commonmark.txt 0000664 0000000 0000000 00000002230 14766552020 0022033 0 ustar 00root root 0000000 0000000 # Differences
Results different than commonmark.
## Setext headings
Example: 93
```````````````````````````````` example
> foo
bar
===
.
<blockquote>
<h1>foo
bar</h1>
</blockquote>
````````````````````````````````
If the dash is less than 3, it is not a `<hr>`, in this case, it
can be rendered into `<h2>`.
```````````````````````````````` example
- # Foo
- Bar
--
baz
.
<ul>
<li>
<h1>Foo</h1>
</li>
<li>
<h2>Bar</h2>
baz</li>
</ul>
````````````````````````````````
## Image
Example 573
```````````````````````````````` example
](/url2)
.
<p><img src="/url2" alt="foo " /></p>
````````````````````````````````
## Link
Example 517
```````````````````````````````` example
[foo [bar](/uri)](/uri)
.
<p><a href="/uri">foo [bar](/uri)</a></p>
````````````````````````````````
Example 518
```````````````````````````````` example
[foo *[bar [baz](/uri)](/uri)*](/uri)
.
<p><a href="/uri">foo <em>[bar [baz](/uri)](/uri)</em></a></p>
````````````````````````````````
Example 519
```````````````````````````````` example
](uri2)](uri3)
.
<p><img src="uri3" alt="[foo](uri1)" /></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/fenced_admonition.txt 0000664 0000000 0000000 00000004450 14766552020 0022435 0 ustar 00root root 0000000 0000000 # Admonition
```````````````````````````````` example
```{unknown} Hi
this is **strong** world
```
.
<div class="error"><pre>{unknown} Hi
this is **strong** world
</pre></div>
````````````````````````````````
```````````````````````````````` example
```
this is code
```
.
<pre><code>this is code
</code></pre>
````````````````````````````````
```````````````````````````````` example
~~~{note} Warning
message
~~~
.
<section class="admonition note">
<p class="admonition-title">Warning</p>
<p>message</p>
</section>
````````````````````````````````
```````````````````````````````` example
~~~{note} A **strong** title
_message_
~~~
.
<section class="admonition note">
<p class="admonition-title">A <strong>strong</strong> title</p>
<p><em>message</em></p>
</section>
````````````````````````````````
Test with code block.
```````````````````````````````` example
```{note}
print()
```
.
<section class="admonition note">
<p class="admonition-title">Note</p>
<pre><code>print()</code></pre>
</section>
````````````````````````````````
Test with no message.
```````````````````````````````` example
~~~{note} Warning
~~~
.
<section class="admonition note">
<p class="admonition-title">Warning</p>
</section>
````````````````````````````````
Test with no ending fence
```````````````````````````````` example
~~~{note} Warning
.
<section class="admonition note">
<p class="admonition-title">Warning</p>
</section>
````````````````````````````````
Test with nested admonition
```````````````````````````````` example
~~~~~~~{note}
~~~~~~{warning}
~~~~~{tip}
~~~~{caution}
~~~{hint}
``````{danger}
`````{attention}
````{important}
```{error}
```
````
`````
``````
~~~
~~~~
~~~~~
~~~~~~
~~~~~~~
.
<section class="admonition note">
<p class="admonition-title">Note</p>
<section class="admonition warning">
<p class="admonition-title">Warning</p>
<section class="admonition tip">
<p class="admonition-title">Tip</p>
<section class="admonition caution">
<p class="admonition-title">Caution</p>
<section class="admonition hint">
<p class="admonition-title">Hint</p>
<section class="admonition danger">
<p class="admonition-title">Danger</p>
<pre><code class="language-{attention}">````{important}
```{error}
```
````
</code></pre>
</section>
</section>
</section>
</section>
</section>
</section>
````````````````````````````````
mistune-3.1.3/tests/fixtures/fenced_figure.txt 0000664 0000000 0000000 00000006631 14766552020 0021560 0 ustar 00root root 0000000 0000000 # Figure
## No options
```````````````````````````````` example
~~~{figure} picture.png
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" /></div>
</figure>
````````````````````````````````
## Align options
```````````````````````````````` example
~~~{figure} picture.png
:align: left
~~~
.
<figure class="figure align-left">
<div class="block-image"><img src="picture.png" /></div>
</figure>
````````````````````````````````
```````````````````````````````` example
~~~{figure} picture.png
:align: invalid
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" /></div>
</figure>
````````````````````````````````
## width and height
```````````````````````````````` example
~~~{figure} picture.png
:width: 100
:height: 50
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" width="100" height="50" /></div>
</figure>
````````````````````````````````
```````````````````````````````` example
~~~{figure} picture.png
:width: 100px
:height: 50px
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" style="width:100px;height:50px;" /></div>
</figure>
````````````````````````````````
```````````````````````````````` example
~~~{figure} picture.png
:figwidth: 400px
~~~
.
<figure class="figure" style="width:400px">
<div class="block-image"><img src="picture.png" /></div>
</figure>
````````````````````````````````
## alt option
```````````````````````````````` example
~~~{figure} picture.png
:alt: description text
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" alt="description text" /></div>
</figure>
````````````````````````````````
## target option
```````````````````````````````` example
~~~{figure} picture.png
:target: https://lepture.com
~~~
.
<figure class="figure">
<a class="block-image" href="https://lepture.com"><img src="picture.png" /></a>
</figure>
````````````````````````````````
## caption
```````````````````````````````` example
~~~{figure} picture.png
a caption with **emphasis** text
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" /></div>
<figcaption>a caption with <strong>emphasis</strong> text</figcaption>
</figure>
````````````````````````````````
## legend
```````````````````````````````` example
~~~{figure} picture.png
a caption with **emphasis** text
> quote
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" /></div>
<figcaption>a caption with <strong>emphasis</strong> text</figcaption>
<div class="legend">
<blockquote>
<p>quote</p>
</blockquote>
</div>
</figure>
````````````````````````````````
```````````````````````````````` example
~~~{figure} picture.png
> quote
~~~
.
<figure class="figure">
<div class="block-image"><img src="picture.png" /></div>
</figure>
````````````````````````````````
## all options
```````````````````````````````` example
~~~{figure} picture.png
:figwidth: 400px
:figclass: all-options
:target: https://lepture.com
:alt: description
:align: left
:width: 100
:height: 50
a caption with **emphasis** text
> quote
~~~
.
<figure class="figure align-left all-options" style="width:400px">
<a class="block-image" href="https://lepture.com"><img src="picture.png" alt="description" width="100" height="50" /></a>
<figcaption>a caption with <strong>emphasis</strong> text</figcaption>
<div class="legend">
<blockquote>
<p>quote</p>
</blockquote>
</div>
</figure>
````````````````````````````````
mistune-3.1.3/tests/fixtures/fenced_image.txt 0000664 0000000 0000000 00000004447 14766552020 0021364 0 ustar 00root root 0000000 0000000 # Image
## No options
```````````````````````````````` example
~~~{image} picture.png
~~~
.
<div class="block-image"><img src="picture.png" /></div>
````````````````````````````````
## Align options
```````````````````````````````` example
~~~{image} picture.png
:align: left
~~~
.
<div class="block-image align-left"><img src="picture.png" /></div>
````````````````````````````````
```````````````````````````````` example
~~~{image} picture.png
:align: invalid
~~~
.
<div class="block-image"><img src="picture.png" /></div>
````````````````````````````````
## width and height
```````````````````````````````` example
~~~{image} picture.png
:width: 100
:height: 50
~~~
.
<div class="block-image"><img src="picture.png" width="100" height="50" /></div>
````````````````````````````````
```````````````````````````````` example
~~~{image} picture.png
:width: 100px
:height: 50px
~~~
.
<div class="block-image"><img src="picture.png" style="width:100px;height:50px;" /></div>
````````````````````````````````
## alt option
```````````````````````````````` example
~~~{image} picture.png
:alt: description text
~~~
.
<div class="block-image"><img src="picture.png" alt="description text" /></div>
````````````````````````````````
## target option
```````````````````````````````` example
~~~{image} picture.png
:target: https://lepture.com
~~~
.
<a class="block-image" href="https://lepture.com"><img src="picture.png" /></a>
````````````````````````````````
## all options
```````````````````````````````` example
~~~{image} picture.png
:target: https://lepture.com
:alt: description
:align: left
:width: 100
:height: 50
~~~
.
<a class="block-image align-left" href="https://lepture.com"><img src="picture.png" alt="description" width="100" height="50" /></a>
````````````````````````````````
## ampersand in source
```````````````````````````````` example
~~~{image} https://example.com/picture.png?foo=qux&test=me
~~~
.
<div class="block-image"><img src="https://example.com/picture.png?foo=qux&test=me" /></div>
````````````````````````````````
## ampersand in target
```````````````````````````````` example
~~~{image} picture.png
:target: https://example.com/rickroll?a=1&b=2
~~~
.
<a class="block-image" href="https://example.com/rickroll?a=1&b=2"><img src="picture.png" /></a>
````````````````````````````````
mistune-3.1.3/tests/fixtures/fenced_toc.txt 0000664 0000000 0000000 00000007110 14766552020 0021055 0 ustar 00root root 0000000 0000000 # Table of Contents
## No TOC
```````````````````````````````` example
none
.
<p>none</p>
````````````````````````````````
```````````````````````````````` example
# H1
## H2
.
<h1>H1</h1>
<h2>H2</h2>
````````````````````````````````
## Simple TOC
```````````````````````````````` example
~~~{toc}
~~~
# H1
## H2
.
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a></li>
</ul>
</li>
</ul>
</details>
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
````````````````````````````````
## Invalid Option
```````````````````````````````` example
# H1
## H2
~~~{toc}
:max-level: s
~~~
.
<h1>H1</h1>
<h2>H2</h2>
<div class="error"><pre>"max-level" option MUST be integer</pre></div>
````````````````````````````````
```````````````````````````````` example
# H1
## H2
~~~{toc}
:max-level: 9
~~~
.
<h1>H1</h1>
<h2>H2</h2>
<div class="error"><pre>"max-level" option MUST be <= 3</pre></div>
````````````````````````````````
```````````````````````````````` example
# H1
## H2
~~~{toc}
:min-level: 2
:max-level: 1
~~~
.
<h1>H1</h1>
<h2>H2</h2>
<div class="error"><pre>"min-level" option MUST be less than "max-level" option</pre></div>
````````````````````````````````
## Complex
```````````````````````````````` example
# H1
## H2
### H3
#### H4
# H1 B
# H1 `C`
```{toc} Contents
```
.
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
<h3 id="toc_3">H3</h3>
<h4 id="toc_4">H4</h4>
<h1 id="toc_5">H1 B</h1>
<h1 id="toc_6">H1 <code>C</code></h1>
<details class="toc" open>
<summary>Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a>
<ul>
<li><a href="#toc_3">H3</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#toc_5">H1 B</a></li>
<li><a href="#toc_6">H1 C</a></li>
</ul>
</details>
````````````````````````````````
## Insane
```````````````````````````````` example
# H1
### H3
## H2
#### H4
### H3 B
# H1 B
```{toc}
```
.
<h1 id="toc_1">H1</h1>
<h3 id="toc_2">H3</h3>
<h2 id="toc_3">H2</h2>
<h4 id="toc_4">H4</h4>
<h3 id="toc_5">H3 B</h3>
<h1 id="toc_6">H1 B</h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H3</a></li>
<li><a href="#toc_3">H2</a>
<ul>
<li><a href="#toc_5">H3 B</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#toc_6">H1 B</a></li>
</ul>
</details>
````````````````````````````````
```````````````````````````````` example
### H3
## H2
# H1
```{toc}
```
.
<h3 id="toc_1">H3</h3>
<h2 id="toc_2">H2</h2>
<h1 id="toc_3">H1</h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H3</a></li>
<li><a href="#toc_2">H2</a></li>
<li><a href="#toc_3">H1</a></li>
</ul>
</details>
````````````````````````````````
## Link in Heading
```````````````````````````````` example
# [foo](/bar)
```{toc}
```
.
<h1 id="toc_1"><a href="/bar">foo</a></h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">foo</a></li>
</ul>
</details>
````````````````````````````````
## HTML in Heading
```````````````````````````````` example
# <em>H1</em>
```{toc}
```
.
<h1 id="toc_1"><em>H1</em></h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a></li>
</ul>
</details>
````````````````````````````````
## Collapse TOC
```````````````````````````````` example
```{toc}
:collapse:
```
# H1
## H2
.
<details class="toc">
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a></li>
</ul>
</li>
</ul>
</details>
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
````````````````````````````````
mistune-3.1.3/tests/fixtures/fix-commonmark.txt 0000664 0000000 0000000 00000003561 14766552020 0021721 0 ustar 00root root 0000000 0000000 Fix problems that commonmark has.
## Links
Links can't contain links.
```````````````````````````````` example
[<https://example.com>](/foo)
.
<p><a href="/foo"><https://example.com></a></p>
````````````````````````````````
```````````````````````````````` example
[<name@example.com>](/foo)
.
<p><a href="/foo"><name@example.com></a></p>
````````````````````````````````
## Emphasis
`<em>` doesn't contain `<em>`, `<strong>` doesn't contain `<strong>`.
```````````````````````````````` example
*_em_* __**strong**__ ______m______
.
<p><em>_em_</em> <strong>**strong**</strong> ______m______</p>
````````````````````````````````
### Non aggressive emphasis
```````````````````````````````` example
*a **b c* d**
.
<p><em>a **b c</em> d**</p>
````````````````````````````````
While CommonMark would render it into:
```
<p><em>a <em><em>b c</em> d</em></em></p>
```
```````````````````````````````` example
*a **b c* d**
.
<p><em>a **b c</em> d**</p>
````````````````````````````````
While CommonMark would render it into:
```
<p><em>a <em><em>b c</em> d</em></em></p>
```
What if the string is:
```````````````````````````````` example
*a **b c* d
.
<p><em>a **b c</em> d</p>
````````````````````````````````
CommonMark would still be a mess:
```
<p>*a *<em>b c</em> d</p>
```
## Max depth
```````````````````````````````` example
> > > > > > > > b
.
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<p>> > b</p>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
````````````````````````````````
```````````````````````````````` example
- a
- b
- c
- d
- e
- f
- g
- h
.
<ul>
<li>a<ul>
<li>b<ul>
<li>c<ul>
<li>d<ul>
<li>e<ul>
<li>f
- g
- h</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
</ul>
````````````````````````````````
mistune-3.1.3/tests/fixtures/footnotes.txt 0000664 0000000 0000000 00000001517 14766552020 0021011 0 ustar 00root root 0000000 0000000 # Footnotes
```````````````````````````````` example
none [^1]
.
<p>none [^1]</p>
````````````````````````````````
```````````````````````````````` example
oneline [^1]
[^1]: foo
.
<p>oneline <sup class="footnote-ref" id="fnref-1"><a href="#fn-1">1</a></sup></p>
<section class="footnotes">
<ol>
<li id="fn-1"><p>foo<a href="#fnref-1" class="footnote">↩</a></p></li>
</ol>
</section>
````````````````````````````````
```````````````````````````````` example
multiple lines [^1]
[^1]: foo
one
two
three
four
.
<p>multiple lines <sup class="footnote-ref" id="fnref-1"><a href="#fn-1">1</a></sup></p>
<pre><code>four</code></pre>
<section class="footnotes">
<ol>
<li id="fn-1"><p>foo</p>
<p>one</p>
<p>two</p>
<p>three<a href="#fnref-1" class="footnote">↩</a></p></li>
</ol>
</section>
````````````````````````````````
mistune-3.1.3/tests/fixtures/hook_toc.txt 0000664 0000000 0000000 00000003550 14766552020 0020575 0 ustar 00root root 0000000 0000000 # Table of Contents
## Simple TOC
```````````````````````````````` example
# H1
content
## H2
.
<h1 id="toc_1">H1</h1>
<p>content</p>
<h2 id="toc_2">H2</h2>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a></li>
</ul>
</li>
</ul>
````````````````````````````````
## Complex TOC
```````````````````````````````` example
# H1
## H2
### H3
#### H4
# H1 B
# H1 `C`
.
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
<h3 id="toc_3">H3</h3>
<h4>H4</h4>
<h1 id="toc_4">H1 B</h1>
<h1 id="toc_5">H1 <code>C</code></h1>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a>
<ul>
<li><a href="#toc_3">H3</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#toc_4">H1 B</a></li>
<li><a href="#toc_5">H1 C</a></li>
</ul>
````````````````````````````````
## Insane TOC
```````````````````````````````` example
# H1
### H3
## H2
#### H4
### H3 B
# H1 B
.
<h1 id="toc_1">H1</h1>
<h3 id="toc_2">H3</h3>
<h2 id="toc_3">H2</h2>
<h4>H4</h4>
<h3 id="toc_4">H3 B</h3>
<h1 id="toc_5">H1 B</h1>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H3</a></li>
<li><a href="#toc_3">H2</a>
<ul>
<li><a href="#toc_4">H3 B</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#toc_5">H1 B</a></li>
</ul>
````````````````````````````````
```````````````````````````````` example
### H3
## H2
# H1
.
<h3 id="toc_1">H3</h3>
<h2 id="toc_2">H2</h2>
<h1 id="toc_3">H1</h1>
<ul>
<li><a href="#toc_1">H3</a></li>
<li><a href="#toc_2">H2</a></li>
<li><a href="#toc_3">H1</a></li>
</ul>
````````````````````````````````
## Link in Heading
```````````````````````````````` example
# [foo](/bar)
.
<h1 id="toc_1"><a href="/bar">foo</a></h1>
<ul>
<li><a href="#toc_1">foo</a></li>
</ul>
````````````````````````````````
## HTML in Heading
```````````````````````````````` example
# <em>H1</em>
.
<h1 id="toc_1"><em>H1</em></h1>
<ul>
<li><a href="#toc_1">H1</a></li>
</ul>
````````````````````````````````
mistune-3.1.3/tests/fixtures/include/ 0000775 0000000 0000000 00000000000 14766552020 0017647 5 ustar 00root root 0000000 0000000 mistune-3.1.3/tests/fixtures/include/hello.md 0000664 0000000 0000000 00000000010 14766552020 0021263 0 ustar 00root root 0000000 0000000 > hello
mistune-3.1.3/tests/fixtures/include/hello.txt 0000664 0000000 0000000 00000000006 14766552020 0021507 0 ustar 00root root 0000000 0000000 hello
mistune-3.1.3/tests/fixtures/include/text.html 0000664 0000000 0000000 00000000030 14766552020 0021512 0 ustar 00root root 0000000 0000000 <div>include html</div>
mistune-3.1.3/tests/fixtures/include/text.md 0000664 0000000 0000000 00000000243 14766552020 0021154 0 ustar 00root root 0000000 0000000 # Include
.. include:: ./text.md
.. include:: ./not-exist.md
.. include:: ./text.html
:encoding: utf-8
.. include:: ./hello.md
.. include:: ../rst_toc.txt
mistune-3.1.3/tests/fixtures/insert.txt 0000664 0000000 0000000 00000002215 14766552020 0020271 0 ustar 00root root 0000000 0000000 # Insert
```````````````````````````````` example
^^insert me
.
<p>^^insert me</p>
````````````````````````````````
## normal insert
```````````````````````````````` example
^^insert me^^
.
<p><ins>insert me</ins></p>
````````````````````````````````
```````````````````````````````` example
foo ^^insert me^^
.
<p>foo <ins>insert me</ins></p>
````````````````````````````````
```````````````````````````````` example
^^insert me^^foo
.
<p><ins>insert me</ins>foo</p>
````````````````````````````````
```````````````````````````````` example
^^insert me^^^
.
<p>^^insert me^^^</p>
````````````````````````````````
## escape insert
```````````````````````````````` example
^^insert me\^^^
.
<p><ins>insert me^</ins></p>
````````````````````````````````
```````````````````````````````` example
^^insert \^\^ me^^
.
<p><ins>insert ^^ me</ins></p>
````````````````````````````````
## insert link
```````````````````````````````` example
^^insert [me^^](/)
.
<p><ins>insert [me</ins>](/)</p>
````````````````````````````````
```````````````````````````````` example
^^[hello](/)^^
.
<p><ins><a href="/">hello</a></ins></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/mark.txt 0000664 0000000 0000000 00000002162 14766552020 0017720 0 ustar 00root root 0000000 0000000 # Mark
```````````````````````````````` example
==mark me
.
<p>==mark me</p>
````````````````````````````````
## normal mark
```````````````````````````````` example
==mark me==
.
<p><mark>mark me</mark></p>
````````````````````````````````
```````````````````````````````` example
foo ==mark me==
.
<p>foo <mark>mark me</mark></p>
````````````````````````````````
```````````````````````````````` example
==mark me==foo
.
<p><mark>mark me</mark>foo</p>
````````````````````````````````
```````````````````````````````` example
==mark me===
.
<p>==mark me===</p>
````````````````````````````````
## escape mark
```````````````````````````````` example
==mark me\===
.
<p><mark>mark me=</mark></p>
````````````````````````````````
```````````````````````````````` example
==mark \=\= me==
.
<p><mark>mark == me</mark></p>
````````````````````````````````
## mark link
```````````````````````````````` example
==mark [me==](/)
.
<p><mark>mark [me</mark>](/)</p>
````````````````````````````````
```````````````````````````````` example
==[hello](/)==
.
<p><mark><a href="/">hello</a></mark></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/math.txt 0000664 0000000 0000000 00000002226 14766552020 0017720 0 ustar 00root root 0000000 0000000 # Math
## Block Math
```````````````````````````````` example
$$
.
<p>$$</p>
````````````````````````````````
```````````````````````````````` example
$$
\operatorname{ker} f=\{g\in G:f(g)=e_{H}\}{\mbox{.}}
$$
.
<div class="math">$$
\operatorname{ker} f=\{g\in G:f(g)=e_{H}\}{\mbox{.}}
$$</div>
````````````````````````````````
```````````````````````````````` example
$$
foo
$$
bar
.
<div class="math">$$
foo
$$</div>
<p>bar</p>
````````````````````````````````
```````````````````````````````` example
$$
foo
bar
$$
.
<div class="math">$$
foo
bar
$$</div>
````````````````````````````````
## Inline Math
```````````````````````````````` example
The homomorphism $f$ is injective if and only if its kernel is only the
singleton set $e_G$, because otherwise $\exists a,b\in G$
with $a\neq b$ such that $f(a)=f(b)$.
.
<p>The homomorphism <span class="math">\(f\)</span> is injective if and only if its kernel is only the
singleton set <span class="math">\(e_G\)</span>, because otherwise <span class="math">\(\exists a,b\in G\)</span>
with <span class="math">\(a\neq b\)</span> such that <span class="math">\(f(a)=f(b)\)</span>.</p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/renderer_markdown.txt 0000664 0000000 0000000 00000006761 14766552020 0022507 0 ustar 00root root 0000000 0000000 # MarkdownRenderer
## inline
```````````````````````````````` example
this is _em_, **strong**, and `code`
.
this is *em*, **strong**, and `code`
````````````````````````````````
## links
```````````````````````````````` example
[link], [link][], [text][link], [link](/foo), [link](/foo "title")
[link]: /url
.
[link][link], [link][link], [text][link], [link](/foo), [link](/foo "title")
[link]: /url
````````````````````````````````
```````````````````````````````` example
[link], [link](https://foo(bar "title")
[link]: /url "title"
.
[link][link], [link](<https://foo(bar> "title")
[link]: /url "title"
````````````````````````````````
```````````````````````````````` example
[https://lepture.com](https://lepture.com)
<https://lepture.com>
<demo@example.com> [demo@example.com](mailto:demo@example.com)
.
<https://lepture.com>
<https://lepture.com>
<demo@example.com> <demo@example.com>
````````````````````````````````
## images
```````````````````````````````` example
[link]: /url
![link], ![link][], ![alt][link]
.
![link][link], ![link][link], ![alt][link]
[link]: /url
````````````````````````````````
## linebreak
```````````````````````````````` example
foo\
bar
.
foo
bar
````````````````````````````````
## html
```````````````````````````````` example
inline html <a>text</a>
and block html
<div>hi</div>
.
inline html <a>text</a>
and block html
<div>hi</div>
````````````````````````````````
## heading
```````````````````````````````` example
# h1
## h2
### h3
#### h4
##### h5
###### h6
h1
==
.
# h1
## h2
### h3
#### h4
##### h5
###### h6
# h1
````````````````````````````````
## thematic break
```````````````````````````````` example
hi
***
.
hi
***
````````````````````````````````
## code
```````````````````````````````` example
start
def foo():
pass
end
.
start
```
def foo():
pass
```
end
````````````````````````````````
```````````````````````````````` example
start
```py
def foo():
pass
```
end
.
start
```py
def foo():
pass
```
end
````````````````````````````````
```````````````````````````````` example
indent code
markdown
```
fenced
.
indent code
~~~
markdown
```
fenced
~~~
````````````````````````````````
```````````````````````````````` example
indent code
markdown
~~~
fenced
.
indent code
```
markdown
~~~
fenced
```
````````````````````````````````
```````````````````````````````` example
indent code
markdown
```
fenced
~~~
.
indent code
````
markdown
```
fenced
~~~
````
````````````````````````````````
## quote
```````````````````````````````` example
> quote
.
> quote
````````````````````````````````
```````````````````````````````` example
hello
> quote
.
hello
> quote
````````````````````````````````
> quote
> quote
>
> continuation
.
> quote
> quote
>
> continuation
## list
```````````````````````````````` example
- list
+ list
.
- list
+ list
````````````````````````````````
```````````````````````````````` example
- item 1
item 2
.
- item 1
item 2
````````````````````````````````
```````````````````````````````` example
- item 1
item 2
- item 3
.
- item 1
item 2
- item 3
````````````````````````````````
```````````````````````````````` example
- item 1
1. item 2
.
- item 1
1. item 2
````````````````````````````````
```````````````````````````````` example
- item 1
2. item 2
.
- item 1
2. item 2
````````````````````````````````
```````````````````````````````` example
- list
-
.
- list
-
````````````````````````````````
mistune-3.1.3/tests/fixtures/renderer_rst.txt 0000664 0000000 0000000 00000005543 14766552020 0021472 0 ustar 00root root 0000000 0000000 # RSTRenderer
## inline
```````````````````````````````` example
this is _em_, **strong**, and `code`
.
this is *em*, **strong**, and ``code``
````````````````````````````````
```````````````````````````````` example
| escape |
.
\| escape \|
````````````````````````````````
## links
```````````````````````````````` example
this is [link][] and [link](/foo)
[link]: /url
.
this is `link </url>`__ and `link </foo>`__
````````````````````````````````
## images
```````````````````````````````` example
this is inline 
.
this is inline |img-0|
.. |img-0| image:: /foo
:alt: alt *text*
````````````````````````````````
```````````````````````````````` example
this is figure
.
this is figure
.. figure:: /foo
alt *text*
````````````````````````````````
```````````````````````````````` example
this is figure
.
this is figure
.. figure:: /foo
:alt: title
alt *text*
````````````````````````````````
## html
```````````````````````````````` example
ignore inline html <a>text</a>
but show block html
<div>hi</div>
.
ignore inline html text
but show block html
.. raw:: html
<div>hi</div>
````````````````````````````````
## line break
```````````````````````````````` example
hello
world
.
| hello
| world
````````````````````````````````
## heading
```````````````````````````````` example
# h1
## h2
### h3
#### h4
##### h5
###### h6
.
h1
==
h2
--
h3
~~
h4
^^
h5
""
h6
''
````````````````````````````````
## thematic break
```````````````````````````````` example
hi
***
.
hi
--------------
````````````````````````````````
## code
```````````````````````````````` example
start
def foo():
pass
end
.
start
::
def foo():
pass
end
````````````````````````````````
```````````````````````````````` example
start
```py
def foo():
pass
```
end
.
start
.. code:: py
def foo():
pass
end
````````````````````````````````
## quote
```````````````````````````````` example
> quote
.
quote
````````````````````````````````
```````````````````````````````` example
hello
> quote
.
hello
quote
````````````````````````````````
```````````````````````````````` example
> hello
> quote
.
hello
..
quote
````````````````````````````````
## list
```````````````````````````````` example
- list
+ list
.
- list
+ list
````````````````````````````````
```````````````````````````````` example
- item 1
item 2
.
- item 1 item 2
````````````````````````````````
```````````````````````````````` example
- item 1
item 2
- item 3
.
- item 1
item 2
- item 3
````````````````````````````````
```````````````````````````````` example
- item 1
1. item 2
.
- item 1
1. item 2
````````````````````````````````
```````````````````````````````` example
- item 1
1. item 2
.
- item 1
1. item 2
````````````````````````````````
mistune-3.1.3/tests/fixtures/rst_admonition.txt 0000664 0000000 0000000 00000001520 14766552020 0022014 0 ustar 00root root 0000000 0000000 # Admonition
```````````````````````````````` example
.. hello:: Warning
message
.
<div class="error"><pre>.. hello:: Warning
message
</pre></div>
````````````````````````````````
```````````````````````````````` example
.. note:: Warning
message
.
<section class="admonition note">
<p class="admonition-title">Warning</p>
<p>message</p>
</section>
````````````````````````````````
Test with code block.
```````````````````````````````` example
.. note::
print()
.
<section class="admonition note">
<p class="admonition-title">Note</p>
<pre><code>print()</code></pre>
</section>
````````````````````````````````
Test with no message.
```````````````````````````````` example
.. note:: Warning
.
<section class="admonition note">
<p class="admonition-title">Warning</p>
</section>
````````````````````````````````
mistune-3.1.3/tests/fixtures/rst_toc.txt 0000664 0000000 0000000 00000007073 14766552020 0020451 0 ustar 00root root 0000000 0000000 # Table of Contents
## No TOC
```````````````````````````````` example
none
.
<p>none</p>
````````````````````````````````
```````````````````````````````` example
# H1
## H2
.
<h1>H1</h1>
<h2>H2</h2>
````````````````````````````````
## Simple TOC
```````````````````````````````` example
.. toc::
# H1
## H2
.
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a></li>
</ul>
</li>
</ul>
</details>
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
````````````````````````````````
## Invalid Option
```````````````````````````````` example
# H1
## H2
.. toc::
:max-level: s
.
<h1>H1</h1>
<h2>H2</h2>
<div class="error"><pre>"max-level" option MUST be integer</pre></div>
````````````````````````````````
```````````````````````````````` example
# H1
## H2
.. toc::
:max-level: 9
.
<h1>H1</h1>
<h2>H2</h2>
<div class="error"><pre>"max-level" option MUST be <= 3</pre></div>
````````````````````````````````
```````````````````````````````` example
# H1
## H2
.. toc::
:min-level: 2
:max-level: 1
.
<h1>H1</h1>
<h2>H2</h2>
<div class="error"><pre>"min-level" option MUST be less than "max-level" option</pre></div>
````````````````````````````````
## Complex
```````````````````````````````` example
# H1
## H2
### H3
#### H4
# H1 B
# H1 `C`
.. toc:: Contents
:max-level: 3
.
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
<h3 id="toc_3">H3</h3>
<h4 id="toc_4">H4</h4>
<h1 id="toc_5">H1 B</h1>
<h1 id="toc_6">H1 <code>C</code></h1>
<details class="toc" open>
<summary>Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a>
<ul>
<li><a href="#toc_3">H3</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#toc_5">H1 B</a></li>
<li><a href="#toc_6">H1 C</a></li>
</ul>
</details>
````````````````````````````````
## Insane
```````````````````````````````` example
# H1
### H3
## H2
#### H4
### H3 B
# H1 B
.. toc::
.
<h1 id="toc_1">H1</h1>
<h3 id="toc_2">H3</h3>
<h2 id="toc_3">H2</h2>
<h4 id="toc_4">H4</h4>
<h3 id="toc_5">H3 B</h3>
<h1 id="toc_6">H1 B</h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H3</a></li>
<li><a href="#toc_3">H2</a>
<ul>
<li><a href="#toc_5">H3 B</a></li>
</ul>
</li>
</ul>
</li>
<li><a href="#toc_6">H1 B</a></li>
</ul>
</details>
````````````````````````````````
```````````````````````````````` example
### H3
## H2
# H1
.. toc::
.
<h3 id="toc_1">H3</h3>
<h2 id="toc_2">H2</h2>
<h1 id="toc_3">H1</h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H3</a></li>
<li><a href="#toc_2">H2</a></li>
<li><a href="#toc_3">H1</a></li>
</ul>
</details>
````````````````````````````````
## Link in Heading
```````````````````````````````` example
# [foo](/bar)
.. toc::
.
<h1 id="toc_1"><a href="/bar">foo</a></h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">foo</a></li>
</ul>
</details>
````````````````````````````````
## HTML in Heading
```````````````````````````````` example
# <em>H1</em>
.. toc::
.
<h1 id="toc_1"><em>H1</em></h1>
<details class="toc" open>
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a></li>
</ul>
</details>
````````````````````````````````
## Collapse TOC
```````````````````````````````` example
.. toc::
:collapse:
# H1
## H2
.
<details class="toc">
<summary>Table of Contents</summary>
<ul>
<li><a href="#toc_1">H1</a>
<ul>
<li><a href="#toc_2">H2</a></li>
</ul>
</li>
</ul>
</details>
<h1 id="toc_1">H1</h1>
<h2 id="toc_2">H2</h2>
````````````````````````````````
mistune-3.1.3/tests/fixtures/ruby.txt 0000664 0000000 0000000 00000003415 14766552020 0017751 0 ustar 00root root 0000000 0000000 # Ruby
## ruby without link
```````````````````````````````` example
[漢字(ㄏㄢˋㄗˋ)]
.
<p><ruby>漢字<rt>ㄏㄢˋㄗˋ</rt></ruby></p>
````````````````````````````````
```````````````````````````````` example
[漢(ㄏㄢˋ)字(ㄗˋ)]
.
<p><ruby>漢<rt>ㄏㄢˋ</rt></ruby><ruby>字<rt>ㄗˋ</rt></ruby></p>
````````````````````````````````
```````````````````````````````` example
[漢字(ㄏㄢˋㄗˋ)][]
.
<p><ruby>漢字<rt>ㄏㄢˋㄗˋ</rt></ruby>[]</p>
````````````````````````````````
```````````````````````````````` example
[漢字(ㄏㄢˋㄗˋ)][link]
.
<p><ruby>漢字<rt>ㄏㄢˋㄗˋ</rt></ruby>[link]</p>
````````````````````````````````
## ruby with link
```````````````````````````````` example
[link]: /url
[漢字(ㄏㄢˋㄗˋ)][link]
.
<p><a href="/url"><ruby>漢字<rt>ㄏㄢˋㄗˋ</rt></ruby></a></p>
````````````````````````````````
```````````````````````````````` example
[漢字(ㄏㄢˋㄗˋ)]()
.
<p><a href=""><ruby>漢字<rt>ㄏㄢˋㄗˋ</rt></ruby></a></p>
````````````````````````````````
```````````````````````````````` example
[漢字(ㄏㄢˋㄗˋ)](/url)
.
<p><a href="/url"><ruby>漢字<rt>ㄏㄢˋㄗˋ</rt></ruby></a></p>
````````````````````````````````
## ruby splits
```````````````````````````````` example
[漢(かん)][字(じ)]
.
<p><ruby>漢<rt>かん</rt></ruby><ruby>字<rt>じ</rt></ruby></p>
````````````````````````````````
```````````````````````````````` example
[[漢(かん)][字(じ)]](https://jisho.org/search/漢字)
.
<p><a href="https://jisho.org/search/%E6%BC%A2%E5%AD%97"><ruby>漢<rt>かん</rt></ruby><ruby>字<rt>じ</rt></ruby></a></p>
````````````````````````````````
```````````````````````````````` example
[汉字(hàn zì)]
.
<p><ruby>汉字<rt>hàn zì</rt></ruby></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/spoiler.txt 0000664 0000000 0000000 00000002202 14766552020 0020436 0 ustar 00root root 0000000 0000000 # Spoiler
## Block spoiler
```````````````````````````````` example
>! hi
.
<div class="spoiler">
<p>hi</p>
</div>
````````````````````````````````
```````````````````````````````` example
>! not
> spoiler
.
<blockquote>
<p>! not
spoiler</p>
</blockquote>
````````````````````````````````
```````````````````````````````` example
>! multiple
>! lines
.
<div class="spoiler">
<p>multiple
lines</p>
</div>
````````````````````````````````
```````````````````````````````` example
>! foo
>!
>! bar
.
<div class="spoiler">
<p>foo</p>
<p>bar</p>
</div>
````````````````````````````````
```````````````````````````````` example
>! foo
>
>! bar
.
<blockquote>
<p>! foo</p>
<p>! bar</p>
</blockquote>
````````````````````````````````
## Inline spoiler
```````````````````````````````` example
hi >! hide !<
.
<p>hi <span class="spoiler">hide</span></p>
````````````````````````````````
```````````````````````````````` example
hi >!hide !<
.
<p>hi <span class="spoiler">hide</span></p>
````````````````````````````````
```````````````````````````````` example
hi >!hide!<
.
<p>hi <span class="spoiler">hide</span></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/strikethrough.txt 0000664 0000000 0000000 00000001566 14766552020 0021677 0 ustar 00root root 0000000 0000000 # Strikethrough
## strikethrough
```````````````````````````````` example
~~delete me
.
<p>~~delete me</p>
````````````````````````````````
```````````````````````````````` example
~~delete me~~
.
<p><del>delete me</del></p>
````````````````````````````````
```````````````````````````````` example
~~delete me~~~
.
<p>~~delete me~~~</p>
````````````````````````````````
```````````````````````````````` example
~~delete me\~~~
.
<p><del>delete me~</del></p>
````````````````````````````````
```````````````````````````````` example
~~delete \~\~ me~~
.
<p><del>delete ~~ me</del></p>
````````````````````````````````
```````````````````````````````` example
~~delete [me~~](/)
.
<p><del>delete [me</del>](/)</p>
````````````````````````````````
```````````````````````````````` example
~~[hello](/)~~
.
<p><del><a href="/">hello</a></del></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/subscript.txt 0000664 0000000 0000000 00000001011 14766552020 0020774 0 ustar 00root root 0000000 0000000 # Subscript
```````````````````````````````` example
CH~3~CH~2~OH
.
<p>CH<sub>3</sub>CH<sub>2</sub>OH</p>
````````````````````````````````
```````````````````````````````` example
text~a\ subscript~
.
<p>text<sub>a subscript</sub></p>
````````````````````````````````
```````````````````````````````` example
text~a subscript~
.
<p>text~a subscript~</p>
````````````````````````````````
```````````````````````````````` example
text~a\~subscript~
.
<p>text<sub>a~subscript</sub></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/superscript.txt 0000664 0000000 0000000 00000001013 14766552020 0021343 0 ustar 00root root 0000000 0000000 # Superscript
```````````````````````````````` example
CH^3^CH^2^OH
.
<p>CH<sup>3</sup>CH<sup>2</sup>OH</p>
````````````````````````````````
```````````````````````````````` example
text^a\ supscript^
.
<p>text<sup>a supscript</sup></p>
````````````````````````````````
```````````````````````````````` example
text^a supscript^
.
<p>text^a supscript^</p>
````````````````````````````````
```````````````````````````````` example
text^a\^supscript^
.
<p>text<sup>a^supscript</sup></p>
````````````````````````````````
mistune-3.1.3/tests/fixtures/table.txt 0000664 0000000 0000000 00000010046 14766552020 0020055 0 ustar 00root root 0000000 0000000 # Table in Markdown
https://michelf.ca/projects/php-markdown/extra/#table
## nptable
```````````````````````````````` example
First Header | Second Header
------------- | -------------
Content Cell | Content Cell
Content Cell | Content Cell
.
<table>
<thead>
<tr>
<th>First Header</th>
<th>Second Header</th>
</tr>
</thead>
<tbody>
<tr>
<td>Content Cell</td>
<td>Content Cell</td>
</tr>
<tr>
<td>Content Cell</td>
<td>Content Cell</td>
</tr>
</tbody>
</table>
````````````````````````````````
## table
```````````````````````````````` example
| First Header | Second Header |
| ------------- | ------------- |
| Content Cell | |
| Content Cell | Content Cell |
.
<table>
<thead>
<tr>
<th>First Header</th>
<th>Second Header</th>
</tr>
</thead>
<tbody>
<tr>
<td>Content Cell</td>
<td></td>
</tr>
<tr>
<td>Content Cell</td>
<td>Content Cell</td>
</tr>
</tbody>
</table>
````````````````````````````````
```````````````````````````````` example
| Command | Description |
| --- | --- |
| git status | List all new or modified files |
| git diff | Show file differences that haven't been staged |
.
<table>
<thead>
<tr>
<th>Command</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>git status</td>
<td>List all new or modified files</td>
</tr>
<tr>
<td>git diff</td>
<td>Show file differences that haven't been staged</td>
</tr>
</tbody>
</table>
````````````````````````````````
## align table
```````````````````````````````` example
Left | Center | Right
:---- | :--------: | ------:
a | b | c
.
<table>
<thead>
<tr>
<th style="text-align:left">Left</th>
<th style="text-align:center">Center</th>
<th style="text-align:right">Right</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left">a</td>
<td style="text-align:center">b</td>
<td style="text-align:right">c</td>
</tr>
</tbody>
</table>
````````````````````````````````
```````````````````````````````` example
| Left | Center | Right |
| :--- | :----: | ----: |
| a | b | c |
.
<table>
<thead>
<tr>
<th style="text-align:left">Left</th>
<th style="text-align:center">Center</th>
<th style="text-align:right">Right</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align:left">a</td>
<td style="text-align:center">b</td>
<td style="text-align:right">c</td>
</tr>
</tbody>
</table>
````````````````````````````````
## Misc Table
```````````````````````````````` example
| A | |
| - | |
| a | b |
.
<table>
<thead>
<tr>
<th>A</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>a</td>
<td>b</td>
</tr>
</tbody>
</table>
````````````````````````````````
```````````````````````````````` example
A |
- |
a | b
.
<table>
<thead>
<tr>
<th>A</th>
<th></th>
</tr>
</thead>
<tbody>
<tr>
<td>a</td>
<td>b</td>
</tr>
</tbody>
</table>
````````````````````````````````
```````````````````````````````` example
| Foo | Bar |
|-----|-----|
| boo | baz |
| faz | |
.
<table>
<thead>
<tr>
<th>Foo</th>
<th>Bar</th>
</tr>
</thead>
<tbody>
<tr>
<td>boo</td>
<td>baz</td>
</tr>
<tr>
<td>faz</td>
<td></td>
</tr>
</tbody>
</table>
````````````````````````````````
## Mismatch length
```````````````````````````````` example
| First Header |
| ------------- | ------------- |
| Content Cell | |
| Content Cell | Content Cell |
.
<p>| First Header |
| ------------- | ------------- |
| Content Cell | |
| Content Cell | Content Cell |</p>
````````````````````````````````
```````````````````````````````` example
| First Header | Second Header |
| ------------- | ------------- |
| Content Cell |
| Content Cell | Content Cell |
.
<p>| First Header | Second Header |
| ------------- | ------------- |
| Content Cell |
| Content Cell | Content Cell |</p>
````````````````````````````````
```````````````````````````````` example
A |
- | - |
a | b | c
.
<p>A |</p>
<ul>
<li>| - |
a | b | c</li>
</ul>
````````````````````````````````
```````````````````````````````` example
A | B | C
- | - | -
a | b
.
<p>A | B | C</p>
<ul>
<li>| - | -
a | b</li>
</ul>
````````````````````````````````
mistune-3.1.3/tests/fixtures/task_lists.txt 0000664 0000000 0000000 00000006040 14766552020 0021145 0 ustar 00root root 0000000 0000000 # Task Lists
```````````````````````````````` example
- [ ] foo
- [x] bar
- [X] baz
.
<ul>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>foo</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled checked/>bar</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled checked/>baz</li>
</ul>
````````````````````````````````
```````````````````````````````` example
- foo
- [ ] bar
.
<ul>
<li>foo</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>bar</li>
</ul>
````````````````````````````````
```````````````````````````````` example
- foo
- [ ] bar
- [x] baz
text
.
<ul>
<li><p>foo</p>
</li>
<li class="task-list-item"><p><input class="task-list-item-checkbox" type="checkbox" disabled/>bar</p>
</li>
<li class="task-list-item"><p><input class="task-list-item-checkbox" type="checkbox" disabled checked/>baz</p>
<p>text</p>
</li>
</ul>
````````````````````````````````
```````````````````````````````` example
1. [ ] foo
2. [x] bar
3. [X] baz
.
<ol>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>foo</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled checked/>bar</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled checked/>baz</li>
</ol>
````````````````````````````````
```````````````````````````````` example
- [ ] Task list item
over two lines
.
<ul>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>Task list item
over two lines</li>
</ul>
````````````````````````````````
```````````````````````````````` example
- [ ] foo
- [x] bar
- [ ] baz
.
<ul>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>foo<ul>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled checked/>bar</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>baz</li>
</ul>
</li>
</ul>
````````````````````````````````
```````````````````````````````` example
1. [ ] foo
1. [ ] bar
2. [ ] baz
.
<ol>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>foo<ol>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>bar</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>baz</li>
</ol>
</li>
</ol>
````````````````````````````````
```````````````````````````````` example
> - [ ] foo
> - [x] bar
> - [ ] baz
.
<blockquote>
<ul>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>foo<ul>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled checked/>bar</li>
<li class="task-list-item"><input class="task-list-item-checkbox" type="checkbox" disabled/>baz</li>
</ul>
</li>
</ul>
</blockquote>
```````````````````````````````` mistune-3.1.3/tests/fixtures/url.txt 0000664 0000000 0000000 00000001022 14766552020 0017562 0 ustar 00root root 0000000 0000000 # url plugin
```````````````````````````````` example
visit https://lepture.com/
.
<p>visit <a href="https://lepture.com/">https://lepture.com/</a></p>
````````````````````````````````
```````````````````````````````` example
visit [https://lepture.com/](/foo)
.
<p>visit <a href="/foo">https://lepture.com/</a></p>
````````````````````````````````
```````````````````````````````` example
visit <a href="/foo">https://lepture.com/</a>
.
<p>visit <a href="/foo">https://lepture.com/</a></p>
````````````````````````````````
mistune-3.1.3/tests/test_commonmark.py 0000664 0000000 0000000 00000004222 14766552020 0020127 0 ustar 00root root 0000000 0000000 import mistune
from tests import BaseTestCase, normalize_html
DIFF_CASES = {
"setext_headings_093",
"html_blocks_191", # mistune keeps \n
"images_573", # image can not be in image
"links_495",
"links_517", # aggressive link group
"links_518",
"links_519",
"links_531",
"links_532",
}
IGNORE_CASES = {
# we don't support link title in (title)
"links_496",
"links_504",
# we don't support flanking delimiter run
"emphasis_and_strong_emphasis_352",
"emphasis_and_strong_emphasis_367",
"emphasis_and_strong_emphasis_368",
"emphasis_and_strong_emphasis_372",
"emphasis_and_strong_emphasis_379",
"emphasis_and_strong_emphasis_388",
"emphasis_and_strong_emphasis_391",
"emphasis_and_strong_emphasis_406",
"emphasis_and_strong_emphasis_407",
"emphasis_and_strong_emphasis_408",
"emphasis_and_strong_emphasis_412",
"emphasis_and_strong_emphasis_413",
"emphasis_and_strong_emphasis_414",
"emphasis_and_strong_emphasis_416",
"emphasis_and_strong_emphasis_417",
"emphasis_and_strong_emphasis_418",
"emphasis_and_strong_emphasis_424",
"emphasis_and_strong_emphasis_425",
"emphasis_and_strong_emphasis_426",
"emphasis_and_strong_emphasis_429",
"emphasis_and_strong_emphasis_430",
"emphasis_and_strong_emphasis_431",
"emphasis_and_strong_emphasis_460",
"emphasis_and_strong_emphasis_467",
"emphasis_and_strong_emphasis_470",
"emphasis_and_strong_emphasis_471",
"emphasis_and_strong_emphasis_477",
"emphasis_and_strong_emphasis_478",
}
for i in range(441, 447):
IGNORE_CASES.add("emphasis_and_strong_emphasis_" + str(i))
for i in range(453, 459):
IGNORE_CASES.add("emphasis_and_strong_emphasis_" + str(i))
for i in range(462, 466):
IGNORE_CASES.add("emphasis_and_strong_emphasis_" + str(i))
class TestCommonMark(BaseTestCase):
@classmethod
def ignore_case(cls, n):
return n in IGNORE_CASES or n in DIFF_CASES
def assert_case(self, n, text, html):
result = mistune.html(text)
self.assertEqual(normalize_html(result), normalize_html(html))
TestCommonMark.load_fixtures("commonmark.json")
mistune-3.1.3/tests/test_directives.py 0000664 0000000 0000000 00000005612 14766552020 0020131 0 ustar 00root root 0000000 0000000 import os
from mistune import create_markdown
from mistune.directives import (
RSTDirective,
FencedDirective,
Admonition,
TableOfContents,
Include,
Image,
Figure,
)
from tests import BaseTestCase
from tests.fixtures import ROOT
def load_directive_test(filename, directive, cls):
class TestDirective(BaseTestCase):
@staticmethod
def parse(text):
md = create_markdown(
escape=False,
plugins=[cls([directive])],
)
html = md(text)
return html
TestDirective.load_fixtures(filename + ".txt")
globals()["TestDirective_" + filename] = TestDirective
load_directive_test("rst_admonition", Admonition(), RSTDirective)
load_directive_test("rst_toc", TableOfContents(), RSTDirective)
load_directive_test("fenced_admonition", Admonition(), FencedDirective)
load_directive_test("fenced_toc", TableOfContents(), FencedDirective)
load_directive_test("fenced_image", Image(), FencedDirective)
load_directive_test("fenced_figure", Figure(), FencedDirective)
class CustomizeTableOfContents(TableOfContents):
def generate_heading_id(self, token, i):
return "t-" + str(i + 1)
class TestCustomizeToc(BaseTestCase):
def test_rst_toc(self):
md = create_markdown(
escape=False,
plugins=[
RSTDirective([CustomizeTableOfContents()]),
],
)
html = md("# h1\n\n.. toc::\n")
self.assertIn('<h1 id="t-1">h1</h1>', html)
self.assertIn('<a href="#t-1">h1</a>', html)
def test_fenced_toc(self):
md = create_markdown(
escape=False,
plugins=[
FencedDirective([CustomizeTableOfContents()]),
],
)
html = md("# h1\n\n```{toc}\n```\n")
self.assertIn('<h1 id="t-1">h1</h1>', html)
self.assertIn('<a href="#t-1">h1</a>', html)
def test_colon_fenced_toc(self):
md = create_markdown(
escape=False,
plugins=[
FencedDirective([CustomizeTableOfContents()], ":"),
],
)
html = md("# h1\n\n:::{toc}\n:::\n")
self.assertIn('<h1 id="t-1">h1</h1>', html)
self.assertIn('<a href="#t-1">h1</a>', html)
class TestDirectiveInclude(BaseTestCase):
md = create_markdown(escape=False, plugins=[RSTDirective([Include()])]) # type: ignore[list-item]
def test_html_include(self):
html = self.md.read(os.path.join(ROOT, "include/text.md"))[0]
self.assertIn("Could not include self", html)
self.assertIn("Could not find file", html)
self.assertIn("<div>include html</div>", html)
self.assertIn("<blockquote>", html)
self.assertIn("# Table of Contents", html)
def test_include_missing_source(self):
s = ".. include:: foo.txt"
html = self.md(s)
self.assertIn("Missing source file", html)
mistune-3.1.3/tests/test_hooks.py 0000664 0000000 0000000 00000001570 14766552020 0017112 0 ustar 00root root 0000000 0000000 import os
from mistune import create_markdown
from mistune.toc import add_toc_hook, render_toc_ul
from tests import BaseTestCase
class TestTocHook(BaseTestCase):
@staticmethod
def parse(text):
md = create_markdown(escape=False)
add_toc_hook(md)
html, state = md.parse(text)
result = html + render_toc_ul(state.env["toc_items"])
return result
def test_customize_heading_id_func(self):
def heading_id(token, i):
return "t-" + str(i + 1)
md = create_markdown(escape=False)
add_toc_hook(md, heading_id=heading_id)
html = md("# h1")
self.assertEqual(html, '<h1 id="t-1">h1</h1>\n')
def test_render_empty_toc(self):
self.assertEqual(render_toc_ul([]), "")
self.assertEqual(render_toc_ul(filter(lambda _: False, [])), "")
TestTocHook.load_fixtures("hook_toc.txt")
mistune-3.1.3/tests/test_misc.py 0000664 0000000 0000000 00000011325 14766552020 0016721 0 ustar 00root root 0000000 0000000 import mistune
from unittest import TestCase
class TestMiscCases(TestCase):
def test_none(self):
self.assertEqual(mistune.html(None), "")
def test_before_parse_hooks(self):
def _add_name(md, state):
state.env["name"] = "test"
md = mistune.create_markdown()
md.before_parse_hooks.append(_add_name)
state = md.block.state_cls()
md.parse("", state)
self.assertEqual(state.env["name"], "test")
def test_hard_wrap(self):
md = mistune.create_markdown(escape=False, hard_wrap=True)
result = md("foo\nbar")
expected = "<p>foo<br />\nbar</p>"
self.assertEqual(result.strip(), expected)
md = mistune.create_markdown(escape=False, hard_wrap=True, plugins=["speedup"])
result = md("foo\nbar")
self.assertEqual(result.strip(), expected)
def test_escape_html(self):
md = mistune.create_markdown(escape=True)
result = md("<div>1</div>")
expected = "<p><div>1</div></p>"
self.assertEqual(result.strip(), expected)
result = md("<em>1</em>")
expected = "<p><em>1</em></p>"
self.assertEqual(result.strip(), expected)
def test_harmful_links(self):
result = mistune.html("[h](javAscript:alert)")
expected = '<p><a href="#harmful-link">h</a></p>'
self.assertEqual(result.strip(), expected)
def test_ref_link(self):
result = mistune.html("[link][h]\n\n[h]: /foo")
expected = '<p><a href="/foo">link</a></p>'
self.assertEqual(result.strip(), expected)
def test_allow_harmful_protocols(self):
renderer = mistune.HTMLRenderer(allow_harmful_protocols=True)
md = mistune.Markdown(renderer)
result = md("[h](javascript:alert)")
expected = '<p><a href="javascript:alert">h</a></p>'
self.assertEqual(result.strip(), expected)
def test_allow_data_protocols(self):
renderer = mistune.HTMLRenderer(allow_harmful_protocols=["data:"])
md = mistune.Markdown(renderer)
result = md("[h](data:alert)")
expected = '<p><a href="data:alert">h</a></p>'
self.assertEqual(result.strip(), expected)
def test_use_plugin(self):
from mistune.plugins.url import url
md = mistune.Markdown(mistune.HTMLRenderer())
md.use(url)
def test_markdown_func(self):
result = mistune.markdown("**b**")
expected = "<p><strong>b</strong></p>\n"
self.assertEqual(result, expected)
# trigger to use cached parser
result = mistune.markdown("**b**")
self.assertEqual(result, expected)
def test_ast_output(self):
md = mistune.create_markdown(escape=False, renderer=None)
text = '# h1\n\nfoo **bar**\n\n`&<>"`'
result = md(text)
expected = [
{
"type": "heading",
"children": [{"type": "text", "raw": "h1"}],
"attrs": {"level": 1},
"style": "atx",
},
{"type": "blank_line"},
{
"type": "paragraph",
"children": [
{"type": "text", "raw": "foo "},
{"type": "strong", "children": [{"type": "text", "raw": "bar"}]},
],
},
{"type": "blank_line"},
{
"type": "paragraph",
"children": [
{"type": "codespan", "raw": '&<>"'},
],
},
]
self.assertEqual(result, expected)
def test_ast_url(self):
md = mistune.create_markdown(escape=False, renderer=None)
label = 'hi &<>"'
url = "https://example.com/foo?a=1&b=2"
text = "[{}]({})".format(label, url)
result = md(text)
expected = [
{
"type": "paragraph",
"children": [
{
"type": "link",
"children": [{"type": "text", "raw": label}],
"attrs": {"url": url},
},
],
},
]
self.assertEqual(result, expected)
def test_emsp(self):
md = mistune.create_markdown(escape=False, hard_wrap=True)
result = md("\u2003\u2003foo\nbar\n\n\u2003\u2003foobar")
expected = "<p>\u2003\u2003foo<br />\nbar</p>\n<p>\u2003\u2003foobar</p>"
self.assertEqual(result.strip(), expected)
def test_html_tag_text_following_list(self):
md = mistune.create_markdown(escape=False, hard_wrap=True)
result = md("foo\n- bar\n\ntable")
expected = "<p>foo</p>\n<ul>\n<li>bar</li>\n</ul>\n<p>table</p>"
self.assertEqual(result.strip(), expected)
mistune-3.1.3/tests/test_plugins.py 0000664 0000000 0000000 00000004350 14766552020 0017447 0 ustar 00root root 0000000 0000000 from mistune import create_markdown
from mistune.plugins.table import table_in_list, table_in_quote
from mistune.plugins.math import math_in_list, math_in_quote
from tests import BaseTestCase
def load_plugin(plugin_name):
md1 = create_markdown(escape=False, plugins=[plugin_name])
md2 = create_markdown(escape=False, plugins=[plugin_name, "speedup"])
class TestPlugin1(BaseTestCase):
parse = md1
class TestPlugin2(BaseTestCase):
parse = md2
TestPlugin1.load_fixtures(plugin_name + ".txt")
TestPlugin2.load_fixtures(plugin_name + ".txt")
globals()["TestPlugin1_" + plugin_name] = TestPlugin1
globals()["TestPlugin2_" + plugin_name] = TestPlugin2
load_plugin("url")
load_plugin("strikethrough")
load_plugin("mark")
load_plugin("insert")
load_plugin("superscript")
load_plugin("subscript")
load_plugin("task_lists")
load_plugin("table")
load_plugin("def_list")
load_plugin("footnotes")
load_plugin("abbr")
load_plugin("math")
load_plugin("ruby")
load_plugin("spoiler")
class TestExtraPlugins(BaseTestCase):
def test_table_in_list(self):
text = """- Cell | Cell\n ---- | ----\n 1 | 2\n"""
md1 = create_markdown(escape=False)
md2 = create_markdown(escape=False, plugins=["table", table_in_list])
self.assertNotIn("<table>", md1(text))
self.assertIn("<table>", md2(text))
def test_table_in_quote(self):
text = """> Cell | Cell\n> ---- | ----\n> 1 | 2\n"""
md1 = create_markdown(escape=False)
md2 = create_markdown(escape=False, plugins=["table", table_in_quote])
self.assertNotIn("<table>", md1(text))
self.assertIn("<table>", md2(text))
def test_math_in_list(self):
text = """- $$\n foo\n $$\n"""
md1 = create_markdown(escape=False)
md2 = create_markdown(escape=False, plugins=["math", math_in_list])
self.assertNotIn('class="math"', md1(text))
self.assertIn('class="math"', md2(text))
def test_math_in_quote(self):
text = """> $$\n> foo\n> $$\n"""
md1 = create_markdown(escape=False)
md2 = create_markdown(escape=False, plugins=["math", math_in_quote])
self.assertNotIn('class="math"', md1(text))
self.assertIn('class="math"', md2(text))
mistune-3.1.3/tests/test_renderers.py 0000664 0000000 0000000 00000000764 14766552020 0017764 0 ustar 00root root 0000000 0000000 from mistune import create_markdown
from mistune.renderers.rst import RSTRenderer
from mistune.renderers.markdown import MarkdownRenderer
from tests import BaseTestCase
def load_renderer(renderer):
class TestRenderer(BaseTestCase):
parse = create_markdown(renderer=renderer)
name = renderer.NAME
TestRenderer.load_fixtures("renderer_" + name + ".txt")
globals()["TestRenderer" + name.title()] = TestRenderer
load_renderer(RSTRenderer())
load_renderer(MarkdownRenderer())
mistune-3.1.3/tests/test_syntax.py 0000664 0000000 0000000 00000000526 14766552020 0017315 0 ustar 00root root 0000000 0000000 import mistune
from tests import BaseTestCase, normalize_html
class TestSyntax(BaseTestCase):
def assert_case(self, n, text, html):
result = mistune.html(text)
self.assertEqual(normalize_html(result), normalize_html(html))
TestSyntax.load_fixtures("fix-commonmark.txt")
TestSyntax.load_fixtures("diff-commonmark.txt")
**NOTE: This is the re-designed v3 of mistune.**
Looking for old Mistune? Switch branch to:
- v1
- v2
## Paid plugins
You can ask me to create a custom mistune plugin or directive for your needs with GitHub sponsor
[one time tier (Mistune enhance)](https://github.com/sponsors/lepture/sponsorships?tier_id=220664)
## Sponsors