From 7be355d0044894af5caf6a3921581c01c4fe02be Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Thu, 12 Jan 2023 10:18:20 -0300
Subject: [PATCH 01/22] at least not __all__ tests are failing

---
 m2r2.py  | 188 +++++++++++++++++++++++++++++--------------------------
 setup.py |   7 +--
 2 files changed, 100 insertions(+), 95 deletions(-)

diff --git a/m2r2.py b/m2r2.py
index e78d969..1e04957 100644
--- a/m2r2.py
+++ b/m2r2.py
@@ -6,8 +6,9 @@
 import os
 import os.path
 import re
-import sys
 from argparse import ArgumentParser, Namespace
+from typing import Any, Dict, Match, Tuple
+from urllib.parse import urlparse
 
 import mistune
 from docutils import io, nodes, statemachine, utils
@@ -17,14 +18,10 @@
 
 __version__ = get_distribution("m2r2").version
 
-if sys.version_info < (3,):
-    from codecs import open as _open
-
-    from urlparse import urlparse
-else:
-    _open = open
-    from urllib.parse import urlparse
 
+State = Dict[str, Any]
+Token = Dict[str, Any]
+Element = Tuple[str, ...]
 
 _is_sphinx = False
 prolog = """\
@@ -79,127 +76,125 @@ def parse_options():
     parser.parse_known_args(namespace=options)
 
 
-class RestBlockGrammar(mistune.BlockGrammar):
-    directive = re.compile(
+class RestBlockParser(mistune.BlockParser):
+    DIRECTIVE = re.compile(
         r"^( *\.\..*?)\n(?=\S)",
         re.DOTALL | re.MULTILINE,
     )
-    oneline_directive = re.compile(
+    ONELINE_DIRECTIVE = re.compile(
         r"^( *\.\..*?)$",
         re.DOTALL | re.MULTILINE,
     )
-    rest_code_block = re.compile(
+    REST_CODE_BLOCK = re.compile(
         r"^::\s*$",
         re.DOTALL | re.MULTILINE,
     )
+    RULE_NAMES = mistune.BlockParser.RULE_NAMES + (
+        "directive",
+        "oneline_directive",
+        "rest_code_block",
+    )
 
-
-class RestBlockLexer(mistune.BlockLexer):
-    grammar_class = RestBlockGrammar
-    default_rules = [
+    RULE_NAMES = (
         "directive",
         "oneline_directive",
         "rest_code_block",
-    ] + mistune.BlockLexer.default_rules
+    ) + mistune.BlockParser.RULE_NAMES
 
-    def parse_directive(self, m):
-        self.tokens.append({"type": "directive", "text": m.group(1)})
+    def parse_directive(self, match: Match, state: State) -> Token:
+        return {"type": "directive", "text": match.group(1)}
 
-    def parse_oneline_directive(self, m):
+    def parse_oneline_directive(self, match: Match, state: State) -> Token:
         # reuse directive output
-        self.tokens.append({"type": "directive", "text": m.group(1)})
+        return {"type": "directive", "text": match.group(1)}
 
-    def parse_rest_code_block(self, m):
-        self.tokens.append({"type": "rest_code_block"})
+    def parse_rest_code_block(self, match: Match, state: State) -> Token:
+        return {"type": "rest_code_block", "text": ""}
 
 
-class RestInlineGrammar(mistune.InlineGrammar):
-    image_link = re.compile(
+class RestInlineParser(mistune.InlineParser):
+    IMAGE_LINK = re.compile(
         r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
     )
-    rest_role = re.compile(r":.*?:`.*?`|`[^`]+`:.*?:")
-    rest_link = re.compile(r"`[^`]*?`_")
-    inline_math = re.compile(r"`\$(.*?)\$`")
-    eol_literal_marker = re.compile(r"(\s+)?::\s*$")
+    REST_ROLE = re.compile(r":.*?:`.*?`|`[^`]+`:.*?:")
+    REST_LINK = re.compile(r"`[^`]*?`_")
+    INLINE_MATH = re.compile(r"`\$(.*?)\$`")
+    EOL_LITERAL_MARKER = re.compile(r"(\s+)?::\s*$")
     # add colon and space as special text
-    text = re.compile(r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)")
+    TEXT = re.compile(r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)")
     # __word__ or **word**
-    double_emphasis = re.compile(r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)")
+    DOUBLE_EMPHASIS = re.compile(r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)")
     # _word_ or *word*
-    emphasis = re.compile(
+    EMPHASIS = re.compile(
         r"^\b_((?:__|[^_])+?)_\b"  # _word_
         r"|"
         r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
     )
 
-    def no_underscore_emphasis(self):
-        self.double_emphasis = re.compile(
-            r"^\*{2}(?P<text>[\s\S]+?)\*{2}(?!\*)"  # **word**
-        )
-        self.emphasis = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
-
-
-class RestInlineLexer(mistune.InlineLexer):
-    grammar_class = RestInlineGrammar
-    default_rules = [
+    RUlE_NAMES = (
+        "inline_math",
         "image_link",
         "rest_role",
         "rest_link",
         "eol_literal_marker",
-    ] + mistune.InlineLexer.default_rules
+    ) + mistune.InlineParser.RULE_NAMES
 
-    def __init__(self, *args, **kwargs):
-        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
-        disable_inline_math = kwargs.pop("disable_inline_math", False)
-        super(RestInlineLexer, self).__init__(*args, **kwargs)
-        if not _is_sphinx:
-            parse_options()
-        if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
-            self.rules.no_underscore_emphasis()
-        inline_maths = "inline_math" in self.default_rules
-        if disable_inline_math or getattr(options, "disable_inline_math", False):
-            if inline_maths:
-                self.default_rules.remove("inline_math")
-        elif not inline_maths:
-            self.default_rules.insert(0, "inline_math")
-
-    def output_double_emphasis(self, m):
+    def parse_double_emphasis(self, match: Match, state: State) -> Element:
         # may include code span
-        text = self.output(m.group("text"))
-        return self.renderer.double_emphasis(text)
+        return "double_emphasis", match.group("text")
 
-    def output_emphasis(self, m):
+    def parse_emphasis(self, match: Match, state: State) -> Element:
         # may include code span
-        text = self.output(m.group("text") or m.group(1))
-        return self.renderer.emphasis(text)
+        return "emphasis", match.group("text") or match.group(1)
 
-    def output_image_link(self, m):
+    def parse_image_link(self, match: Match, state: State) -> Element:
         """Pass through rest role."""
-        return self.renderer.image_link(
-            m.group("url"), m.group("target"), m.group("alt")
-        )
+        alt, src, target = match.groups()
+        return "image_link", src, target, alt
 
-    def output_rest_role(self, m):
+    def parse_rest_role(self, match: Match, state: State) -> Element:
         """Pass through rest role."""
-        return self.renderer.rest_role(m.group(0))
+        return "rest_role", match.group(0)
 
-    def output_rest_link(self, m):
+    def parse_rest_link(self, match: Match, state: State) -> Element:
         """Pass through rest link."""
-        return self.renderer.rest_link(m.group(0))
+        return "rest_link", match.group(0)
 
-    def output_inline_math(self, m):
+    def parse_inline_math(self, match: Match, state: State) -> Element:
         """Pass through rest link."""
-        return self.renderer.inline_math(m.group(1))
+        return "inline_math", match.group(2)
 
-    def output_eol_literal_marker(self, m):
+    def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
         """Pass through rest link."""
-        marker = ":" if m.group(1) is None else ""
-        return self.renderer.eol_literal_marker(marker)
-
+        marker = ":" if match.group(1) is None else ""
+        return "eol_literal_marker", marker
 
-class RestRenderer(mistune.Renderer):
+    def no_underscore_emphasis(self):
+        self.DOUBLE_EMPHASIS = re.compile(
+            r"^\*{2}(?P<text>[\s\S]+?)\*{2}(?!\*)"  # **word**
+        )
+        self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
+
+
+#    def __init__(self, renderer, *args, **kwargs):
+#        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
+#        disable_inline_math = kwargs.pop("disable_inline_math", False)
+#        super().__init__(*args, **kwargs)
+#        if not _is_sphinx:
+#            parse_options()
+#        if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
+#            self.rules.no_underscore_emphasis()
+#        inline_maths = "inline_math" in self.default_rules
+#        if disable_inline_math or getattr(options, "disable_inline_math", False):
+#            if inline_maths:
+#                self.RUlE_NAMES = tuple(x for x in self.RUlE_NAMES if x != "inline_math")
+#        elif not inline_maths:
+#            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
+
+
+class RestRenderer(mistune.renderers.BaseRenderer):
     _include_raw_html = False
-    list_indent_re = re.compile(r"^(\s*(#\.|\*)\s)")
+    # list_indent_re = re.compile(r"^(\s*(#\.|\*)\s)")
     indent = " " * 3
     list_marker = "{#__rest_list_mark__#}"
     hmarks = {
@@ -223,6 +218,9 @@ def __init__(self, *args, **kwargs):
             if getattr(options, "anonymous_references", False):
                 self.anonymous_references = options.anonymous_references
 
+    def finalize(self, data):
+        return "".join(filter(lambda x: x is not None, data))
+
     def _indent_block(self, block):
         return "\n".join(
             self.indent + line if line else "" for line in block.splitlines()
@@ -249,6 +247,9 @@ def block_quote(self, text):
         # text includes some empty line
         return "\n..\n\n{}\n\n".format(self._indent_block(text.strip("\n")))
 
+    def block_text(self, text):
+        text
+
     def block_html(self, html):
         """Rendering block level pure html content.
 
@@ -265,7 +266,15 @@ def header(self, text, level, raw=None):
         """
         return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
 
-    def hrule(self):
+    def heading(self, text, level, raw=None):
+        """Rendering header/heading tags like ``<h1>`` ``<h2>``.
+        :param text: rendered text content for the header.
+        :param level: a number for the header level, for example: 1.
+        :param raw: raw text content of the header.
+        """
+        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
+
+    def thematic_break(self):
         """Rendering method for ``<hr>`` tag."""
         return "\n----\n"
 
@@ -529,15 +538,14 @@ def rest_code_block(self):
 
 
 class M2R(mistune.Markdown):
-    def __init__(
-        self, renderer=None, inline=RestInlineLexer, block=RestBlockLexer, **kwargs
-    ):
-        if renderer is None:
-            renderer = RestRenderer(**kwargs)
-        super(M2R, self).__init__(renderer, inline=inline, block=block, **kwargs)
+    def __init__(self, renderer=None, block=None, inline=None, **kwargs):
+        renderer = renderer or RestRenderer()
+        block = block or RestBlockParser()
+        inline = inline or RestInlineParser(renderer)
+        super().__init__(renderer, block=block, inline=inline, **kwargs)
 
     def parse(self, text):
-        output = super(M2R, self).parse(text)
+        output = super().parse(text)
         return self.post_process(output)
 
     def output_directive(self):
@@ -698,7 +706,7 @@ def convert(text, **kwargs):
 def parse_from_file(file, encoding="utf-8", **kwargs):
     if not os.path.exists(file):
         raise OSError("No such file exists: {}".format(file))
-    with _open(file, encoding=encoding) as f:
+    with open(file, encoding=encoding) as f:
         src = f.read()
     output = convert(src, **kwargs)
     return output
@@ -711,7 +719,7 @@ def save_to_file(file, src, encoding="utf-8", **kwargs):
         if confirm.upper() not in ("Y", "YES"):
             print("skip {}".format(file))
             return
-    with _open(target, "w", encoding=encoding) as f:
+    with open(target, "w", encoding=encoding) as f:
         f.write(src)
 
 
diff --git a/setup.py b/setup.py
index b0997ab..3b00319 100644
--- a/setup.py
+++ b/setup.py
@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import sys
 from os import path
 
 try:
@@ -14,17 +13,15 @@
     from m2r2 import parse_from_file
 
     readme = parse_from_file(readme_file)
-except ImportError:
+except (ImportError, TypeError):
     with open(readme_file) as f:
         readme = f.read()
 
 
 __version__ = "0.3.3"
 
-install_requires = ["mistune==0.8.4", "docutils>=0.19"]
+install_requires = ["mistune>=2.0.0,<3.0", "docutils>=0.16,<1.0"]
 test_requirements = ["pygments"]
-if sys.version_info < (3, 3):
-    test_requirements.append("mock")
 
 setup(
     name="m2r2",

From 0f0d206c4c122fc5bb49fbeac9c46c28b1412713 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Thu, 12 Jan 2023 11:18:42 -0300
Subject: [PATCH 02/22] small change

---
 m2r2.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/m2r2.py b/m2r2.py
index 1e04957..eacbe15 100644
--- a/m2r2.py
+++ b/m2r2.py
@@ -24,7 +24,8 @@
 Element = Tuple[str, ...]
 
 _is_sphinx = False
-prolog = """\
+
+PROLOG = """\
 .. role:: raw-html-m2r(raw)
    :format: html
 
@@ -356,6 +357,9 @@ def emphasis(self, text):
         """
         return r"\ *{}*\ ".format(text)
 
+    def strong(self, text):
+        return r"**{}**".format(text)
+
     def codespan(self, text):
         """Rendering inline `code` text.
 
@@ -563,7 +567,7 @@ def post_process(self, text):
             .replace("\\ .", ".")
         )
         if self.renderer._include_raw_html:
-            return prolog + output
+            return PROLOG + output
         else:
             return output
 

From da56b6dc4ab3c19cc4680612ce1bc375b6bde40c Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Thu, 12 Jan 2023 11:33:27 -0300
Subject: [PATCH 03/22] some more tests passing

---
 m2r2.py                | 6 +++---
 tests/test_renderer.py | 9 ++++-----
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/m2r2.py b/m2r2.py
index eacbe15..3be0967 100644
--- a/m2r2.py
+++ b/m2r2.py
@@ -249,7 +249,7 @@ def block_quote(self, text):
         return "\n..\n\n{}\n\n".format(self._indent_block(text.strip("\n")))
 
     def block_text(self, text):
-        text
+        return text
 
     def block_html(self, html):
         """Rendering block level pure html content.
@@ -279,7 +279,7 @@ def thematic_break(self):
         """Rendering method for ``<hr>`` tag."""
         return "\n----\n"
 
-    def list(self, body, ordered=True):
+    def list(self, body, ordered, level, start):
         """Rendering list tags like ``<ul>`` and ``<ol>``.
 
         :param body: body contents of the list.
@@ -292,7 +292,7 @@ def list(self, body, ordered=True):
                 lines[i] = " " * len(mark) + line
         return "\n{}\n".format("\n".join(lines)).replace(self.list_marker, mark)
 
-    def list_item(self, text):
+    def list_item(self, text, level):
         """Rendering list item snippet. Like ``<li>``."""
         return "\n" + self.list_marker + text
 
diff --git a/tests/test_renderer.py b/tests/test_renderer.py
index 8e86792..3c28d5d 100644
--- a/tests/test_renderer.py
+++ b/tests/test_renderer.py
@@ -5,10 +5,9 @@
 
 from unittest import TestCase, skip
 
-from docutils.core import Publisher
 from docutils import io
-
-from m2r2 import prolog, convert
+from docutils.core import Publisher
+from m2r2 import PROLOG, convert
 
 
 class RendererTestBase(TestCase):
@@ -77,7 +76,7 @@ def test_linebreak(self):
         src = 'abc def  \nghi'
         out = self.conv(src)
         self.assertEqual(
-            out, prolog + '\nabc def\\ :raw-html-m2r:`<br>`\nghi' + '\n',
+            out, PROLOG + '\nabc def\\ :raw-html-m2r:`<br>`\nghi' + '\n',
         )
 
 
@@ -276,7 +275,7 @@ def test_disable_inline_math(self):
     def test_inline_html(self):
         src = 'this is <s>html</s>.'
         out = self.conv(src)
-        self.assertEqual(out, prolog + '\nthis is :raw-html-m2r:`<s>html</s>`.\n')
+        self.assertEqual(out, PROLOG + '\nthis is :raw-html-m2r:`<s>html</s>`.\n')
 
     def test_block_html(self):
         src = '<h1>title</h1>'

From 6ec499a64de8d22c6c3ed23e2bac987cd2adede0 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Thu, 12 Jan 2023 11:41:38 -0300
Subject: [PATCH 04/22] fix init

---
 m2r2.py | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/m2r2.py b/m2r2.py
index 3be0967..16928ca 100644
--- a/m2r2.py
+++ b/m2r2.py
@@ -176,21 +176,22 @@ def no_underscore_emphasis(self):
         )
         self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
 
-
-#    def __init__(self, renderer, *args, **kwargs):
-#        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
-#        disable_inline_math = kwargs.pop("disable_inline_math", False)
-#        super().__init__(*args, **kwargs)
-#        if not _is_sphinx:
-#            parse_options()
-#        if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
-#            self.rules.no_underscore_emphasis()
-#        inline_maths = "inline_math" in self.default_rules
-#        if disable_inline_math or getattr(options, "disable_inline_math", False):
-#            if inline_maths:
-#                self.RUlE_NAMES = tuple(x for x in self.RUlE_NAMES if x != "inline_math")
-#        elif not inline_maths:
-#            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
+    def __init__(self, renderer, *args, **kwargs):
+        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
+        disable_inline_math = kwargs.pop("disable_inline_math", False)
+        super().__init__(renderer, *args, **kwargs)
+        if not _is_sphinx:
+            parse_options()
+        if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
+            self.rules.no_underscore_emphasis()
+        inline_maths = "inline_math" in self.RULE_NAMES
+        if disable_inline_math or getattr(options, "disable_inline_math", False):
+            if inline_maths:
+                self.RULE_NAMES = tuple(
+                    x for x in self.RUlE_NAMES if x != "inline_math"
+                )
+        elif not inline_maths:
+            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
 
 
 class RestRenderer(mistune.renderers.BaseRenderer):

From aad7d27ba1c1825137805cb0a83e7690a12b2909 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Thu, 12 Jan 2023 12:19:42 -0300
Subject: [PATCH 05/22] fix a test

---
 m2r2.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/m2r2.py b/m2r2.py
index 16928ca..d0d278b 100644
--- a/m2r2.py
+++ b/m2r2.py
@@ -538,7 +538,7 @@ def eol_literal_marker(self, marker):
     def directive(self, text):
         return "\n" + text
 
-    def rest_code_block(self):
+    def rest_code_block(self, text):
         return "\n\n"
 
 

From 516e167a61bb96554553d269fdde84362e4b9918 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 30 Jan 2023 04:01:38 -0300
Subject: [PATCH 06/22] restructure everything

---
 .pre-commit-config.yaml |   1 -
 m2r2.py                 | 745 ----------------------------------------
 m2r2/__init__.py        |   3 +
 m2r2/cli/__init__.py    |   0
 m2r2/cli/m2r2.py        |  85 +++++
 m2r2/constants.py       |   5 +
 m2r2/m2r2.py            |  42 +++
 m2r2/parser.py          |  24 ++
 m2r2/rst/__init__.py    |   0
 m2r2/rst/directives.py  |  92 +++++
 m2r2/rst/parser.py      | 126 +++++++
 m2r2/rst/renderer.py    | 355 +++++++++++++++++++
 m2r2/sphinx/__init__.py |   0
 m2r2/sphinx/m2r2.py     |  30 ++
 m2r2/typing.py          |   5 +
 requirements-test.txt   |   1 -
 setup.py                |   3 +-
 17 files changed, 769 insertions(+), 748 deletions(-)
 delete mode 100644 m2r2.py
 create mode 100644 m2r2/__init__.py
 create mode 100644 m2r2/cli/__init__.py
 create mode 100644 m2r2/cli/m2r2.py
 create mode 100644 m2r2/constants.py
 create mode 100644 m2r2/m2r2.py
 create mode 100644 m2r2/parser.py
 create mode 100644 m2r2/rst/__init__.py
 create mode 100644 m2r2/rst/directives.py
 create mode 100644 m2r2/rst/parser.py
 create mode 100644 m2r2/rst/renderer.py
 create mode 100644 m2r2/sphinx/__init__.py
 create mode 100644 m2r2/sphinx/m2r2.py
 create mode 100644 m2r2/typing.py

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 1e55a3f..cad3826 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -26,7 +26,6 @@ repos:
       language: system
       types: [python]
       args: []
-      language_version: python3.7
       exclude: (docs|tests)/*
     - id: mypy
       name: mypy
diff --git a/m2r2.py b/m2r2.py
deleted file mode 100644
index d0d278b..0000000
--- a/m2r2.py
+++ /dev/null
@@ -1,745 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-from __future__ import print_function, unicode_literals
-
-import os
-import os.path
-import re
-from argparse import ArgumentParser, Namespace
-from typing import Any, Dict, Match, Tuple
-from urllib.parse import urlparse
-
-import mistune
-from docutils import io, nodes, statemachine, utils
-from docutils.parsers import rst
-from docutils.utils import column_width
-from pkg_resources import get_distribution
-
-__version__ = get_distribution("m2r2").version
-
-
-State = Dict[str, Any]
-Token = Dict[str, Any]
-Element = Tuple[str, ...]
-
-_is_sphinx = False
-
-PROLOG = """\
-.. role:: raw-html-m2r(raw)
-   :format: html
-
-"""
-
-# for command-line use
-parser = ArgumentParser()
-options = Namespace()
-parser.add_argument("input_file", nargs="*", help="files to convert to reST format")
-parser.add_argument(
-    "--overwrite",
-    action="store_true",
-    default=False,
-    help="overwrite output file without confirmaion",
-)
-parser.add_argument(
-    "--dry-run",
-    action="store_true",
-    default=False,
-    help="print conversion result and not save output file",
-)
-parser.add_argument(
-    "--no-underscore-emphasis",
-    action="store_true",
-    default=False,
-    help="do not use underscore (_) for emphasis",
-)
-parser.add_argument(
-    "--parse-relative-links",
-    action="store_true",
-    default=False,
-    help="parse relative links into ref or doc directives",
-)
-parser.add_argument(
-    "--anonymous-references",
-    action="store_true",
-    default=False,
-    help="use anonymous references in generated rst",
-)
-parser.add_argument(
-    "--disable-inline-math",
-    action="store_true",
-    default=False,
-    help="disable parsing inline math",
-)
-
-
-def parse_options():
-    parser.parse_known_args(namespace=options)
-
-
-class RestBlockParser(mistune.BlockParser):
-    DIRECTIVE = re.compile(
-        r"^( *\.\..*?)\n(?=\S)",
-        re.DOTALL | re.MULTILINE,
-    )
-    ONELINE_DIRECTIVE = re.compile(
-        r"^( *\.\..*?)$",
-        re.DOTALL | re.MULTILINE,
-    )
-    REST_CODE_BLOCK = re.compile(
-        r"^::\s*$",
-        re.DOTALL | re.MULTILINE,
-    )
-    RULE_NAMES = mistune.BlockParser.RULE_NAMES + (
-        "directive",
-        "oneline_directive",
-        "rest_code_block",
-    )
-
-    RULE_NAMES = (
-        "directive",
-        "oneline_directive",
-        "rest_code_block",
-    ) + mistune.BlockParser.RULE_NAMES
-
-    def parse_directive(self, match: Match, state: State) -> Token:
-        return {"type": "directive", "text": match.group(1)}
-
-    def parse_oneline_directive(self, match: Match, state: State) -> Token:
-        # reuse directive output
-        return {"type": "directive", "text": match.group(1)}
-
-    def parse_rest_code_block(self, match: Match, state: State) -> Token:
-        return {"type": "rest_code_block", "text": ""}
-
-
-class RestInlineParser(mistune.InlineParser):
-    IMAGE_LINK = re.compile(
-        r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
-    )
-    REST_ROLE = re.compile(r":.*?:`.*?`|`[^`]+`:.*?:")
-    REST_LINK = re.compile(r"`[^`]*?`_")
-    INLINE_MATH = re.compile(r"`\$(.*?)\$`")
-    EOL_LITERAL_MARKER = re.compile(r"(\s+)?::\s*$")
-    # add colon and space as special text
-    TEXT = re.compile(r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)")
-    # __word__ or **word**
-    DOUBLE_EMPHASIS = re.compile(r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)")
-    # _word_ or *word*
-    EMPHASIS = re.compile(
-        r"^\b_((?:__|[^_])+?)_\b"  # _word_
-        r"|"
-        r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
-    )
-
-    RUlE_NAMES = (
-        "inline_math",
-        "image_link",
-        "rest_role",
-        "rest_link",
-        "eol_literal_marker",
-    ) + mistune.InlineParser.RULE_NAMES
-
-    def parse_double_emphasis(self, match: Match, state: State) -> Element:
-        # may include code span
-        return "double_emphasis", match.group("text")
-
-    def parse_emphasis(self, match: Match, state: State) -> Element:
-        # may include code span
-        return "emphasis", match.group("text") or match.group(1)
-
-    def parse_image_link(self, match: Match, state: State) -> Element:
-        """Pass through rest role."""
-        alt, src, target = match.groups()
-        return "image_link", src, target, alt
-
-    def parse_rest_role(self, match: Match, state: State) -> Element:
-        """Pass through rest role."""
-        return "rest_role", match.group(0)
-
-    def parse_rest_link(self, match: Match, state: State) -> Element:
-        """Pass through rest link."""
-        return "rest_link", match.group(0)
-
-    def parse_inline_math(self, match: Match, state: State) -> Element:
-        """Pass through rest link."""
-        return "inline_math", match.group(2)
-
-    def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
-        """Pass through rest link."""
-        marker = ":" if match.group(1) is None else ""
-        return "eol_literal_marker", marker
-
-    def no_underscore_emphasis(self):
-        self.DOUBLE_EMPHASIS = re.compile(
-            r"^\*{2}(?P<text>[\s\S]+?)\*{2}(?!\*)"  # **word**
-        )
-        self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
-
-    def __init__(self, renderer, *args, **kwargs):
-        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
-        disable_inline_math = kwargs.pop("disable_inline_math", False)
-        super().__init__(renderer, *args, **kwargs)
-        if not _is_sphinx:
-            parse_options()
-        if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
-            self.rules.no_underscore_emphasis()
-        inline_maths = "inline_math" in self.RULE_NAMES
-        if disable_inline_math or getattr(options, "disable_inline_math", False):
-            if inline_maths:
-                self.RULE_NAMES = tuple(
-                    x for x in self.RUlE_NAMES if x != "inline_math"
-                )
-        elif not inline_maths:
-            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
-
-
-class RestRenderer(mistune.renderers.BaseRenderer):
-    _include_raw_html = False
-    # list_indent_re = re.compile(r"^(\s*(#\.|\*)\s)")
-    indent = " " * 3
-    list_marker = "{#__rest_list_mark__#}"
-    hmarks = {
-        1: "=",
-        2: "-",
-        3: "^",
-        4: "~",
-        5: '"',
-        6: "#",
-    }
-
-    def __init__(self, *args, **kwargs):
-        self.parse_relative_links = kwargs.pop("parse_relative_links", False)
-        self.anonymous_references = kwargs.pop("anonymous_references", False)
-        self.use_mermaid = kwargs.pop("use_mermaid", False)
-        super(RestRenderer, self).__init__(*args, **kwargs)
-        if not _is_sphinx:
-            parse_options()
-            if getattr(options, "parse_relative_links", False):
-                self.parse_relative_links = options.parse_relative_links
-            if getattr(options, "anonymous_references", False):
-                self.anonymous_references = options.anonymous_references
-
-    def finalize(self, data):
-        return "".join(filter(lambda x: x is not None, data))
-
-    def _indent_block(self, block):
-        return "\n".join(
-            self.indent + line if line else "" for line in block.splitlines()
-        )
-
-    def _raw_html(self, html):
-        self._include_raw_html = True
-        return r"\ :raw-html-m2r:`{}`\ ".format(html)
-
-    def block_code(self, code, lang=None):
-        if lang == "math":
-            first_line = "\n.. math::\n\n"
-        elif lang == "mermaid" and self.use_mermaid:
-            first_line = "\n.. mermaid::\n\n"
-        elif lang:
-            first_line = "\n.. code-block:: {}\n\n".format(lang)
-        elif _is_sphinx:
-            first_line = "\n::\n\n"
-        else:
-            first_line = "\n.. code-block::\n\n"
-        return first_line + self._indent_block(code) + "\n"
-
-    def block_quote(self, text):
-        # text includes some empty line
-        return "\n..\n\n{}\n\n".format(self._indent_block(text.strip("\n")))
-
-    def block_text(self, text):
-        return text
-
-    def block_html(self, html):
-        """Rendering block level pure html content.
-
-        :param html: text content of the html snippet.
-        """
-        return "\n\n.. raw:: html\n\n" + self._indent_block(html) + "\n\n"
-
-    def header(self, text, level, raw=None):
-        """Rendering header/heading tags like ``<h1>`` ``<h2>``.
-
-        :param text: rendered text content for the header.
-        :param level: a number for the header level, for example: 1.
-        :param raw: raw text content of the header.
-        """
-        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
-
-    def heading(self, text, level, raw=None):
-        """Rendering header/heading tags like ``<h1>`` ``<h2>``.
-        :param text: rendered text content for the header.
-        :param level: a number for the header level, for example: 1.
-        :param raw: raw text content of the header.
-        """
-        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
-
-    def thematic_break(self):
-        """Rendering method for ``<hr>`` tag."""
-        return "\n----\n"
-
-    def list(self, body, ordered, level, start):
-        """Rendering list tags like ``<ul>`` and ``<ol>``.
-
-        :param body: body contents of the list.
-        :param ordered: whether this list is ordered or not.
-        """
-        mark = "#. " if ordered else "* "
-        lines = body.splitlines()
-        for i, line in enumerate(lines):
-            if line and not line.startswith(self.list_marker):
-                lines[i] = " " * len(mark) + line
-        return "\n{}\n".format("\n".join(lines)).replace(self.list_marker, mark)
-
-    def list_item(self, text, level):
-        """Rendering list item snippet. Like ``<li>``."""
-        return "\n" + self.list_marker + text
-
-    def paragraph(self, text):
-        """Rendering paragraph tags. Like ``<p>``."""
-        return "\n" + text + "\n"
-
-    def table(self, header, body):
-        """Rendering table element. Wrap header and body in it.
-
-        :param header: header part of the table.
-        :param body: body part of the table.
-        """
-        table = "\n.. list-table::\n"
-        if header and not header.isspace():
-            table = (
-                table
-                + self.indent
-                + ":header-rows: 1\n\n"
-                + self._indent_block(header)
-                + "\n"
-            )
-        else:
-            table = table + "\n"
-        table = table + self._indent_block(body) + "\n\n"
-        return table
-
-    def table_row(self, content):
-        """Rendering a table row. Like ``<tr>``.
-
-        :param content: content of current table row.
-        """
-        contents = content.splitlines()
-        if not contents:
-            return ""
-        clist = ["* " + contents[0]]
-        if len(contents) > 1:
-            for c in contents[1:]:
-                clist.append("  " + c)
-        return "\n".join(clist) + "\n"
-
-    def table_cell(self, content, **flags):
-        """Rendering a table cell. Like ``<th>`` ``<td>``.
-
-        :param content: content of current table cell.
-        :param header: whether this is header or not.
-        :param align: align of current table cell.
-        """
-        return "- " + content + "\n"
-
-    def double_emphasis(self, text):
-        """Rendering **strong** text.
-
-        :param text: text content for emphasis.
-        """
-        return r"\ **{}**\ ".format(text)
-
-    def emphasis(self, text):
-        """Rendering *emphasis* text.
-
-        :param text: text content for emphasis.
-        """
-        return r"\ *{}*\ ".format(text)
-
-    def strong(self, text):
-        return r"**{}**".format(text)
-
-    def codespan(self, text):
-        """Rendering inline `code` text.
-
-        :param text: text content for inline code.
-        """
-        if "``" not in text:
-            return r"\ ``{}``\ ".format(text)
-        else:
-            # actually, docutils split spaces in literal
-            return self._raw_html(
-                '<code class="docutils literal">'
-                '<span class="pre">{}</span>'
-                "</code>".format(text.replace("`", "&#96;"))
-            )
-
-    def linebreak(self):
-        """Rendering line break like ``<br>``."""
-        if self.options.get("use_xhtml"):
-            return self._raw_html("<br />") + "\n"
-        return self._raw_html("<br>") + "\n"
-
-    def strikethrough(self, text):
-        """Rendering ~~strikethrough~~ text.
-
-        :param text: text content for strikethrough.
-        """
-        return self._raw_html("<del>{}</del>".format(text))
-
-    def text(self, text):
-        """Rendering unformatted text.
-
-        :param text: text content.
-        """
-        return text
-
-    def autolink(self, link, is_email=False):
-        """Rendering a given link or email address.
-
-        :param link: link content or email address.
-        :param is_email: whether this is an email or not.
-        """
-        return link
-
-    def link(self, link, title, text):
-        """Rendering a given link with content and title.
-
-        :param link: href link for ``<a>`` tag.
-        :param title: title content for `title` attribute.
-        :param text: text content for description.
-        """
-        if self.anonymous_references:
-            underscore = "__"
-        else:
-            underscore = "_"
-        if title:
-            return self._raw_html(
-                '<a href="{link}" title="{title}">{text}</a>'.format(
-                    link=link, title=title, text=text
-                )
-            )
-        if not self.parse_relative_links:
-            return r"\ `{text} <{target}>`{underscore}\ ".format(
-                target=link, text=text, underscore=underscore
-            )
-        else:
-            url_info = urlparse(link)
-            if url_info.scheme:
-                return r"\ `{text} <{target}>`{underscore}\ ".format(
-                    target=link, text=text, underscore=underscore
-                )
-            else:
-                link_type = "doc"
-                anchor = url_info.fragment
-                if url_info.fragment:
-                    if url_info.path:
-                        # Can't link to anchors via doc directive.
-                        anchor = ""
-                    else:
-                        # Example: [text](#anchor)
-                        link_type = "ref"
-                doc_link = "{doc_name}{anchor}".format(
-                    # splittext approach works whether or not path is set. It
-                    # will return an empty string if unset, which leads to
-                    # anchor only ref.
-                    doc_name=os.path.splitext(url_info.path)[0],
-                    anchor=anchor,
-                )
-                return r"\ :{link_type}:`{text} <{doc_link}>`\ ".format(
-                    link_type=link_type, doc_link=doc_link, text=text
-                )
-
-    def image(self, src, title, text):
-        """Rendering a image with title and text.
-
-        :param src: source link of the image.
-        :param title: title text of the image.
-        :param text: alt text of the image.
-        """
-        # rst does not support title option
-        # and I couldn't find title attribute in HTML standard
-        return "\n".join(
-            [
-                "",
-                ".. image:: {}".format(src),
-                "   :target: {}".format(src),
-                "   :alt: {}".format(text),
-                "",
-            ]
-        )
-
-    def inline_html(self, html):
-        """Rendering span level pure html content.
-
-        :param html: text content of the html snippet.
-        """
-        return self._raw_html(html)
-
-    def newline(self):
-        """Rendering newline element."""
-        return ""
-
-    def footnote_ref(self, key, index):
-        """Rendering the ref anchor of a footnote.
-
-        :param key: identity key for the footnote.
-        :param index: the index count of current footnote.
-        """
-        return r"\ [#fn-{}]_\ ".format(key)
-
-    def footnote_item(self, key, text):
-        """Rendering a footnote item.
-
-        :param key: identity key for the footnote.
-        :param text: text content of the footnote.
-        """
-        return ".. [#fn-{0}] {1}\n".format(key, text.strip())
-
-    def footnotes(self, text):
-        """Wrapper for all footnotes.
-
-        :param text: contents of all footnotes.
-        """
-        if text:
-            return "\n\n" + text
-        else:
-            return ""
-
-    """Below outputs are for rst."""
-
-    def image_link(self, url, target, alt):
-        return "\n".join(
-            [
-                "",
-                ".. image:: {}".format(url),
-                "   :target: {}".format(target),
-                "   :alt: {}".format(alt),
-                "",
-            ]
-        )
-
-    def rest_role(self, text):
-        return text
-
-    def rest_link(self, text):
-        return text
-
-    def inline_math(self, math):
-        """Extension of recommonmark."""
-        return r":math:`{}`".format(math)
-
-    def eol_literal_marker(self, marker):
-        """Extension of recommonmark."""
-        return marker
-
-    def directive(self, text):
-        return "\n" + text
-
-    def rest_code_block(self, text):
-        return "\n\n"
-
-
-class M2R(mistune.Markdown):
-    def __init__(self, renderer=None, block=None, inline=None, **kwargs):
-        renderer = renderer or RestRenderer()
-        block = block or RestBlockParser()
-        inline = inline or RestInlineParser(renderer)
-        super().__init__(renderer, block=block, inline=inline, **kwargs)
-
-    def parse(self, text):
-        output = super().parse(text)
-        return self.post_process(output)
-
-    def output_directive(self):
-        return self.renderer.directive(self.token["text"])
-
-    def output_rest_code_block(self):
-        return self.renderer.rest_code_block()
-
-    def post_process(self, text):
-        output = (
-            text.replace("\\ \n", "\n")
-            .replace("\n\\ ", "\n")
-            .replace(" \\ ", " ")
-            .replace("\\  ", " ")
-            .replace("\\ .", ".")
-        )
-        if self.renderer._include_raw_html:
-            return PROLOG + output
-        else:
-            return output
-
-
-class M2RParser(rst.Parser, object):
-    # Explicitly tell supported formats to sphinx
-    supported = ("markdown", "md", "mkd")
-
-    def parse(self, inputstrings, document):
-        if isinstance(inputstrings, statemachine.StringList):
-            inputstring = "\n".join(inputstrings)
-        else:
-            inputstring = inputstrings
-        config = document.settings.env.config
-        converter = M2R(
-            no_underscore_emphasis=config.no_underscore_emphasis,
-            parse_relative_links=config.m2r_parse_relative_links,
-            anonymous_references=config.m2r_anonymous_references,
-            disable_inline_math=config.m2r_disable_inline_math,
-            use_mermaid=config.m2r_use_mermaid,
-        )
-        super(M2RParser, self).parse(converter(inputstring), document)
-
-
-class MdInclude(rst.Directive):
-    """Directive class to include markdown in sphinx.
-
-    Load a file and convert it to rst and insert as a node. Currently
-    directive-specific options are not implemented.
-    """
-
-    required_arguments = 1
-    optional_arguments = 0
-    option_spec = {
-        "start-line": int,
-        "end-line": int,
-    }
-
-    def run(self):
-        """Most of this method is from ``docutils.parser.rst.Directive``.
-
-        docutils version: 0.12
-        """
-        if not self.state.document.settings.file_insertion_enabled:
-            raise self.warning('"%s" directive disabled.' % self.name)
-        source = self.state_machine.input_lines.source(
-            self.lineno - self.state_machine.input_offset - 1
-        )
-        source_dir = os.path.dirname(os.path.abspath(source))
-        path = rst.directives.path(self.arguments[0])
-        path = os.path.normpath(os.path.join(source_dir, path))
-        path = utils.relative_path(None, path)
-        path = nodes.reprunicode(path)
-
-        # get options (currently not use directive-specific options)
-        encoding = self.options.get(
-            "encoding", self.state.document.settings.input_encoding
-        )
-        e_handler = self.state.document.settings.input_encoding_error_handler
-        tab_width = self.options.get(
-            "tab-width", self.state.document.settings.tab_width
-        )
-
-        # open the including file
-        try:
-            self.state.document.settings.record_dependencies.add(path)
-            include_file = io.FileInput(
-                source_path=path, encoding=encoding, error_handler=e_handler
-            )
-        except UnicodeEncodeError:
-            raise self.severe(
-                'Problems with "%s" directive path:\n'
-                'Cannot encode input file path "%s" '
-                "(wrong locale?)." % (self.name, str(path))
-            )
-        except IOError as error:
-            raise self.severe(
-                'Problems with "%s" directive path:\n%s.'
-                % (self.name, io.error_string(error))
-            )
-
-        # read from the file
-        startline = self.options.get("start-line", None)
-        endline = self.options.get("end-line", None)
-        try:
-            if startline or (endline is not None):
-                lines = include_file.readlines()
-                rawtext = "".join(lines[startline:endline])
-            else:
-                rawtext = include_file.read()
-        except UnicodeError as error:
-            raise self.severe(
-                'Problem with "%s" directive:\n%s' % (self.name, io.error_string(error))
-            )
-
-        config = self.state.document.settings.env.config
-        converter = M2R(
-            no_underscore_emphasis=config.no_underscore_emphasis,
-            parse_relative_links=config.m2r_parse_relative_links,
-            anonymous_references=config.m2r_anonymous_references,
-            disable_inline_math=config.m2r_disable_inline_math,
-            use_mermaid=config.m2r_use_mermaid,
-        )
-        include_lines = statemachine.string2lines(
-            converter(rawtext), tab_width, convert_whitespace=True
-        )
-        self.state_machine.insert_input(include_lines, path)
-        return []
-
-
-def setup(app):
-    """When used for sphinx extension."""
-    global _is_sphinx
-    _is_sphinx = True
-    app.add_config_value("no_underscore_emphasis", False, "env")
-    app.add_config_value("m2r_parse_relative_links", False, "env")
-    app.add_config_value("m2r_anonymous_references", False, "env")
-    app.add_config_value("m2r_disable_inline_math", False, "env")
-    app.add_config_value(
-        "m2r_use_mermaid", "sphinxcontrib.mermaid" in app.config.extensions, "env"
-    )
-    try:
-        app.add_source_parser(".md", M2RParser)  # for older sphinx versions
-    except (TypeError, AttributeError):
-        app.add_source_suffix(".md", "markdown")
-        app.add_source_parser(M2RParser)
-    app.add_directive("mdinclude", MdInclude)
-    metadata = dict(
-        version=__version__,
-        parallel_read_safe=True,
-        parallel_write_safe=True,
-    )
-    return metadata
-
-
-def convert(text, **kwargs):
-    return M2R(**kwargs)(text)
-
-
-def parse_from_file(file, encoding="utf-8", **kwargs):
-    if not os.path.exists(file):
-        raise OSError("No such file exists: {}".format(file))
-    with open(file, encoding=encoding) as f:
-        src = f.read()
-    output = convert(src, **kwargs)
-    return output
-
-
-def save_to_file(file, src, encoding="utf-8", **kwargs):
-    target = os.path.splitext(file)[0] + ".rst"
-    if not options.overwrite and os.path.exists(target):
-        confirm = input("{} already exists. overwrite it? [y/n]: ".format(target))
-        if confirm.upper() not in ("Y", "YES"):
-            print("skip {}".format(file))
-            return
-    with open(target, "w", encoding=encoding) as f:
-        f.write(src)
-
-
-def main():
-    parse_options()  # parse cli options
-    if not options.input_file:
-        parser.print_help()
-        parser.exit(0)
-    for file in options.input_file:
-        output = parse_from_file(file)
-        if options.dry_run:
-            print(output)
-        else:
-            save_to_file(file, output)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/m2r2/__init__.py b/m2r2/__init__.py
new file mode 100644
index 0000000..96b2868
--- /dev/null
+++ b/m2r2/__init__.py
@@ -0,0 +1,3 @@
+from .m2r2 import M2R, convert
+
+__all__ = ("M2R", "convert")
diff --git a/m2r2/cli/__init__.py b/m2r2/cli/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/m2r2/cli/m2r2.py b/m2r2/cli/m2r2.py
new file mode 100644
index 0000000..c706367
--- /dev/null
+++ b/m2r2/cli/m2r2.py
@@ -0,0 +1,85 @@
+import os
+from argparse import ArgumentParser, Namespace
+
+from m2r2 import convert
+
+parser = ArgumentParser()
+options = Namespace()
+parser.add_argument("input_file", nargs="*", help="files to convert to reST format")
+parser.add_argument(
+    "--overwrite",
+    action="store_true",
+    default=False,
+    help="overwrite output file without confirmaion",
+)
+parser.add_argument(
+    "--dry-run",
+    action="store_true",
+    default=False,
+    help="print conversion result and not save output file",
+)
+parser.add_argument(
+    "--no-underscore-emphasis",
+    action="store_true",
+    default=False,
+    help="do not use underscore (_) for emphasis",
+)
+parser.add_argument(
+    "--parse-relative-links",
+    action="store_true",
+    default=False,
+    help="parse relative links into ref or doc directives",
+)
+parser.add_argument(
+    "--anonymous-references",
+    action="store_true",
+    default=False,
+    help="use anonymous references in generated rst",
+)
+parser.add_argument(
+    "--disable-inline-math",
+    action="store_true",
+    default=False,
+    help="disable parsing inline math",
+)
+
+
+def parse_options():
+    parser.parse_known_args(namespace=options)
+
+
+def parse_from_file(file, encoding="utf-8", **kwargs):
+    if not os.path.exists(file):
+        raise OSError("No such file exists: {}".format(file))
+    with open(file, encoding=encoding) as f:
+        src = f.read()
+    output = convert(src, **kwargs)
+    return output
+
+
+def save_to_file(file, src, encoding="utf-8", **kwargs):
+    target = os.path.splitext(file)[0] + ".rst"
+    if not options.overwrite and os.path.exists(target):
+        confirm = input("{} already exists. overwrite it? [y/n]: ".format(target))
+        if confirm.upper() not in ("Y", "YES"):
+            print("skip {}".format(file))
+            return
+    with open(target, "w", encoding=encoding) as f:
+        f.write(src)
+
+
+def main():
+    parse_options()  # parse cli options
+    if not options.input_file:
+        parser.print_help()
+        parser.exit(0)
+    for file in options.input_file:
+        output = parse_from_file(file)
+        if options.dry_run:
+            print(output)
+        else:
+            save_to_file(file, output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/m2r2/constants.py b/m2r2/constants.py
new file mode 100644
index 0000000..476f591
--- /dev/null
+++ b/m2r2/constants.py
@@ -0,0 +1,5 @@
+PROLOG = """\
+.. role:: raw-html-m2r(raw)
+   :format: html
+
+"""
diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
new file mode 100644
index 0000000..05fa4b0
--- /dev/null
+++ b/m2r2/m2r2.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import print_function, unicode_literals
+
+import mistune
+from pkg_resources import get_distribution
+
+from m2r2.constants import PROLOG
+from m2r2.rst.parser import RestBlockParser, RestInlineParser
+from m2r2.rst.renderer import RestRenderer
+
+__version__ = get_distribution("m2r2").version
+
+
+class M2R(mistune.Markdown):
+    def __init__(self, renderer=None, block=None, inline=None, plugins=None):
+        renderer = renderer or RestRenderer()
+        block = block or RestBlockParser()
+        inline = inline or RestInlineParser(renderer)
+        super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
+
+    def parse(self, text):
+        output = super().parse(text)
+        return self.post_process(output)
+
+    def post_process(self, text):
+        output = (
+            text.replace("\\ \n", "\n")
+            .replace("\n\\ ", "\n")
+            .replace(" \\ ", " ")
+            .replace("\\  ", " ")
+            .replace("\\ .", ".")
+        )
+        if self.renderer._include_raw_html:
+            return PROLOG + output
+        else:
+            return output
+
+
+def convert(text, **kwargs):
+    return M2R(**kwargs)(text)
diff --git a/m2r2/parser.py b/m2r2/parser.py
new file mode 100644
index 0000000..35b8aff
--- /dev/null
+++ b/m2r2/parser.py
@@ -0,0 +1,24 @@
+from docutils import statemachine
+from docutils.parsers import rst
+
+from m2r2 import M2R
+
+
+class M2RParser(rst.Parser):
+    # Explicitly tell supported formats to sphinx
+    supported = ("markdown", "md", "mkd")
+
+    def parse(self, inputstrings, document):
+        if isinstance(inputstrings, statemachine.StringList):
+            inputstring = "\n".join(inputstrings)
+        else:
+            inputstring = inputstrings
+        config = document.settings.env.config
+        converter = M2R(
+            no_underscore_emphasis=config.no_underscore_emphasis,
+            parse_relative_links=config.m2r_parse_relative_links,
+            anonymous_references=config.m2r_anonymous_references,
+            disable_inline_math=config.m2r_disable_inline_math,
+            use_mermaid=config.m2r_use_mermaid,
+        )
+        super(M2RParser, self).parse(converter(inputstring), document)
diff --git a/m2r2/rst/__init__.py b/m2r2/rst/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/m2r2/rst/directives.py b/m2r2/rst/directives.py
new file mode 100644
index 0000000..58b1da7
--- /dev/null
+++ b/m2r2/rst/directives.py
@@ -0,0 +1,92 @@
+import os
+
+from docutils import io, nodes, statemachine, utils
+from docutils.parsers import rst
+
+from m2r2 import M2R
+
+
+class MdInclude(rst.Directive):
+    """Directive class to include markdown in sphinx.
+
+    Load a file and convert it to rst and insert as a node. Currently
+    directive-specific options are not implemented.
+    """
+
+    required_arguments = 1
+    optional_arguments = 0
+    option_spec = {
+        "start-line": int,
+        "end-line": int,
+    }
+
+    def run(self):
+        """Most of this method is from ``docutils.parser.rst.Directive``.
+
+        docutils version: 0.12
+        """
+        if not self.state.document.settings.file_insertion_enabled:
+            raise self.warning('"%s" directive disabled.' % self.name)
+        source = self.state_machine.input_lines.source(
+            self.lineno - self.state_machine.input_offset - 1
+        )
+        source_dir = os.path.dirname(os.path.abspath(source))
+        path = rst.directives.path(self.arguments[0])
+        path = os.path.normpath(os.path.join(source_dir, path))
+        path = utils.relative_path(None, path)
+        path = nodes.reprunicode(path)
+
+        # get options (currently not use directive-specific options)
+        encoding = self.options.get(
+            "encoding", self.state.document.settings.input_encoding
+        )
+        e_handler = self.state.document.settings.input_encoding_error_handler
+        tab_width = self.options.get(
+            "tab-width", self.state.document.settings.tab_width
+        )
+
+        # open the including file
+        try:
+            self.state.document.settings.record_dependencies.add(path)
+            include_file = io.FileInput(
+                source_path=path, encoding=encoding, error_handler=e_handler
+            )
+        except UnicodeEncodeError:
+            raise self.severe(
+                'Problems with "%s" directive path:\n'
+                'Cannot encode input file path "%s" '
+                "(wrong locale?)." % (self.name, str(path))
+            )
+        except IOError as error:
+            raise self.severe(
+                'Problems with "%s" directive path:\n%s.'
+                % (self.name, io.error_string(error))
+            )
+
+        # read from the file
+        startline = self.options.get("start-line", None)
+        endline = self.options.get("end-line", None)
+        try:
+            if startline or (endline is not None):
+                lines = include_file.readlines()
+                rawtext = "".join(lines[startline:endline])
+            else:
+                rawtext = include_file.read()
+        except UnicodeError as error:
+            raise self.severe(
+                'Problem with "%s" directive:\n%s' % (self.name, io.error_string(error))
+            )
+
+        config = self.state.document.settings.env.config
+        converter = M2R(
+            no_underscore_emphasis=config.no_underscore_emphasis,
+            parse_relative_links=config.m2r_parse_relative_links,
+            anonymous_references=config.m2r_anonymous_references,
+            disable_inline_math=config.m2r_disable_inline_math,
+            use_mermaid=config.m2r_use_mermaid,
+        )
+        include_lines = statemachine.string2lines(
+            converter(rawtext), tab_width, convert_whitespace=True
+        )
+        self.state_machine.insert_input(include_lines, path)
+        return []
diff --git a/m2r2/rst/parser.py b/m2r2/rst/parser.py
new file mode 100644
index 0000000..384800a
--- /dev/null
+++ b/m2r2/rst/parser.py
@@ -0,0 +1,126 @@
+import re
+from typing import Match
+
+import mistune
+
+from m2r2.typing import Element, State, Token
+
+# TODO: fix global
+_is_sphinx = False
+
+
+class RestBlockParser(mistune.BlockParser):
+    DIRECTIVE = re.compile(
+        r"^( *\.\..*?)\n(?=\S)",
+        re.DOTALL | re.MULTILINE,
+    )
+    ONELINE_DIRECTIVE = re.compile(
+        r"^( *\.\..*?)$",
+        re.DOTALL | re.MULTILINE,
+    )
+    REST_CODE_BLOCK = re.compile(
+        r"^::\s*$",
+        re.DOTALL | re.MULTILINE,
+    )
+    RULE_NAMES = mistune.BlockParser.RULE_NAMES + (
+        "directive",
+        "oneline_directive",
+        "rest_code_block",
+    )
+
+    RULE_NAMES = (
+        "directive",
+        "oneline_directive",
+        "rest_code_block",
+    ) + mistune.BlockParser.RULE_NAMES
+
+    def parse_directive(self, match: Match, state: State) -> Token:
+        return {"type": "directive", "text": match.group(1)}
+
+    def parse_oneline_directive(self, match: Match, state: State) -> Token:
+        # reuse directive output
+        return {"type": "directive", "text": match.group(1)}
+
+    def parse_rest_code_block(self, match: Match, state: State) -> Token:
+        return {"type": "rest_code_block", "text": ""}
+
+
+class RestInlineParser(mistune.InlineParser):
+    IMAGE_LINK = re.compile(
+        r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
+    )
+    REST_ROLE = re.compile(r":.*?:`.*?`|`[^`]+`:.*?:")
+    REST_LINK = re.compile(r"`[^`]*?`_")
+    INLINE_MATH = re.compile(r"`\$(.*?)\$`")
+    EOL_LITERAL_MARKER = re.compile(r"(\s+)?::\s*$")
+    # add colon and space as special text
+    TEXT = re.compile(r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)")
+    # __word__ or **word**
+    DOUBLE_EMPHASIS = re.compile(r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)")
+    # _word_ or *word*
+    EMPHASIS = re.compile(
+        r"^\b_((?:__|[^_])+?)_\b"  # _word_
+        r"|"
+        r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
+    )
+
+    RUlE_NAMES = (
+        "inline_math",
+        "image_link",
+        "rest_role",
+        "rest_link",
+        "eol_literal_marker",
+    ) + mistune.InlineParser.RULE_NAMES
+
+    def parse_double_emphasis(self, match: Match, state: State) -> Element:
+        # may include code span
+        return "double_emphasis", match.group("text")
+
+    def parse_emphasis(self, match: Match, state: State) -> Element:
+        # may include code span
+        return "emphasis", match.group("text") or match.group(1)
+
+    def parse_image_link(self, match: Match, state: State) -> Element:
+        """Pass through rest role."""
+        alt, src, target = match.groups()
+        return "image_link", src, target, alt
+
+    def parse_rest_role(self, match: Match, state: State) -> Element:
+        """Pass through rest role."""
+        return "rest_role", match.group(0)
+
+    def parse_rest_link(self, match: Match, state: State) -> Element:
+        """Pass through rest link."""
+        return "rest_link", match.group(0)
+
+    def parse_inline_math(self, match: Match, state: State) -> Element:
+        """Pass through rest link."""
+        return "inline_math", match.group(2)
+
+    def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
+        """Pass through rest link."""
+        marker = ":" if match.group(1) is None else ""
+        return "eol_literal_marker", marker
+
+    def no_underscore_emphasis(self):
+        self.DOUBLE_EMPHASIS = re.compile(
+            r"^\*{2}(?P<text>[\s\S]+?)\*{2}(?!\*)"  # **word**
+        )
+        self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
+
+    def __init__(self, renderer, *args, **kwargs):
+        # no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
+        disable_inline_math = kwargs.pop("disable_inline_math", False)
+        super().__init__(renderer, *args, **kwargs)
+        # if not _is_sphinx:
+        #    parse_options()
+        # if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
+        #    self.rules.no_underscore_emphasis()
+        inline_maths = "inline_math" in self.RULE_NAMES
+        if disable_inline_math:  # or getattr(options, "disable_inline_math", False):
+            if inline_maths:
+                self.RULE_NAMES = tuple(
+                    x for x in self.RUlE_NAMES if x != "inline_math"
+                )
+        elif not inline_maths:
+            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
diff --git a/m2r2/rst/renderer.py b/m2r2/rst/renderer.py
new file mode 100644
index 0000000..2285dd5
--- /dev/null
+++ b/m2r2/rst/renderer.py
@@ -0,0 +1,355 @@
+import os
+from urllib.parse import urlparse
+
+from docutils.utils import column_width
+from mistune.core import BaseRenderer
+
+_is_sphinx = False
+
+
+class RestRenderer(BaseRenderer):
+    _include_raw_html = False
+    # list_indent_re = re.compile(r"^(\s*(#\.|\*)\s)")
+    indent = " " * 3
+    list_marker = "{#__rest_list_mark__#}"
+    hmarks = {
+        1: "=",
+        2: "-",
+        3: "^",
+        4: "~",
+        5: '"',
+        6: "#",
+    }
+
+    def __init__(self, *args, **kwargs):
+        self.parse_relative_links = kwargs.pop("parse_relative_links", False)
+        self.anonymous_references = kwargs.pop("anonymous_references", False)
+        self.use_mermaid = kwargs.pop("use_mermaid", False)
+        super(RestRenderer, self).__init__(*args, **kwargs)
+        # if not _is_sphinx:
+        #    parse_options()
+        #    if getattr(options, "parse_relative_links", False):
+        #        self.parse_relative_links = options.parse_relative_links
+        #    if getattr(options, "anonymous_references", False):
+        #       self.anonymous_references = options.anonymous_references
+
+    def finalize(self, data):
+        return "".join(filter(lambda x: x is not None, data))
+
+    def _indent_block(self, block):
+        return "\n".join(
+            self.indent + line if line else "" for line in block.splitlines()
+        )
+
+    def _raw_html(self, html):
+        self._include_raw_html = True
+        return r"\ :raw-html-m2r:`{}`\ ".format(html)
+
+    def block_code(self, code, lang=None):
+        if lang == "math":
+            first_line = "\n.. math::\n\n"
+        elif lang == "mermaid" and self.use_mermaid:
+            first_line = "\n.. mermaid::\n\n"
+        elif lang:
+            first_line = "\n.. code-block:: {}\n\n".format(lang)
+        elif _is_sphinx:
+            first_line = "\n::\n\n"
+        else:
+            first_line = "\n.. code-block::\n\n"
+        return first_line + self._indent_block(code) + "\n"
+
+    def block_quote(self, text):
+        # text includes some empty line
+        return "\n..\n\n{}\n\n".format(self._indent_block(text.strip("\n")))
+
+    def block_text(self, text):
+        return text
+
+    def block_html(self, html):
+        """Rendering block level pure html content.
+
+        :param html: text content of the html snippet.
+        """
+        return "\n\n.. raw:: html\n\n" + self._indent_block(html) + "\n\n"
+
+    def header(self, text, level, raw=None):
+        """Rendering header/heading tags like ``<h1>`` ``<h2>``.
+
+        :param text: rendered text content for the header.
+        :param level: a number for the header level, for example: 1.
+        :param raw: raw text content of the header.
+        """
+        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
+
+    def heading(self, text, level, raw=None):
+        """Rendering header/heading tags like ``<h1>`` ``<h2>``.
+        :param text: rendered text content for the header.
+        :param level: a number for the header level, for example: 1.
+        :param raw: raw text content of the header.
+        """
+        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
+
+    def thematic_break(self):
+        """Rendering method for ``<hr>`` tag."""
+        return "\n----\n"
+
+    def list(self, body, ordered, level, start):
+        """Rendering list tags like ``<ul>`` and ``<ol>``.
+
+        :param body: body contents of the list.
+        :param ordered: whether this list is ordered or not.
+        """
+        mark = "#. " if ordered else "* "
+        lines = body.splitlines()
+        for i, line in enumerate(lines):
+            if line and not line.startswith(self.list_marker):
+                lines[i] = " " * len(mark) + line
+        return "\n{}\n".format("\n".join(lines)).replace(self.list_marker, mark)
+
+    def list_item(self, text, level):
+        """Rendering list item snippet. Like ``<li>``."""
+        return "\n" + self.list_marker + text
+
+    def paragraph(self, text):
+        """Rendering paragraph tags. Like ``<p>``."""
+        return "\n" + text + "\n"
+
+    def table(self, header, body):
+        """Rendering table element. Wrap header and body in it.
+
+        :param header: header part of the table.
+        :param body: body part of the table.
+        """
+        table = "\n.. list-table::\n"
+        if header and not header.isspace():
+            table = (
+                table
+                + self.indent
+                + ":header-rows: 1\n\n"
+                + self._indent_block(header)
+                + "\n"
+            )
+        else:
+            table = table + "\n"
+        table = table + self._indent_block(body) + "\n\n"
+        return table
+
+    def table_row(self, content):
+        """Rendering a table row. Like ``<tr>``.
+
+        :param content: content of current table row.
+        """
+        contents = content.splitlines()
+        if not contents:
+            return ""
+        clist = ["* " + contents[0]]
+        if len(contents) > 1:
+            for c in contents[1:]:
+                clist.append("  " + c)
+        return "\n".join(clist) + "\n"
+
+    def table_cell(self, content, **flags):
+        """Rendering a table cell. Like ``<th>`` ``<td>``.
+
+        :param content: content of current table cell.
+        :param header: whether this is header or not.
+        :param align: align of current table cell.
+        """
+        return "- " + content + "\n"
+
+    def double_emphasis(self, text):
+        """Rendering **strong** text.
+
+        :param text: text content for emphasis.
+        """
+        return r"\ **{}**\ ".format(text)
+
+    def emphasis(self, text):
+        """Rendering *emphasis* text.
+
+        :param text: text content for emphasis.
+        """
+        return r"\ *{}*\ ".format(text)
+
+    def strong(self, text):
+        return r"**{}**".format(text)
+
+    def codespan(self, text):
+        """Rendering inline `code` text.
+
+        :param text: text content for inline code.
+        """
+        if "``" not in text:
+            return r"\ ``{}``\ ".format(text)
+        else:
+            # actually, docutils split spaces in literal
+            return self._raw_html(
+                '<code class="docutils literal">'
+                '<span class="pre">{}</span>'
+                "</code>".format(text.replace("`", "&#96;"))
+            )
+
+    def linebreak(self):
+        """Rendering line break like ``<br>``."""
+        if self.options.get("use_xhtml"):
+            return self._raw_html("<br />") + "\n"
+        return self._raw_html("<br>") + "\n"
+
+    def strikethrough(self, text):
+        """Rendering ~~strikethrough~~ text.
+
+        :param text: text content for strikethrough.
+        """
+        return self._raw_html("<del>{}</del>".format(text))
+
+    def text(self, text):
+        """Rendering unformatted text.
+
+        :param text: text content.
+        """
+        return text
+
+    def autolink(self, link, is_email=False):
+        """Rendering a given link or email address.
+
+        :param link: link content or email address.
+        :param is_email: whether this is an email or not.
+        """
+        return link
+
+    def link(self, link, title, text):
+        """Rendering a given link with content and title.
+
+        :param link: href link for ``<a>`` tag.
+        :param title: title content for `title` attribute.
+        :param text: text content for description.
+        """
+        if self.anonymous_references:
+            underscore = "__"
+        else:
+            underscore = "_"
+        if title:
+            return self._raw_html(
+                '<a href="{link}" title="{title}">{text}</a>'.format(
+                    link=link, title=title, text=text
+                )
+            )
+        if not self.parse_relative_links:
+            return r"\ `{text} <{target}>`{underscore}\ ".format(
+                target=link, text=text, underscore=underscore
+            )
+        else:
+            url_info = urlparse(link)
+            if url_info.scheme:
+                return r"\ `{text} <{target}>`{underscore}\ ".format(
+                    target=link, text=text, underscore=underscore
+                )
+            else:
+                link_type = "doc"
+                anchor = url_info.fragment
+                if url_info.fragment:
+                    if url_info.path:
+                        # Can't link to anchors via doc directive.
+                        anchor = ""
+                    else:
+                        # Example: [text](#anchor)
+                        link_type = "ref"
+                doc_link = "{doc_name}{anchor}".format(
+                    # splittext approach works whether or not path is set. It
+                    # will return an empty string if unset, which leads to
+                    # anchor only ref.
+                    doc_name=os.path.splitext(url_info.path)[0],
+                    anchor=anchor,
+                )
+                return r"\ :{link_type}:`{text} <{doc_link}>`\ ".format(
+                    link_type=link_type, doc_link=doc_link, text=text
+                )
+
+    def image(self, src, title, text):
+        """Rendering a image with title and text.
+
+        :param src: source link of the image.
+        :param title: title text of the image.
+        :param text: alt text of the image.
+        """
+        # rst does not support title option
+        # and I couldn't find title attribute in HTML standard
+        return "\n".join(
+            [
+                "",
+                ".. image:: {}".format(src),
+                "   :target: {}".format(src),
+                "   :alt: {}".format(text),
+                "",
+            ]
+        )
+
+    def inline_html(self, html):
+        """Rendering span level pure html content.
+
+        :param html: text content of the html snippet.
+        """
+        return self._raw_html(html)
+
+    def newline(self):
+        """Rendering newline element."""
+        return ""
+
+    def footnote_ref(self, key, index):
+        """Rendering the ref anchor of a footnote.
+
+        :param key: identity key for the footnote.
+        :param index: the index count of current footnote.
+        """
+        return r"\ [#fn-{}]_\ ".format(key)
+
+    def footnote_item(self, key, text):
+        """Rendering a footnote item.
+
+        :param key: identity key for the footnote.
+        :param text: text content of the footnote.
+        """
+        return ".. [#fn-{0}] {1}\n".format(key, text.strip())
+
+    def footnotes(self, text):
+        """Wrapper for all footnotes.
+
+        :param text: contents of all footnotes.
+        """
+        if text:
+            return "\n\n" + text
+        else:
+            return ""
+
+    """Below outputs are for rst."""
+
+    def image_link(self, url, target, alt):
+        return "\n".join(
+            [
+                "",
+                ".. image:: {}".format(url),
+                "   :target: {}".format(target),
+                "   :alt: {}".format(alt),
+                "",
+            ]
+        )
+
+    def rest_role(self, text):
+        return text
+
+    def rest_link(self, text):
+        return text
+
+    def inline_math(self, math):
+        """Extension of recommonmark."""
+        return r":math:`{}`".format(math)
+
+    def eol_literal_marker(self, marker):
+        """Extension of recommonmark."""
+        return marker
+
+    def directive(self, text):
+        return "\n" + text
+
+    def rest_code_block(self, text):
+        return "\n\n"
diff --git a/m2r2/sphinx/__init__.py b/m2r2/sphinx/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/m2r2/sphinx/m2r2.py b/m2r2/sphinx/m2r2.py
new file mode 100644
index 0000000..51e59c0
--- /dev/null
+++ b/m2r2/sphinx/m2r2.py
@@ -0,0 +1,30 @@
+from m2r2.m2r2 import __version__
+from m2r2.parser import M2RParser
+from m2r2.rst.directives import MdInclude
+
+_is_sphinx = False
+
+
+def setup(app):
+    """When used for sphinx extension."""
+    global _is_sphinx
+    _is_sphinx = True
+    app.add_config_value("no_underscore_emphasis", False, "env")
+    app.add_config_value("m2r_parse_relative_links", False, "env")
+    app.add_config_value("m2r_anonymous_references", False, "env")
+    app.add_config_value("m2r_disable_inline_math", False, "env")
+    app.add_config_value(
+        "m2r_use_mermaid", "sphinxcontrib.mermaid" in app.config.extensions, "env"
+    )
+    try:
+        app.add_source_parser(".md", M2RParser)  # for older sphinx versions
+    except (TypeError, AttributeError):
+        app.add_source_suffix(".md", "markdown")
+        app.add_source_parser(M2RParser)
+    app.add_directive("mdinclude", MdInclude)
+    metadata = dict(
+        version=__version__,
+        parallel_read_safe=True,
+        parallel_write_safe=True,
+    )
+    return metadata
diff --git a/m2r2/typing.py b/m2r2/typing.py
new file mode 100644
index 0000000..59ef277
--- /dev/null
+++ b/m2r2/typing.py
@@ -0,0 +1,5 @@
+from typing import Any, Dict, Tuple
+
+State = Dict[str, Any]
+Token = Dict[str, Any]
+Element = Tuple[str, ...]
diff --git a/requirements-test.txt b/requirements-test.txt
index 0b570ef..0dc9a78 100644
--- a/requirements-test.txt
+++ b/requirements-test.txt
@@ -1,4 +1,3 @@
-mock; python_version < '3.3'
 pytest
 pytest-cov
 six
diff --git a/setup.py b/setup.py
index eecbe88..8c5e43d 100644
--- a/setup.py
+++ b/setup.py
@@ -18,7 +18,7 @@
         readme = f.read()
 
 
-__version__ = "0.3.3.post2"
+__version__ = "1.0.0"
 
 install_requires = ["mistune>=2.0.0,<3.0", "docutils>=0.16,<1.0"]
 test_requirements = ["pygments"]
@@ -57,4 +57,5 @@
     test_suite="tests",
     tests_require=test_requirements,
     python_requires=">=3.7",
+    packages=["m2r2"],
 )

From 61593081fadeaa11adb726432aecac3e50d28989 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 30 Jan 2023 04:13:17 -0300
Subject: [PATCH 07/22] pytest running

---
 m2r2/rst/renderer.py   |   2 +-
 tests/test_cli.py      |  90 +++--
 tests/test_renderer.py | 724 ++++++++++++++++++++++-------------------
 3 files changed, 439 insertions(+), 377 deletions(-)

diff --git a/m2r2/rst/renderer.py b/m2r2/rst/renderer.py
index 2285dd5..6a830cf 100644
--- a/m2r2/rst/renderer.py
+++ b/m2r2/rst/renderer.py
@@ -2,7 +2,7 @@
 from urllib.parse import urlparse
 
 from docutils.utils import column_width
-from mistune.core import BaseRenderer
+from mistune.renderers import BaseRenderer
 
 _is_sphinx = False
 
diff --git a/tests/test_cli.py b/tests/test_cli.py
index e55826f..b02e0c0 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -10,24 +10,15 @@
 from unittest import TestCase
 import subprocess
 import six
-from m2r2 import parse_from_file, main, options
+from m2r2.cli.m2r2 import parse_from_file, main, options
 
-if sys.version_info < (3,):
-    from mock import patch
+from unittest.mock import patch
 
-    _builtin = '__builtin__'
-    from codecs import open as _open
-    from functools import partial
-
-    open = partial(_open, encoding='utf-8')
-else:
-    from unittest.mock import patch
-
-    _builtin = 'builtins'
+_builtin = "builtins"
 
 curdir = path.dirname(path.abspath(__file__))
-test_md = path.join(curdir, 'test.md')
-test_rst = path.join(curdir, 'test.rst')
+test_md = path.join(curdir, "test.md")
+test_rst = path.join(curdir, "test.rst")
 
 
 class TestConvert(TestCase):
@@ -45,19 +36,22 @@ def setUp(self):
 
     def tearDown(self):
         sys.argv = self._orig_argv
-        with open(test_rst, 'w') as f:
+        with open(test_rst, "w") as f:
             f.write(self._orig_rst)
 
     def test_no_file(self):
-        p = subprocess.Popen([sys.executable, '-m', 'm2r2'], stdout=subprocess.PIPE,)
+        p = subprocess.Popen(
+            [sys.executable, "-m", "m2r2"],
+            stdout=subprocess.PIPE,
+        )
         p.wait()
         self.assertEqual(p.returncode, 0)
         with p.stdout as buffer:
             message = buffer.read().decode()
-        self.assertIn('usage', message)
-        self.assertIn('underscore-emphasis', message)
-        self.assertIn('anonymous-references', message)
-        self.assertIn('inline-math', message)
+        self.assertIn("usage", message)
+        self.assertIn("underscore-emphasis", message)
+        self.assertIn("anonymous-references", message)
+        self.assertIn("inline-math", message)
         six.assertRegex(self, message, r"option(s|al arguments):")
 
     def test_parse_file(self):
@@ -67,20 +61,20 @@ def test_parse_file(self):
         self.assertEqual(output.strip(), expected.strip())
 
     def test_dryrun(self):
-        sys.argv = [sys.argv[0], '--dry-run', test_md]
-        target_file = path.join(curdir, 'test.rst')
+        sys.argv = [sys.argv[0], "--dry-run", test_md]
+        target_file = path.join(curdir, "test.rst")
         with open(target_file) as f:
             rst = f.read()
         os.remove(target_file)
         self.assertFalse(path.exists(target_file))
-        with patch(_builtin + '.print') as m:
+        with patch(_builtin + ".print") as m:
             main()
         self.assertFalse(path.exists(target_file))
         m.assert_called_once_with(rst)
 
     def test_write_file(self):
         sys.argv = [sys.argv[0], test_md]
-        target_file = path.join(curdir, 'test.rst')
+        target_file = path.join(curdir, "test.rst")
         os.remove(target_file)
         self.assertFalse(path.exists(target_file))
         main()
@@ -88,53 +82,53 @@ def test_write_file(self):
 
     def test_overwrite_file(self):
         sys.argv = [sys.argv[0], test_md]
-        target_file = path.join(curdir, 'test.rst')
-        with open(target_file, 'w') as f:
-            f.write('test')
+        target_file = path.join(curdir, "test.rst")
+        with open(target_file, "w") as f:
+            f.write("test")
         with open(target_file) as f:
             first_line = f.readline()
-        self.assertIn('test', first_line)
-        with patch(_builtin + '.input', return_value='y'):
+        self.assertIn("test", first_line)
+        with patch(_builtin + ".input", return_value="y"):
             main()
         self.assertTrue(path.exists(target_file))
         with open(target_file) as f:
             first_line = f.readline()
-        self.assertNotIn('test', first_line)
+        self.assertNotIn("test", first_line)
 
     def test_overwrite_option(self):
-        sys.argv = [sys.argv[0], '--overwrite', test_md]
-        target_file = path.join(curdir, 'test.rst')
-        with open(target_file, 'w') as f:
-            f.write('test')
+        sys.argv = [sys.argv[0], "--overwrite", test_md]
+        target_file = path.join(curdir, "test.rst")
+        with open(target_file, "w") as f:
+            f.write("test")
         with open(target_file) as f:
             first_line = f.readline()
-        self.assertIn('test', first_line)
-        with patch(_builtin + '.input', return_value='y') as m_input:
-            with patch(_builtin + '.print') as m_print:
+        self.assertIn("test", first_line)
+        with patch(_builtin + ".input", return_value="y") as m_input:
+            with patch(_builtin + ".print") as m_print:
                 main()
         self.assertTrue(path.exists(target_file))
         self.assertFalse(m_input.called)
         self.assertFalse(m_print.called)
         with open(target_file) as f:
             first_line = f.readline()
-        self.assertNotIn('test', first_line)
+        self.assertNotIn("test", first_line)
 
     def test_underscore_option(self):
-        sys.argv = [sys.argv[0], '--no-underscore-emphasis', '--dry-run', test_md]
-        with patch(_builtin + '.print') as m:
+        sys.argv = [sys.argv[0], "--no-underscore-emphasis", "--dry-run", test_md]
+        with patch(_builtin + ".print") as m:
             main()
-        self.assertIn('__content__', m.call_args[0][0])
-        self.assertNotIn('**content**', m.call_args[0][0])
+        self.assertIn("__content__", m.call_args[0][0])
+        self.assertNotIn("**content**", m.call_args[0][0])
 
     def test_anonymous_reference_option(self):
-        sys.argv = [sys.argv[0], '--anonymous-references', '--dry-run', test_md]
-        with patch(_builtin + '.print') as m:
+        sys.argv = [sys.argv[0], "--anonymous-references", "--dry-run", test_md]
+        with patch(_builtin + ".print") as m:
             main()
         self.assertIn("`A link to GitHub <http://github.com/>`__", m.call_args[0][0])
 
     def test_disable_inline_math(self):
-        sys.argv = [sys.argv[0], '--disable-inline-math', '--dry-run', test_md]
-        with patch(_builtin + '.print') as m:
+        sys.argv = [sys.argv[0], "--disable-inline-math", "--dry-run", test_md]
+        with patch(_builtin + ".print") as m:
             main()
-        self.assertIn('``$E = mc^2$``', m.call_args[0][0])
-        self.assertNotIn(':math:', m.call_args[0][0])
+        self.assertIn("``$E = mc^2$``", m.call_args[0][0])
+        self.assertNotIn(":math:", m.call_args[0][0])
diff --git a/tests/test_renderer.py b/tests/test_renderer.py
index 3c28d5d..f2623b9 100644
--- a/tests/test_renderer.py
+++ b/tests/test_renderer.py
@@ -7,7 +7,8 @@
 
 from docutils import io
 from docutils.core import Publisher
-from m2r2 import PROLOG, convert
+from m2r2 import convert
+from m2r2.constants import PROLOG
 
 
 class RendererTestBase(TestCase):
@@ -30,13 +31,13 @@ def check_rst(self, rst):
             destination_class=io.StringOutput,
         )
         pub.set_components(
-            reader_name='standalone',
-            parser_name='restructuredtext',
-            writer_name='pseudoxml',
+            reader_name="standalone",
+            parser_name="restructuredtext",
+            writer_name="pseudoxml",
         )
         pub.process_programmatic_settings(
             settings_spec=None,
-            settings_overrides={'output_encoding': 'unicode'},
+            settings_overrides={"output_encoding": "unicode"},
             config_section=None,
         )
         pub.set_source(rst, source_path=None)
@@ -50,301 +51,356 @@ class TestBasic(RendererTestBase):
     def test_fail_rst(self):
         with self.assertRaises(AssertionError):
             # This check should be failed and report warning
-            self.check_rst('```')
+            self.check_rst("```")
 
     def test_simple_paragraph(self):
-        src = 'this is a sentence.\n'
+        src = "this is a sentence.\n"
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src)
+        self.assertEqual(out, "\n" + src)
 
     def test_multiline_paragraph(self):
-        src = '\n'.join(['first sentence.', 'second sentence.',])
+        src = "\n".join(
+            [
+                "first sentence.",
+                "second sentence.",
+            ]
+        )
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_multi_paragraph(self):
-        src = '\n'.join(['first paragraph.', '', 'second paragraph.',])
+        src = "\n".join(
+            [
+                "first paragraph.",
+                "",
+                "second paragraph.",
+            ]
+        )
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_hr(self):
-        src = 'a\n\n---\n\nb'
+        src = "a\n\n---\n\nb"
         out = self.conv(src)
-        self.assertEqual(out, '\na\n\n----\n\nb\n')
+        self.assertEqual(out, "\na\n\n----\n\nb\n")
 
     def test_linebreak(self):
-        src = 'abc def  \nghi'
+        src = "abc def  \nghi"
         out = self.conv(src)
         self.assertEqual(
-            out, PROLOG + '\nabc def\\ :raw-html-m2r:`<br>`\nghi' + '\n',
+            out,
+            PROLOG + "\nabc def\\ :raw-html-m2r:`<br>`\nghi" + "\n",
         )
 
 
 class TestInlineMarkdown(RendererTestBase):
     def test_inline_code(self):
-        src = '`a`'
+        src = "`a`"
         out = self.conv(src)
-        self.assertEqual(out.replace('\n', ''), '``a``')
+        self.assertEqual(out.replace("\n", ""), "``a``")
 
     def test_inline_code_with_backticks(self):
-        src = '```a``a```'
+        src = "```a``a```"
         out = self.conv(src)
         self.assertEqual(
             out.strip(),
-            '.. role:: raw-html-m2r(raw)\n'
-            '   :format: html\n\n\n'
+            ".. role:: raw-html-m2r(raw)\n"
+            "   :format: html\n\n\n"
             ':raw-html-m2r:`<code class="docutils literal">'
             '<span class="pre">a&#96;&#96;a</span></code>`',
         )
 
     def test_strikethrough(self):
-        src = '~~a~~'
+        src = "~~a~~"
         self.conv(src)
 
     def test_emphasis(self):
-        src = '*a*'
+        src = "*a*"
         out = self.conv(src)
-        self.assertEqual(out.replace('\n', ''), '*a*')
+        self.assertEqual(out.replace("\n", ""), "*a*")
 
     def test_emphasis_(self):
-        src = '_a_'
+        src = "_a_"
         out = self.conv(src)
-        self.assertEqual(out.replace('\n', ''), '*a*')
+        self.assertEqual(out.replace("\n", ""), "*a*")
 
     def test_emphasis_no_(self):
-        src = '_a_'
+        src = "_a_"
         out = self.conv(src, no_underscore_emphasis=True)
-        self.assertEqual(out.replace('\n', ''), '_a_')
+        self.assertEqual(out.replace("\n", ""), "_a_")
 
     def test_double_emphasis(self):
-        src = '**a**'
+        src = "**a**"
         out = self.conv(src)
-        self.assertEqual(out.replace('\n', ''), '**a**')
+        self.assertEqual(out.replace("\n", ""), "**a**")
 
     def test_double_emphasis__(self):
-        src = '__a__'
+        src = "__a__"
         out = self.conv(src)
-        self.assertEqual(out.replace('\n', ''), '**a**')
+        self.assertEqual(out.replace("\n", ""), "**a**")
 
     def test_emphasis_no__(self):
-        src = '__a__'
+        src = "__a__"
         out = self.conv(src, no_underscore_emphasis=True)
-        self.assertEqual(out.replace('\n', ''), '__a__')
+        self.assertEqual(out.replace("\n", ""), "__a__")
 
     def test_autolink(self):
-        src = 'link to http://example.com/ in sentence.'
+        src = "link to http://example.com/ in sentence."
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_link(self):
-        src = 'this is a [link](http://example.com/).'
+        src = "this is a [link](http://example.com/)."
         out = self.conv(src)
-        self.assertEqual(out, '\nthis is a `link <http://example.com/>`_.\n')
+        self.assertEqual(out, "\nthis is a `link <http://example.com/>`_.\n")
 
     def test_anonymous_link(self):
-        src = 'this is a [link](http://example.com/).'
+        src = "this is a [link](http://example.com/)."
         out = self.conv(src, anonymous_references=True)
-        self.assertEqual(out, '\nthis is a `link <http://example.com/>`__.\n')
+        self.assertEqual(out, "\nthis is a `link <http://example.com/>`__.\n")
 
     def test_link_with_rel_link_enabled(self):
-        src = 'this is a [link](http://example.com/).'
+        src = "this is a [link](http://example.com/)."
         out = self.conv_no_check(src, parse_relative_links=True)
-        self.assertEqual(out, '\nthis is a `link <http://example.com/>`_.\n')
+        self.assertEqual(out, "\nthis is a `link <http://example.com/>`_.\n")
 
     def test_anonymous_link_with_rel_link_enabled(self):
-        src = 'this is a [link](http://example.com/).'
+        src = "this is a [link](http://example.com/)."
         out = self.conv_no_check(
             src, parse_relative_links=True, anonymous_references=True
         )
-        self.assertEqual(out, '\nthis is a `link <http://example.com/>`__.\n')
+        self.assertEqual(out, "\nthis is a `link <http://example.com/>`__.\n")
 
     def test_anchor(self):
-        src = 'this is an [anchor](#anchor).'
+        src = "this is an [anchor](#anchor)."
         out = self.conv_no_check(src, parse_relative_links=True)
-        self.assertEqual(out, '\nthis is an :ref:`anchor <anchor>`.\n')
+        self.assertEqual(out, "\nthis is an :ref:`anchor <anchor>`.\n")
 
     def test_relative_link(self):
-        src = 'this is a [relative link](a_file.md).'
+        src = "this is a [relative link](a_file.md)."
         out = self.conv_no_check(src, parse_relative_links=True)
-        self.assertEqual(out, '\nthis is a :doc:`relative link <a_file>`.\n')
+        self.assertEqual(out, "\nthis is a :doc:`relative link <a_file>`.\n")
 
     def test_relative_link_with_anchor(self):
-        src = 'this is a [relative link](a_file.md#anchor).'
+        src = "this is a [relative link](a_file.md#anchor)."
         out = self.conv_no_check(src, parse_relative_links=True)
-        self.assertEqual(out, '\nthis is a :doc:`relative link <a_file>`.\n')
+        self.assertEqual(out, "\nthis is a :doc:`relative link <a_file>`.\n")
 
     def test_link_title(self):
         src = 'this is a [link](http://example.com/ "example").'
         out = self.conv(src)
         self.assertEqual(
             out,
-            '.. role:: raw-html-m2r(raw)\n'
-            '   :format: html\n\n\n'
-            'this is a :raw-html-m2r:'
+            ".. role:: raw-html-m2r(raw)\n"
+            "   :format: html\n\n\n"
+            "this is a :raw-html-m2r:"
             '`<a href="http://example.com/" title="example">link</a>`.\n',
         )
 
     def test_image_link(self):
-        src = '[![Alt Text](image_taget_url)](link_target_url)'
+        src = "[![Alt Text](image_taget_url)](link_target_url)"
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n\n.. image:: image_taget_url\n'
-            '   :target: link_target_url\n   :alt: Alt Text\n\n',
+            "\n\n.. image:: image_taget_url\n"
+            "   :target: link_target_url\n   :alt: Alt Text\n\n",
         )
 
     def test_rest_role(self):
-        src = 'a :code:`some code` inline.'
+        src = "a :code:`some code` inline."
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_rest_role2(self):
-        src = 'a `some code`:code: inline.'
+        src = "a `some code`:code: inline."
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_rest_link(self):
-        src = 'a `RefLink <http://example.com>`_ here.'
+        src = "a `RefLink <http://example.com>`_ here."
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_rest_link_and_role(self):
-        src = 'a :code:`a` and `RefLink <http://example.com>`_ here.'
+        src = "a :code:`a` and `RefLink <http://example.com>`_ here."
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_rest_link_and_role2(self):
-        src = 'a `a`:code: and `RefLink <http://example.com>`_ here.'
+        src = "a `a`:code: and `RefLink <http://example.com>`_ here."
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src + '\n')
+        self.assertEqual(out, "\n" + src + "\n")
 
     def test_rest_role_incomplete(self):
-        src = 'a co:`de` and `RefLink <http://example.com>`_ here.'
+        src = "a co:`de` and `RefLink <http://example.com>`_ here."
         out = self.conv(src)
         self.assertEqual(
-            out, '\na co:\\ ``de`` and `RefLink <http://example.com>`_ here.\n',
+            out,
+            "\na co:\\ ``de`` and `RefLink <http://example.com>`_ here.\n",
         )
 
     def test_rest_role_incomplete2(self):
-        src = 'a `RefLink <http://example.com>`_ and co:`de` here.'
+        src = "a `RefLink <http://example.com>`_ and co:`de` here."
         out = self.conv(src)
         self.assertEqual(
-            out, '\na `RefLink <http://example.com>`_ and co:\\ ``de`` here.\n',
+            out,
+            "\na `RefLink <http://example.com>`_ and co:\\ ``de`` here.\n",
         )
 
     def test_rest_role_with_code(self):
-        src = 'a `code` and :code:`rest` here.'
+        src = "a `code` and :code:`rest` here."
         out = self.conv(src)
-        self.assertEqual(out, '\na ``code`` and :code:`rest` here.\n')
+        self.assertEqual(out, "\na ``code`` and :code:`rest` here.\n")
 
     def test_rest2_role_with_code(self):
-        src = 'a `code` and `rest`:code: here.'
+        src = "a `code` and `rest`:code: here."
         out = self.conv(src)
-        self.assertEqual(out, '\na ``code`` and `rest`:code: here.\n')
+        self.assertEqual(out, "\na ``code`` and `rest`:code: here.\n")
 
     def test_code_with_rest_role(self):
-        src = 'a :code:`rest` and `code` here.'
+        src = "a :code:`rest` and `code` here."
         out = self.conv(src)
-        self.assertEqual(out, '\na :code:`rest` and ``code`` here.\n')
+        self.assertEqual(out, "\na :code:`rest` and ``code`` here.\n")
 
     def test_code_with_rest_role2(self):
-        src = 'a `rest`:code: and `code` here.'
+        src = "a `rest`:code: and `code` here."
         out = self.conv(src)
-        self.assertEqual(out, '\na `rest`:code: and ``code`` here.\n')
+        self.assertEqual(out, "\na `rest`:code: and ``code`` here.\n")
 
     def test_rest_link_with_code(self):
-        src = 'a `RefLink <a>`_ and `code` here.'
+        src = "a `RefLink <a>`_ and `code` here."
         out = self.conv(src)
-        self.assertEqual(out, '\na `RefLink <a>`_ and ``code`` here.\n')
+        self.assertEqual(out, "\na `RefLink <a>`_ and ``code`` here.\n")
 
     def test_code_with_rest_link(self):
-        src = 'a `code` and `RefLink <a>`_ here.'
+        src = "a `code` and `RefLink <a>`_ here."
         out = self.conv(src)
-        self.assertEqual(out, '\na ``code`` and `RefLink <a>`_ here.\n')
+        self.assertEqual(out, "\na ``code`` and `RefLink <a>`_ here.\n")
 
     def test_inline_math(self):
-        src = 'this is `$E = mc^2$` inline math.'
+        src = "this is `$E = mc^2$` inline math."
         out = self.conv(src)
-        self.assertEqual(out, '\nthis is :math:`E = mc^2` inline math.\n')
+        self.assertEqual(out, "\nthis is :math:`E = mc^2` inline math.\n")
 
     def test_disable_inline_math(self):
-        src = 'this is `$E = mc^2$` inline math.'
+        src = "this is `$E = mc^2$` inline math."
         out = self.conv(src, disable_inline_math=True)
-        self.assertEqual(out, '\nthis is ``$E = mc^2$`` inline math.\n')
+        self.assertEqual(out, "\nthis is ``$E = mc^2$`` inline math.\n")
 
     def test_inline_html(self):
-        src = 'this is <s>html</s>.'
+        src = "this is <s>html</s>."
         out = self.conv(src)
-        self.assertEqual(out, PROLOG + '\nthis is :raw-html-m2r:`<s>html</s>`.\n')
+        self.assertEqual(out, PROLOG + "\nthis is :raw-html-m2r:`<s>html</s>`.\n")
 
     def test_block_html(self):
-        src = '<h1>title</h1>'
+        src = "<h1>title</h1>"
         out = self.conv(src)
-        self.assertEqual(out, '\n\n.. raw:: html\n\n   <h1>title</h1>\n\n')
+        self.assertEqual(out, "\n\n.. raw:: html\n\n   <h1>title</h1>\n\n")
 
 
 class TestBlockQuote(RendererTestBase):
     def test_block_quote(self):
-        src = '> q1\n> q2'
+        src = "> q1\n> q2"
         out = self.conv(src)
-        self.assertEqual(out, '\n..\n\n   q1\n   q2\n\n')
+        self.assertEqual(out, "\n..\n\n   q1\n   q2\n\n")
 
     def test_block_quote_nested(self):
-        src = '> q1\n> > q2'
+        src = "> q1\n> > q2"
         out = self.conv(src)
         # one extra empty line is inserted, but still valid rst anyway
-        self.assertEqual(out, '\n..\n\n   q1\n\n   ..\n\n      q2\n\n')
+        self.assertEqual(out, "\n..\n\n   q1\n\n   ..\n\n      q2\n\n")
 
-    @skip('markdown does not support dedent in block quote')
+    @skip("markdown does not support dedent in block quote")
     def test_block_quote_nested_2(self):
-        src = '> q1\n> > q2\n> q3'
+        src = "> q1\n> > q2\n> q3"
         out = self.conv(src)
-        self.assertEqual(out, '\n..\n\n   q1\n\n   ..\n      q2\n\n   q3\n\n')
+        self.assertEqual(out, "\n..\n\n   q1\n\n   ..\n      q2\n\n   q3\n\n")
 
 
 class TestCodeBlock(RendererTestBase):
     def test_plain_code_block(self):
-        src = '\n'.join(['```', 'pip install sphinx', '```',])
+        src = "\n".join(
+            [
+                "```",
+                "pip install sphinx",
+                "```",
+            ]
+        )
         out = self.conv(src)
-        self.assertEqual(out, '\n.. code-block::\n\n   pip install sphinx\n')
+        self.assertEqual(out, "\n.. code-block::\n\n   pip install sphinx\n")
 
     def test_plain_code_block_tilda(self):
-        src = '\n'.join(['~~~', 'pip install sphinx', '~~~',])
+        src = "\n".join(
+            [
+                "~~~",
+                "pip install sphinx",
+                "~~~",
+            ]
+        )
         out = self.conv(src)
-        self.assertEqual(out, '\n.. code-block::\n\n   pip install sphinx\n')
+        self.assertEqual(out, "\n.. code-block::\n\n   pip install sphinx\n")
 
     def test_code_block_math(self):
-        src = '\n'.join(['```math', 'E = mc^2', '```',])
+        src = "\n".join(
+            [
+                "```math",
+                "E = mc^2",
+                "```",
+            ]
+        )
         out = self.conv(src)
-        self.assertEqual(out, '\n.. math::\n\n   E = mc^2\n')
+        self.assertEqual(out, "\n.. math::\n\n   E = mc^2\n")
 
     def test_plain_code_block_indent(self):
-        src = '\n'.join(['```', 'pip install sphinx', '    new line', '```',])
+        src = "\n".join(
+            [
+                "```",
+                "pip install sphinx",
+                "    new line",
+                "```",
+            ]
+        )
         out = self.conv(src)
         self.assertEqual(
-            out, '\n.. code-block::\n\n   pip install sphinx\n       new line\n',
+            out,
+            "\n.. code-block::\n\n   pip install sphinx\n       new line\n",
         )
 
     def test_python_code_block(self):
-        src = '\n'.join(['```python', 'print(1)', '```',])
+        src = "\n".join(
+            [
+                "```python",
+                "print(1)",
+                "```",
+            ]
+        )
         out = self.conv(src)
-        self.assertEqual(out, '\n.. code-block:: python\n\n   print(1)\n')
+        self.assertEqual(out, "\n.. code-block:: python\n\n   print(1)\n")
 
     def test_python_code_block_indent(self):
-        src = '\n'.join(['```python', 'def a(i):', '    print(i)', '```',])
+        src = "\n".join(
+            [
+                "```python",
+                "def a(i):",
+                "    print(i)",
+                "```",
+            ]
+        )
         out = self.conv(src)
         self.assertEqual(
-            out, '\n.. code-block:: python\n\n   def a(i):\n       print(i)\n',
+            out,
+            "\n.. code-block:: python\n\n   def a(i):\n       print(i)\n",
         )
 
 
 class TestImage(RendererTestBase):
     def test_image(self):
-        src = '![alt text](a.png)'
+        src = "![alt text](a.png)"
         out = self.conv(src)
         # first and last newline is inserted by paragraph
         self.assertEqual(
-            out, '\n\n.. image:: a.png\n   :target: a.png\n   :alt: alt text\n\n',
+            out,
+            "\n\n.. image:: a.png\n   :target: a.png\n   :alt: alt text\n\n",
         )
 
     def test_image_title(self):
@@ -355,256 +411,268 @@ def test_image_title(self):
 
 class TestHeading(RendererTestBase):
     def test_heading(self):
-        src = '# head 1'
+        src = "# head 1"
         out = self.conv(src)
-        self.assertEqual(out, '\nhead 1\n' + '=' * 6 + '\n')
+        self.assertEqual(out, "\nhead 1\n" + "=" * 6 + "\n")
 
     def test_heading_multibyte(self):
-        src = '# マルチバイト文字\n'
+        src = "# マルチバイト文字\n"
         out = self.conv(src)
-        self.assertEqual(out, '\nマルチバイト文字\n' + '=' * 16 + '\n')
+        self.assertEqual(out, "\nマルチバイト文字\n" + "=" * 16 + "\n")
 
 
 class TestList(RendererTestBase):
     def test_ul(self):
-        src = '* list'
+        src = "* list"
         out = self.conv(src)
-        self.assertEqual(out, '\n\n* list\n')
+        self.assertEqual(out, "\n\n* list\n")
 
     def test_ol(self):
-        src = '1. list'
+        src = "1. list"
         out = self.conv(src)
-        self.assertEqual(out, '\n\n#. list\n')
+        self.assertEqual(out, "\n\n#. list\n")
 
     def test_nested_ul(self):
-        src = '\n'.join(
-            ['* list 1', '* list 2', '  * list 2.1', '  * list 2.2', '* list 3',]
+        src = "\n".join(
+            [
+                "* list 1",
+                "* list 2",
+                "  * list 2.1",
+                "  * list 2.2",
+                "* list 3",
+            ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n\n* list 1\n'
-            '* list 2\n\n'
-            '  * list 2.1\n'
-            '  * list 2.2\n\n'
-            '* list 3\n',
+            "\n\n* list 1\n"
+            "* list 2\n\n"
+            "  * list 2.1\n"
+            "  * list 2.2\n\n"
+            "* list 3\n",
         )
 
     def test_nested_ul_2(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                '* list 1',
-                '* list 2',
-                '  * list 2.1',
-                '  * list 2.2',
-                '    * list 2.2.1',
-                '    * list 2.2.2',
-                '* list 3',
+                "* list 1",
+                "* list 2",
+                "  * list 2.1",
+                "  * list 2.2",
+                "    * list 2.2.1",
+                "    * list 2.2.2",
+                "* list 3",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n\n* list 1\n'
-            '* list 2\n\n'
-            '  * list 2.1\n'
-            '  * list 2.2\n\n'
-            '    * list 2.2.1\n'
-            '    * list 2.2.2\n\n'
-            '* list 3\n',
+            "\n\n* list 1\n"
+            "* list 2\n\n"
+            "  * list 2.1\n"
+            "  * list 2.2\n\n"
+            "    * list 2.2.1\n"
+            "    * list 2.2.2\n\n"
+            "* list 3\n",
         )
 
     def test_nested_ol(self):
-        src = '\n'.join(
-            ['1. list 1', '2. list 2', '  2. list 2.1', '  3. list 2.2', '3. list 3',]
+        src = "\n".join(
+            [
+                "1. list 1",
+                "2. list 2",
+                "  2. list 2.1",
+                "  3. list 2.2",
+                "3. list 3",
+            ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n\n#. list 1\n'
-            '#. list 2\n'
-            '\n'
-            '   #. list 2.1\n'
-            '   #. list 2.2\n'
-            '\n'
-            '#. list 3\n',
+            "\n\n#. list 1\n"
+            "#. list 2\n"
+            "\n"
+            "   #. list 2.1\n"
+            "   #. list 2.2\n"
+            "\n"
+            "#. list 3\n",
         )
 
     def test_nested_ol_2(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                '1. list 1',
-                '2. list 2',
-                '  3. list 2.1',
-                '  4. list 2.2',
-                '    5. list 2.2.1',
-                '    6. list 2.2.2',
-                '7. list 3',
+                "1. list 1",
+                "2. list 2",
+                "  3. list 2.1",
+                "  4. list 2.2",
+                "    5. list 2.2.1",
+                "    6. list 2.2.2",
+                "7. list 3",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '\n\n#. list 1',
-                    '#. list 2',
-                    '',
-                    '   #. list 2.1',
-                    '   #. list 2.2',
-                    '',
-                    '      #. list 2.2.1',
-                    '      #. list 2.2.2',
-                    '',
-                    '#. list 3\n',
+                    "\n\n#. list 1",
+                    "#. list 2",
+                    "",
+                    "   #. list 2.1",
+                    "   #. list 2.2",
+                    "",
+                    "      #. list 2.2.1",
+                    "      #. list 2.2.2",
+                    "",
+                    "#. list 3\n",
                 ]
             ),
         )
 
     def test_nested_mixed_1(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                '1. list 1',
-                '2. list 2',
-                '  * list 2.1',
-                '  * list 2.2',
-                '    1. list 2.2.1',
-                '    2. list 2.2.2',
-                '7. list 3',
+                "1. list 1",
+                "2. list 2",
+                "  * list 2.1",
+                "  * list 2.2",
+                "    1. list 2.2.1",
+                "    2. list 2.2.2",
+                "7. list 3",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '\n\n#. list 1',
-                    '#. list 2',
-                    '',
-                    '   * list 2.1',
-                    '   * list 2.2',
-                    '',
-                    '     #. list 2.2.1',
-                    '     #. list 2.2.2',
-                    '',
-                    '#. list 3\n',
+                    "\n\n#. list 1",
+                    "#. list 2",
+                    "",
+                    "   * list 2.1",
+                    "   * list 2.2",
+                    "",
+                    "     #. list 2.2.1",
+                    "     #. list 2.2.2",
+                    "",
+                    "#. list 3\n",
                 ]
             ),
         )
 
     def test_nested_multiline_1(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                '* list 1',
-                '  list 1 cont',
-                '* list 2',
-                '  list 2 cont',
-                '  * list 2.1',
-                '    list 2.1 cont',
-                '  * list 2.2',
-                '    list 2.2 cont',
-                '    * list 2.2.1',
-                '    * list 2.2.2',
-                '* list 3',
+                "* list 1",
+                "  list 1 cont",
+                "* list 2",
+                "  list 2 cont",
+                "  * list 2.1",
+                "    list 2.1 cont",
+                "  * list 2.2",
+                "    list 2.2 cont",
+                "    * list 2.2.1",
+                "    * list 2.2.2",
+                "* list 3",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '\n\n* list 1',
-                    '  list 1 cont',
-                    '* list 2',
-                    '  list 2 cont',
-                    '',
-                    '  * list 2.1',
-                    '    list 2.1 cont',
-                    '  * list 2.2',
-                    '    list 2.2 cont',
-                    '',
-                    '    * list 2.2.1',
-                    '    * list 2.2.2',
-                    '',
-                    '* list 3\n',
+                    "\n\n* list 1",
+                    "  list 1 cont",
+                    "* list 2",
+                    "  list 2 cont",
+                    "",
+                    "  * list 2.1",
+                    "    list 2.1 cont",
+                    "  * list 2.2",
+                    "    list 2.2 cont",
+                    "",
+                    "    * list 2.2.1",
+                    "    * list 2.2.2",
+                    "",
+                    "* list 3\n",
                 ]
             ),
         )
 
     def test_nested_multiline_2(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                '1. list 1',
-                '  list 1 cont',
-                '1. list 2',
-                '  list 2 cont',
-                '  1. list 2.1',
-                '    list 2.1 cont',
-                '  1. list 2.2',
-                '    list 2.2 cont',
-                '    1. list 2.2.1',
-                '    1. list 2.2.2',
-                '1. list 3',
+                "1. list 1",
+                "  list 1 cont",
+                "1. list 2",
+                "  list 2 cont",
+                "  1. list 2.1",
+                "    list 2.1 cont",
+                "  1. list 2.2",
+                "    list 2.2 cont",
+                "    1. list 2.2.1",
+                "    1. list 2.2.2",
+                "1. list 3",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '\n\n#. list 1',
-                    '   list 1 cont',
-                    '#. list 2',
-                    '   list 2 cont',
-                    '',
-                    '   #. list 2.1',
-                    '      list 2.1 cont',
-                    '   #. list 2.2',
-                    '      list 2.2 cont',
-                    '',
-                    '      #. list 2.2.1',
-                    '      #. list 2.2.2',
-                    '',
-                    '#. list 3\n',
+                    "\n\n#. list 1",
+                    "   list 1 cont",
+                    "#. list 2",
+                    "   list 2 cont",
+                    "",
+                    "   #. list 2.1",
+                    "      list 2.1 cont",
+                    "   #. list 2.2",
+                    "      list 2.2 cont",
+                    "",
+                    "      #. list 2.2.1",
+                    "      #. list 2.2.2",
+                    "",
+                    "#. list 3\n",
                 ]
             ),
         )
 
     def test_nested_multiline_3(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                '1. list 1',
-                '  list 1 cont',
-                '1. list 2',
-                '  list 2 cont',
-                '  * list 2.1',
-                '    list 2.1 cont',
-                '  * list 2.2',
-                '    list 2.2 cont',
-                '    1. list 2.2.1',
-                '    1. list 2.2.2',
-                '1. list 3',
+                "1. list 1",
+                "  list 1 cont",
+                "1. list 2",
+                "  list 2 cont",
+                "  * list 2.1",
+                "    list 2.1 cont",
+                "  * list 2.2",
+                "    list 2.2 cont",
+                "    1. list 2.2.1",
+                "    1. list 2.2.2",
+                "1. list 3",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '\n\n#. list 1',
-                    '   list 1 cont',
-                    '#. list 2',
-                    '   list 2 cont',
-                    '',
-                    '   * list 2.1',
-                    '     list 2.1 cont',
-                    '   * list 2.2',
-                    '     list 2.2 cont',
-                    '',
-                    '     #. list 2.2.1',
-                    '     #. list 2.2.2',
-                    '',
-                    '#. list 3\n',
+                    "\n\n#. list 1",
+                    "   list 1 cont",
+                    "#. list 2",
+                    "   list 2 cont",
+                    "",
+                    "   * list 2.1",
+                    "     list 2.1 cont",
+                    "   * list 2.2",
+                    "     list 2.2 cont",
+                    "",
+                    "     #. list 2.2.1",
+                    "     #. list 2.2.2",
+                    "",
+                    "#. list 3\n",
                 ]
             ),
         )
@@ -612,7 +680,7 @@ def test_nested_multiline_3(self):
 
 class TestConplexText(RendererTestBase):
     def test_code(self):
-        src = '''
+        src = """
 some sentence
 ```python
 print(1)
@@ -625,33 +693,33 @@ def test_code(self):
 ```
 ---
 end
-'''
+"""
         self.conv(src)
 
 
 class TestTable(RendererTestBase):
     def test_table(self):
-        src = '''h1 | h2 | h3\n--- | --- | ---\n1 | 2 | 3\n4 | 5 | 6'''
+        src = """h1 | h2 | h3\n--- | --- | ---\n1 | 2 | 3\n4 | 5 | 6"""
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '',
-                    '.. list-table::',
-                    '   :header-rows: 1',
-                    '',
-                    '   * - h1',
-                    '     - h2',
-                    '     - h3',
-                    '   * - 1',
-                    '     - 2',
-                    '     - 3',
-                    '   * - 4',
-                    '     - 5',
-                    '     - 6',
-                    '',
-                    '',
+                    "",
+                    ".. list-table::",
+                    "   :header-rows: 1",
+                    "",
+                    "   * - h1",
+                    "     - h2",
+                    "     - h3",
+                    "   * - 1",
+                    "     - 2",
+                    "     - 3",
+                    "   * - 4",
+                    "     - 5",
+                    "     - 6",
+                    "",
+                    "",
                 ]
             ),
         )
@@ -659,83 +727,83 @@ def test_table(self):
 
 class TestFootNote(RendererTestBase):
     def test_footnote(self):
-        src = '\n'.join(
+        src = "\n".join(
             [
-                'This is a[^1] footnote[^2] ref[^ref] with rst [#a]_.',
-                '',
-                '[^1]: note 1',
-                '[^2]: note 2',
-                '[^ref]: note ref',
-                '.. [#a] note rst',
+                "This is a[^1] footnote[^2] ref[^ref] with rst [#a]_.",
+                "",
+                "[^1]: note 1",
+                "[^2]: note 2",
+                "[^ref]: note ref",
+                ".. [#a] note rst",
             ]
         )
         out = self.conv(src)
         self.assertEqual(
             out,
-            '\n'.join(
+            "\n".join(
                 [
-                    '',
-                    'This is a\\ [#fn-1]_ '
-                    'footnote\\ [#fn-2]_ ref\\ [#fn-ref]_ with rst [#a]_.',
-                    '',
-                    '.. [#a] note rst',  # one empty line inserted...
-                    '',
-                    '.. [#fn-1] note 1',
-                    '.. [#fn-2] note 2',
-                    '.. [#fn-ref] note ref',
-                    '',
+                    "",
+                    "This is a\\ [#fn-1]_ "
+                    "footnote\\ [#fn-2]_ ref\\ [#fn-ref]_ with rst [#a]_.",
+                    "",
+                    ".. [#a] note rst",  # one empty line inserted...
+                    "",
+                    ".. [#fn-1] note 1",
+                    ".. [#fn-2] note 2",
+                    ".. [#fn-ref] note ref",
+                    "",
                 ]
             ),
         )
 
     def test_sphinx_ref(self):
-        src = 'This is a sphinx [ref]_ global ref.\n\n.. [ref] ref text'
+        src = "This is a sphinx [ref]_ global ref.\n\n.. [ref] ref text"
         out = self.conv(src)
-        self.assertEqual(out, '\n' + src)
+        self.assertEqual(out, "\n" + src)
 
 
 class TestDirective(RendererTestBase):
     def test_comment_oneline(self):
-        src = '.. a'
+        src = ".. a"
         out = self.conv(src)
-        self.assertEqual(out, '\n.. a')
+        self.assertEqual(out, "\n.. a")
 
     def test_comment_indented(self):
-        src = '    .. a'
+        src = "    .. a"
         out = self.conv(src)
-        self.assertEqual(out, '\n    .. a')
+        self.assertEqual(out, "\n    .. a")
 
     def test_comment_newline(self):
-        src = '..\n\n   comment\n\nnewline'
+        src = "..\n\n   comment\n\nnewline"
         out = self.conv(src)
-        self.assertEqual(out, '\n..\n\n   comment\n\nnewline\n')
+        self.assertEqual(out, "\n..\n\n   comment\n\nnewline\n")
 
     def test_comment_multiline(self):
         comment = (
-            '.. this is comment.\n'
-            '   this is also comment.\n'
-            '\n'
-            '\n'
-            '    comment may include empty line.\n'
-            '\n\n'
+            ".. this is comment.\n"
+            "   this is also comment.\n"
+            "\n"
+            "\n"
+            "    comment may include empty line.\n"
+            "\n\n"
         )
-        src = comment + '`eoc`'
+        src = comment + "`eoc`"
         out = self.conv(src)
-        self.assertEqual(out, '\n' + comment + '``eoc``\n')
+        self.assertEqual(out, "\n" + comment + "``eoc``\n")
 
 
 class TestRestCode(RendererTestBase):
     def test_rest_code_block_empty(self):
-        src = '\n\n::\n\n'
+        src = "\n\n::\n\n"
         out = self.conv(src)
-        self.assertEqual(out, '\n\n')
+        self.assertEqual(out, "\n\n")
 
     def test_eol_marker(self):
-        src = 'a::\n\n    code\n'
+        src = "a::\n\n    code\n"
         out = self.conv(src)
-        self.assertEqual(out, '\na:\n\n.. code-block::\n\n   code\n')
+        self.assertEqual(out, "\na:\n\n.. code-block::\n\n   code\n")
 
     def test_eol_marker_remove(self):
-        src = 'a ::\n\n    code\n'
+        src = "a ::\n\n    code\n"
         out = self.conv(src)
-        self.assertEqual(out, '\na\n\n.. code-block::\n\n   code\n')
+        self.assertEqual(out, "\na\n\n.. code-block::\n\n   code\n")

From 039f30fb00797f976a712e18f03927050d87c410 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 30 Jan 2023 04:22:27 -0300
Subject: [PATCH 08/22] remove precommit warning

---
 .pre-commit-config.yaml | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index cad3826..60c301e 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -12,27 +12,43 @@ repos:
       language: system
       types: [python]
       args: [--max-line-length=88]
-      exclude: (docs|tests)/*
+      exclude: |
+            (?x)^(
+                docs*|
+                test*
+            )$
     - id: isort
       name: isort
       entry: isort
       language: system
       types: [python]
       args: [--multi-line=3,--trailing-comma,--force-grid-wrap=0,--use-parentheses,--line-width=88]
-      exclude: (docs|tests)/*
+      exclude: |
+            (?x)^(
+                docs*|
+                test*
+            )$
     - id: black
       name: black
       entry: black
       language: system
       types: [python]
       args: []
-      exclude: (docs|tests)/*
+      exclude: |
+            (?x)^(
+                docs*|
+                test*
+            )$
     - id: mypy
       name: mypy
       entry: mypy
       language: system
       types: [python]
-      exclude: (tests|docs)/*
+      exclude: |
+            (?x)^(
+                docs*|
+                test*
+            )$
     - id: pylint
       name: pylint
       entry: pylint

From de2258642472f4f33ea68c9488a758ac9c47dea6 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 30 Jan 2023 04:27:07 -0300
Subject: [PATCH 09/22] ignore venv

---
 .gitignore | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.gitignore b/.gitignore
index f27916d..c1d98b4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -93,3 +93,5 @@ ghostdriver.log
 
 # nox
 .nox/*
+
+venv*

From e49391b1aaa3255d86609c8ecaf4904ebc89b42a Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Sun, 28 Jul 2024 20:06:03 -0300
Subject: [PATCH 10/22] move to poetry

---
 .bumpversion.cfg      |    8 -
 .flake8               |   12 -
 MANIFEST.in           |    7 -
 bandit.yaml           |  397 ---------------
 mypy.ini              |    4 -
 poetry.lock           | 1128 +++++++++++++++++++++++++++++++++++++++++
 pyproject.toml        |   42 ++
 requirements-dev.txt  |   10 -
 requirements-test.txt |    4 -
 setup.py              |   61 ---
 10 files changed, 1170 insertions(+), 503 deletions(-)
 delete mode 100644 .bumpversion.cfg
 delete mode 100644 .flake8
 delete mode 100644 MANIFEST.in
 delete mode 100644 bandit.yaml
 delete mode 100644 mypy.ini
 create mode 100644 poetry.lock
 create mode 100644 pyproject.toml
 delete mode 100644 requirements-dev.txt
 delete mode 100644 requirements-test.txt
 delete mode 100644 setup.py

diff --git a/.bumpversion.cfg b/.bumpversion.cfg
deleted file mode 100644
index d3331a7..0000000
--- a/.bumpversion.cfg
+++ /dev/null
@@ -1,8 +0,0 @@
-[bumpversion]
-current_version = 0.3.3.post2
-commit = False
-tag = False
-
-[bumpversion:file:setup.py]
-search = __version__ = "{current_version}"
-replace = __version__ = "{new_version}"
diff --git a/.flake8 b/.flake8
deleted file mode 100644
index 0ed216d..0000000
--- a/.flake8
+++ /dev/null
@@ -1,12 +0,0 @@
-[flake8]
-
-ignore =
-	E501, # pylint already does this
-	W503, # https://github.com/psf/black/issues/113
-	D100,
-	D101,
-	D102,
-	D103,
-	D107,
-	D401
-
diff --git a/MANIFEST.in b/MANIFEST.in
deleted file mode 100644
index 5e3e2a9..0000000
--- a/MANIFEST.in
+++ /dev/null
@@ -1,7 +0,0 @@
-include README.md
-include LICENSE
-include CHANGES.md
-
-recursive-include tests *.py test.md test.rst
-recursive-exclude * __pycache__
-recursive-exclude * *.py[co]
diff --git a/bandit.yaml b/bandit.yaml
deleted file mode 100644
index 7bc50e7..0000000
--- a/bandit.yaml
+++ /dev/null
@@ -1,397 +0,0 @@
-
-### Bandit config file generated from:
-# '/home/nox/repos/venv/bin/bandit-config-generator -s B322 -o bandit.yaml'
-
-### This config may optionally select a subset of tests to run or skip by
-### filling out the 'tests' and 'skips' lists given below. If no tests are
-### specified for inclusion then it is assumed all tests are desired. The skips
-### set will remove specific tests from the include set. This can be controlled
-### using the -t/-s CLI options. Note that the same test ID should not appear
-### in both 'tests' and 'skips', this would be nonsensical and is detected by
-### Bandit at runtime.
-
-# Available tests:
-# B101 : assert_used
-# B102 : exec_used
-# B103 : set_bad_file_permissions
-# B104 : hardcoded_bind_all_interfaces
-# B105 : hardcoded_password_string
-# B106 : hardcoded_password_funcarg
-# B107 : hardcoded_password_default
-# B108 : hardcoded_tmp_directory
-# B110 : try_except_pass
-# B112 : try_except_continue
-# B201 : flask_debug_true
-# B301 : pickle
-# B302 : marshal
-# B303 : md5
-# B304 : ciphers
-# B305 : cipher_modes
-# B306 : mktemp_q
-# B307 : eval
-# B308 : mark_safe
-# B309 : httpsconnection
-# B310 : urllib_urlopen
-# B311 : random
-# B312 : telnetlib
-# B313 : xml_bad_cElementTree
-# B314 : xml_bad_ElementTree
-# B315 : xml_bad_expatreader
-# B316 : xml_bad_expatbuilder
-# B317 : xml_bad_sax
-# B318 : xml_bad_minidom
-# B319 : xml_bad_pulldom
-# B320 : xml_bad_etree
-# B321 : ftplib
-# B322 : input
-# B323 : unverified_context
-# B324 : hashlib_new_insecure_functions
-# B325 : tempnam
-# B401 : import_telnetlib
-# B402 : import_ftplib
-# B403 : import_pickle
-# B404 : import_subprocess
-# B405 : import_xml_etree
-# B406 : import_xml_sax
-# B407 : import_xml_expat
-# B408 : import_xml_minidom
-# B409 : import_xml_pulldom
-# B410 : import_lxml
-# B411 : import_xmlrpclib
-# B412 : import_httpoxy
-# B413 : import_pycrypto
-# B501 : request_with_no_cert_validation
-# B502 : ssl_with_bad_version
-# B503 : ssl_with_bad_defaults
-# B504 : ssl_with_no_version
-# B505 : weak_cryptographic_key
-# B506 : yaml_load
-# B507 : ssh_no_host_key_verification
-# B601 : paramiko_calls
-# B602 : subprocess_popen_with_shell_equals_true
-# B603 : subprocess_without_shell_equals_true
-# B604 : any_other_function_with_shell_equals_true
-# B605 : start_process_with_a_shell
-# B606 : start_process_with_no_shell
-# B607 : start_process_with_partial_path
-# B608 : hardcoded_sql_expressions
-# B609 : linux_commands_wildcard_injection
-# B610 : django_extra_used
-# B611 : django_rawsql_used
-# B701 : jinja2_autoescape_false
-# B702 : use_of_mako_templates
-# B703 : django_mark_safe
-
-# (optional) list included test IDs here, eg '[B101, B406]':
-tests:
-
-# (optional) list skipped test IDs here, eg '[B101, B406]':
-skips: []
-
-### (optional) plugin settings - some test plugins require configuration data
-### that may be given here, per-plugin. All bandit test plugins have a built in
-### set of sensible defaults and these will be used if no configuration is
-### provided. It is not necessary to provide settings for every (or any) plugin
-### if the defaults are acceptable.
-
-any_other_function_with_shell_equals_true:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-hardcoded_tmp_directory:
-  tmp_dirs:
-  - /tmp
-  - /var/tmp
-  - /dev/shm
-linux_commands_wildcard_injection:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-ssl_with_bad_defaults:
-  bad_protocol_versions:
-  - PROTOCOL_SSLv2
-  - SSLv2_METHOD
-  - SSLv23_METHOD
-  - PROTOCOL_SSLv3
-  - PROTOCOL_TLSv1
-  - SSLv3_METHOD
-  - TLSv1_METHOD
-ssl_with_bad_version:
-  bad_protocol_versions:
-  - PROTOCOL_SSLv2
-  - SSLv2_METHOD
-  - SSLv23_METHOD
-  - PROTOCOL_SSLv3
-  - PROTOCOL_TLSv1
-  - SSLv3_METHOD
-  - TLSv1_METHOD
-start_process_with_a_shell:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-start_process_with_no_shell:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-start_process_with_partial_path:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-subprocess_popen_with_shell_equals_true:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-subprocess_without_shell_equals_true:
-  no_shell:
-  - os.execl
-  - os.execle
-  - os.execlp
-  - os.execlpe
-  - os.execv
-  - os.execve
-  - os.execvp
-  - os.execvpe
-  - os.spawnl
-  - os.spawnle
-  - os.spawnlp
-  - os.spawnlpe
-  - os.spawnv
-  - os.spawnve
-  - os.spawnvp
-  - os.spawnvpe
-  - os.startfile
-  shell:
-  - os.system
-  - os.popen
-  - os.popen2
-  - os.popen3
-  - os.popen4
-  - popen2.popen2
-  - popen2.popen3
-  - popen2.popen4
-  - popen2.Popen3
-  - popen2.Popen4
-  - commands.getoutput
-  - commands.getstatusoutput
-  subprocess:
-  - subprocess.Popen
-  - subprocess.call
-  - subprocess.check_call
-  - subprocess.check_output
-  - subprocess.run
-try_except_continue:
-  check_typed_exception: false
-try_except_pass:
-  check_typed_exception: false
-weak_cryptographic_key:
-  weak_key_size_dsa_high: 1024
-  weak_key_size_dsa_medium: 2048
-  weak_key_size_ec_high: 160
-  weak_key_size_ec_medium: 224
-  weak_key_size_rsa_high: 1024
-  weak_key_size_rsa_medium: 2048
-
diff --git a/mypy.ini b/mypy.ini
deleted file mode 100644
index 461b55e..0000000
--- a/mypy.ini
+++ /dev/null
@@ -1,4 +0,0 @@
-[mypy]
-
-ignore_missing_imports = True
-follow_imports = skip
diff --git a/poetry.lock b/poetry.lock
new file mode 100644
index 0000000..999fa86
--- /dev/null
+++ b/poetry.lock
@@ -0,0 +1,1128 @@
+# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand.
+
+[[package]]
+name = "alabaster"
+version = "0.7.16"
+description = "A light, configurable Sphinx theme"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "alabaster-0.7.16-py3-none-any.whl", hash = "sha256:b46733c07dce03ae4e150330b975c75737fa60f0a7c591b6c8bf4928a28e2c92"},
+    {file = "alabaster-0.7.16.tar.gz", hash = "sha256:75a8b99c28a5dad50dd7f8ccdd447a121ddb3892da9e53d1ca5cca3106d58d65"},
+]
+
+[[package]]
+name = "astroid"
+version = "3.2.4"
+description = "An abstract syntax tree for Python with inference support."
+optional = false
+python-versions = ">=3.8.0"
+files = [
+    {file = "astroid-3.2.4-py3-none-any.whl", hash = "sha256:413658a61eeca6202a59231abb473f932038fbcbf1666587f66d482083413a25"},
+    {file = "astroid-3.2.4.tar.gz", hash = "sha256:0e14202810b30da1b735827f78f5157be2bbd4a7a59b7707ca0bfc2fb4c0063a"},
+]
+
+[package.dependencies]
+typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""}
+
+[[package]]
+name = "babel"
+version = "2.15.0"
+description = "Internationalization utilities"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "Babel-2.15.0-py3-none-any.whl", hash = "sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb"},
+    {file = "babel-2.15.0.tar.gz", hash = "sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413"},
+]
+
+[package.extras]
+dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"]
+
+[[package]]
+name = "bandit"
+version = "1.7.9"
+description = "Security oriented static analyser for python code."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "bandit-1.7.9-py3-none-any.whl", hash = "sha256:52077cb339000f337fb25f7e045995c4ad01511e716e5daac37014b9752de8ec"},
+    {file = "bandit-1.7.9.tar.gz", hash = "sha256:7c395a436743018f7be0a4cbb0a4ea9b902b6d87264ddecf8cfdc73b4f78ff61"},
+]
+
+[package.dependencies]
+colorama = {version = ">=0.3.9", markers = "platform_system == \"Windows\""}
+PyYAML = ">=5.3.1"
+rich = "*"
+stevedore = ">=1.20.0"
+
+[package.extras]
+baseline = ["GitPython (>=3.1.30)"]
+sarif = ["jschema-to-python (>=1.2.3)", "sarif-om (>=1.0.4)"]
+test = ["beautifulsoup4 (>=4.8.0)", "coverage (>=4.5.4)", "fixtures (>=3.0.0)", "flake8 (>=4.0.0)", "pylint (==1.9.4)", "stestr (>=2.5.0)", "testscenarios (>=0.5.0)", "testtools (>=2.3.0)"]
+toml = ["tomli (>=1.1.0)"]
+yaml = ["PyYAML"]
+
+[[package]]
+name = "black"
+version = "24.4.2"
+description = "The uncompromising code formatter."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "black-24.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dd1b5a14e417189db4c7b64a6540f31730713d173f0b63e55fabd52d61d8fdce"},
+    {file = "black-24.4.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e537d281831ad0e71007dcdcbe50a71470b978c453fa41ce77186bbe0ed6021"},
+    {file = "black-24.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eaea3008c281f1038edb473c1aa8ed8143a5535ff18f978a318f10302b254063"},
+    {file = "black-24.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:7768a0dbf16a39aa5e9a3ded568bb545c8c2727396d063bbaf847df05b08cd96"},
+    {file = "black-24.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:257d724c2c9b1660f353b36c802ccece186a30accc7742c176d29c146df6e474"},
+    {file = "black-24.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bdde6f877a18f24844e381d45e9947a49e97933573ac9d4345399be37621e26c"},
+    {file = "black-24.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e151054aa00bad1f4e1f04919542885f89f5f7d086b8a59e5000e6c616896ffb"},
+    {file = "black-24.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:7e122b1c4fb252fd85df3ca93578732b4749d9be076593076ef4d07a0233c3e1"},
+    {file = "black-24.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:accf49e151c8ed2c0cdc528691838afd217c50412534e876a19270fea1e28e2d"},
+    {file = "black-24.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:88c57dc656038f1ab9f92b3eb5335ee9b021412feaa46330d5eba4e51fe49b04"},
+    {file = "black-24.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be8bef99eb46d5021bf053114442914baeb3649a89dc5f3a555c88737e5e98fc"},
+    {file = "black-24.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:415e686e87dbbe6f4cd5ef0fbf764af7b89f9057b97c908742b6008cc554b9c0"},
+    {file = "black-24.4.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bf10f7310db693bb62692609b397e8d67257c55f949abde4c67f9cc574492cc7"},
+    {file = "black-24.4.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:98e123f1d5cfd42f886624d84464f7756f60ff6eab89ae845210631714f6db94"},
+    {file = "black-24.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48a85f2cb5e6799a9ef05347b476cce6c182d6c71ee36925a6c194d074336ef8"},
+    {file = "black-24.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:b1530ae42e9d6d5b670a34db49a94115a64596bc77710b1d05e9801e62ca0a7c"},
+    {file = "black-24.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:37aae07b029fa0174d39daf02748b379399b909652a806e5708199bd93899da1"},
+    {file = "black-24.4.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:da33a1a5e49c4122ccdfd56cd021ff1ebc4a1ec4e2d01594fef9b6f267a9e741"},
+    {file = "black-24.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef703f83fc32e131e9bcc0a5094cfe85599e7109f896fe8bc96cc402f3eb4b6e"},
+    {file = "black-24.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:b9176b9832e84308818a99a561e90aa479e73c523b3f77afd07913380ae2eab7"},
+    {file = "black-24.4.2-py3-none-any.whl", hash = "sha256:d36ed1124bb81b32f8614555b34cc4259c3fbc7eec17870e8ff8ded335b58d8c"},
+    {file = "black-24.4.2.tar.gz", hash = "sha256:c872b53057f000085da66a19c55d68f6f8ddcac2642392ad3a355878406fbd4d"},
+]
+
+[package.dependencies]
+click = ">=8.0.0"
+mypy-extensions = ">=0.4.3"
+packaging = ">=22.0"
+pathspec = ">=0.9.0"
+platformdirs = ">=2"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""}
+
+[package.extras]
+colorama = ["colorama (>=0.4.3)"]
+d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"]
+jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
+uvloop = ["uvloop (>=0.15.2)"]
+
+[[package]]
+name = "certifi"
+version = "2024.7.4"
+description = "Python package for providing Mozilla's CA Bundle."
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"},
+    {file = "certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b"},
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.3.2"
+description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"},
+    {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"},
+    {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"},
+    {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"},
+    {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"},
+    {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"},
+    {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"},
+    {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"},
+]
+
+[[package]]
+name = "click"
+version = "8.1.7"
+description = "Composable command line interface toolkit"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+description = "Cross-platform colored terminal text."
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+files = [
+    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
+    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
+]
+
+[[package]]
+name = "coverage"
+version = "7.6.0"
+description = "Code coverage measurement for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "coverage-7.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dff044f661f59dace805eedb4a7404c573b6ff0cdba4a524141bc63d7be5c7fd"},
+    {file = "coverage-7.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a8659fd33ee9e6ca03950cfdcdf271d645cf681609153f218826dd9805ab585c"},
+    {file = "coverage-7.6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7792f0ab20df8071d669d929c75c97fecfa6bcab82c10ee4adb91c7a54055463"},
+    {file = "coverage-7.6.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4b3cd1ca7cd73d229487fa5caca9e4bc1f0bca96526b922d61053ea751fe791"},
+    {file = "coverage-7.6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7e128f85c0b419907d1f38e616c4f1e9f1d1b37a7949f44df9a73d5da5cd53c"},
+    {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a94925102c89247530ae1dab7dc02c690942566f22e189cbd53579b0693c0783"},
+    {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dcd070b5b585b50e6617e8972f3fbbee786afca71b1936ac06257f7e178f00f6"},
+    {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d50a252b23b9b4dfeefc1f663c568a221092cbaded20a05a11665d0dbec9b8fb"},
+    {file = "coverage-7.6.0-cp310-cp310-win32.whl", hash = "sha256:0e7b27d04131c46e6894f23a4ae186a6a2207209a05df5b6ad4caee6d54a222c"},
+    {file = "coverage-7.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:54dece71673b3187c86226c3ca793c5f891f9fc3d8aa183f2e3653da18566169"},
+    {file = "coverage-7.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7b525ab52ce18c57ae232ba6f7010297a87ced82a2383b1afd238849c1ff933"},
+    {file = "coverage-7.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bea27c4269234e06f621f3fac3925f56ff34bc14521484b8f66a580aacc2e7d"},
+    {file = "coverage-7.6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed8d1d1821ba5fc88d4a4f45387b65de52382fa3ef1f0115a4f7a20cdfab0e94"},
+    {file = "coverage-7.6.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01c322ef2bbe15057bc4bf132b525b7e3f7206f071799eb8aa6ad1940bcf5fb1"},
+    {file = "coverage-7.6.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03cafe82c1b32b770a29fd6de923625ccac3185a54a5e66606da26d105f37dac"},
+    {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d1b923fc4a40c5832be4f35a5dab0e5ff89cddf83bb4174499e02ea089daf57"},
+    {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4b03741e70fb811d1a9a1d75355cf391f274ed85847f4b78e35459899f57af4d"},
+    {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a73d18625f6a8a1cbb11eadc1d03929f9510f4131879288e3f7922097a429f63"},
+    {file = "coverage-7.6.0-cp311-cp311-win32.whl", hash = "sha256:65fa405b837060db569a61ec368b74688f429b32fa47a8929a7a2f9b47183713"},
+    {file = "coverage-7.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:6379688fb4cfa921ae349c76eb1a9ab26b65f32b03d46bb0eed841fd4cb6afb1"},
+    {file = "coverage-7.6.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f7db0b6ae1f96ae41afe626095149ecd1b212b424626175a6633c2999eaad45b"},
+    {file = "coverage-7.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bbdf9a72403110a3bdae77948b8011f644571311c2fb35ee15f0f10a8fc082e8"},
+    {file = "coverage-7.6.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc44bf0315268e253bf563f3560e6c004efe38f76db03a1558274a6e04bf5d5"},
+    {file = "coverage-7.6.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da8549d17489cd52f85a9829d0e1d91059359b3c54a26f28bec2c5d369524807"},
+    {file = "coverage-7.6.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0086cd4fc71b7d485ac93ca4239c8f75732c2ae3ba83f6be1c9be59d9e2c6382"},
+    {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fad32ee9b27350687035cb5fdf9145bc9cf0a094a9577d43e909948ebcfa27b"},
+    {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:044a0985a4f25b335882b0966625270a8d9db3d3409ddc49a4eb00b0ef5e8cee"},
+    {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:76d5f82213aa78098b9b964ea89de4617e70e0d43e97900c2778a50856dac605"},
+    {file = "coverage-7.6.0-cp312-cp312-win32.whl", hash = "sha256:3c59105f8d58ce500f348c5b56163a4113a440dad6daa2294b5052a10db866da"},
+    {file = "coverage-7.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:ca5d79cfdae420a1d52bf177de4bc2289c321d6c961ae321503b2ca59c17ae67"},
+    {file = "coverage-7.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d39bd10f0ae453554798b125d2f39884290c480f56e8a02ba7a6ed552005243b"},
+    {file = "coverage-7.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:beb08e8508e53a568811016e59f3234d29c2583f6b6e28572f0954a6b4f7e03d"},
+    {file = "coverage-7.6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2e16f4cd2bc4d88ba30ca2d3bbf2f21f00f382cf4e1ce3b1ddc96c634bc48ca"},
+    {file = "coverage-7.6.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6616d1c9bf1e3faea78711ee42a8b972367d82ceae233ec0ac61cc7fec09fa6b"},
+    {file = "coverage-7.6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad4567d6c334c46046d1c4c20024de2a1c3abc626817ae21ae3da600f5779b44"},
+    {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d17c6a415d68cfe1091d3296ba5749d3d8696e42c37fca5d4860c5bf7b729f03"},
+    {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9146579352d7b5f6412735d0f203bbd8d00113a680b66565e205bc605ef81bc6"},
+    {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:cdab02a0a941af190df8782aafc591ef3ad08824f97850b015c8c6a8b3877b0b"},
+    {file = "coverage-7.6.0-cp38-cp38-win32.whl", hash = "sha256:df423f351b162a702c053d5dddc0fc0ef9a9e27ea3f449781ace5f906b664428"},
+    {file = "coverage-7.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:f2501d60d7497fd55e391f423f965bbe9e650e9ffc3c627d5f0ac516026000b8"},
+    {file = "coverage-7.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7221f9ac9dad9492cecab6f676b3eaf9185141539d5c9689d13fd6b0d7de840c"},
+    {file = "coverage-7.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ddaaa91bfc4477d2871442bbf30a125e8fe6b05da8a0015507bfbf4718228ab2"},
+    {file = "coverage-7.6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4cbe651f3904e28f3a55d6f371203049034b4ddbce65a54527a3f189ca3b390"},
+    {file = "coverage-7.6.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:831b476d79408ab6ccfadaaf199906c833f02fdb32c9ab907b1d4aa0713cfa3b"},
+    {file = "coverage-7.6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46c3d091059ad0b9c59d1034de74a7f36dcfa7f6d3bde782c49deb42438f2450"},
+    {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4d5fae0a22dc86259dee66f2cc6c1d3e490c4a1214d7daa2a93d07491c5c04b6"},
+    {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:07ed352205574aad067482e53dd606926afebcb5590653121063fbf4e2175166"},
+    {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:49c76cdfa13015c4560702574bad67f0e15ca5a2872c6a125f6327ead2b731dd"},
+    {file = "coverage-7.6.0-cp39-cp39-win32.whl", hash = "sha256:482855914928c8175735a2a59c8dc5806cf7d8f032e4820d52e845d1f731dca2"},
+    {file = "coverage-7.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:543ef9179bc55edfd895154a51792b01c017c87af0ebaae092720152e19e42ca"},
+    {file = "coverage-7.6.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:6fe885135c8a479d3e37a7aae61cbd3a0fb2deccb4dda3c25f92a49189f766d6"},
+    {file = "coverage-7.6.0.tar.gz", hash = "sha256:289cc803fa1dc901f84701ac10c9ee873619320f2f9aff38794db4a4a0268d51"},
+]
+
+[package.dependencies]
+tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.11.0a6\" and extra == \"toml\""}
+
+[package.extras]
+toml = ["tomli"]
+
+[[package]]
+name = "dill"
+version = "0.3.8"
+description = "serialize all of Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"},
+    {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"},
+]
+
+[package.extras]
+graph = ["objgraph (>=1.7.2)"]
+profile = ["gprof2dot (>=2022.7.29)"]
+
+[[package]]
+name = "docutils"
+version = "0.20.1"
+description = "Docutils -- Python Documentation Utilities"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "docutils-0.20.1-py3-none-any.whl", hash = "sha256:96f387a2c5562db4476f09f13bbab2192e764cac08ebbf3a34a95d9b1e4a59d6"},
+    {file = "docutils-0.20.1.tar.gz", hash = "sha256:f08a4e276c3a1583a86dce3e34aba3fe04d02bba2dd51ed16106244e8a923e3b"},
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+description = "Backport of PEP 654 (exception groups)"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
+    {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},
+]
+
+[package.extras]
+test = ["pytest (>=6)"]
+
+[[package]]
+name = "idna"
+version = "3.7"
+description = "Internationalized Domain Names in Applications (IDNA)"
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "idna-3.7-py3-none-any.whl", hash = "sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0"},
+    {file = "idna-3.7.tar.gz", hash = "sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc"},
+]
+
+[[package]]
+name = "imagesize"
+version = "1.4.1"
+description = "Getting image size from png/jpeg/jpeg2000/gif file"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*"
+files = [
+    {file = "imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b"},
+    {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"},
+]
+
+[[package]]
+name = "importlib-metadata"
+version = "8.2.0"
+description = "Read metadata from Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "importlib_metadata-8.2.0-py3-none-any.whl", hash = "sha256:11901fa0c2f97919b288679932bb64febaeacf289d18ac84dd68cb2e74213369"},
+    {file = "importlib_metadata-8.2.0.tar.gz", hash = "sha256:72e8d4399996132204f9a16dcc751af254a48f8d1b20b9ff0f98d4a8f901e73d"},
+]
+
+[package.dependencies]
+zipp = ">=0.5"
+
+[package.extras]
+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+perf = ["ipython"]
+test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+description = "brain-dead simple config-ini parsing"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
+    {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
+]
+
+[[package]]
+name = "isort"
+version = "5.13.2"
+description = "A Python utility / library to sort Python imports."
+optional = false
+python-versions = ">=3.8.0"
+files = [
+    {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"},
+    {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"},
+]
+
+[package.extras]
+colors = ["colorama (>=0.4.6)"]
+
+[[package]]
+name = "jinja2"
+version = "3.1.4"
+description = "A very fast and expressive template engine."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "jinja2-3.1.4-py3-none-any.whl", hash = "sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d"},
+    {file = "jinja2-3.1.4.tar.gz", hash = "sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369"},
+]
+
+[package.dependencies]
+MarkupSafe = ">=2.0"
+
+[package.extras]
+i18n = ["Babel (>=2.7)"]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+description = "Python port of markdown-it. Markdown parsing, done right!"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"},
+    {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"},
+]
+
+[package.dependencies]
+mdurl = ">=0.1,<1.0"
+
+[package.extras]
+benchmarking = ["psutil", "pytest", "pytest-benchmark"]
+code-style = ["pre-commit (>=3.0,<4.0)"]
+compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"]
+linkify = ["linkify-it-py (>=1,<3)"]
+plugins = ["mdit-py-plugins"]
+profiling = ["gprof2dot"]
+rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"]
+testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"]
+
+[[package]]
+name = "markupsafe"
+version = "2.1.5"
+description = "Safely add untrusted strings to HTML/XML markup."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"},
+    {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"},
+    {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"},
+    {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"},
+    {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"},
+    {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"},
+    {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"},
+    {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},
+]
+
+[[package]]
+name = "mccabe"
+version = "0.7.0"
+description = "McCabe checker, plugin for flake8"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"},
+    {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"},
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+description = "Markdown URL utilities"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"},
+    {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"},
+]
+
+[[package]]
+name = "mistune"
+version = "2.0.5"
+description = "A sane Markdown parser with useful plugins and renderers"
+optional = false
+python-versions = "*"
+files = [
+    {file = "mistune-2.0.5-py2.py3-none-any.whl", hash = "sha256:bad7f5d431886fcbaf5f758118ecff70d31f75231b34024a1341120340a65ce8"},
+    {file = "mistune-2.0.5.tar.gz", hash = "sha256:0246113cb2492db875c6be56974a7c893333bf26cd92891c85f63151cee09d34"},
+]
+
+[[package]]
+name = "mypy"
+version = "1.11.0"
+description = "Optional static typing for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "mypy-1.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a3824187c99b893f90c845bab405a585d1ced4ff55421fdf5c84cb7710995229"},
+    {file = "mypy-1.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:96f8dbc2c85046c81bcddc246232d500ad729cb720da4e20fce3b542cab91287"},
+    {file = "mypy-1.11.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a5d8d8dd8613a3e2be3eae829ee891b6b2de6302f24766ff06cb2875f5be9c6"},
+    {file = "mypy-1.11.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:72596a79bbfb195fd41405cffa18210af3811beb91ff946dbcb7368240eed6be"},
+    {file = "mypy-1.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:35ce88b8ed3a759634cb4eb646d002c4cef0a38f20565ee82b5023558eb90c00"},
+    {file = "mypy-1.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:98790025861cb2c3db8c2f5ad10fc8c336ed2a55f4daf1b8b3f877826b6ff2eb"},
+    {file = "mypy-1.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:25bcfa75b9b5a5f8d67147a54ea97ed63a653995a82798221cca2a315c0238c1"},
+    {file = "mypy-1.11.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bea2a0e71c2a375c9fa0ede3d98324214d67b3cbbfcbd55ac8f750f85a414e3"},
+    {file = "mypy-1.11.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d2b3d36baac48e40e3064d2901f2fbd2a2d6880ec6ce6358825c85031d7c0d4d"},
+    {file = "mypy-1.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:d8e2e43977f0e09f149ea69fd0556623919f816764e26d74da0c8a7b48f3e18a"},
+    {file = "mypy-1.11.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1d44c1e44a8be986b54b09f15f2c1a66368eb43861b4e82573026e04c48a9e20"},
+    {file = "mypy-1.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cea3d0fb69637944dd321f41bc896e11d0fb0b0aa531d887a6da70f6e7473aba"},
+    {file = "mypy-1.11.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a83ec98ae12d51c252be61521aa5731f5512231d0b738b4cb2498344f0b840cd"},
+    {file = "mypy-1.11.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c7b73a856522417beb78e0fb6d33ef89474e7a622db2653bc1285af36e2e3e3d"},
+    {file = "mypy-1.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:f2268d9fcd9686b61ab64f077be7ffbc6fbcdfb4103e5dd0cc5eaab53a8886c2"},
+    {file = "mypy-1.11.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:940bfff7283c267ae6522ef926a7887305945f716a7704d3344d6d07f02df850"},
+    {file = "mypy-1.11.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:14f9294528b5f5cf96c721f231c9f5b2733164e02c1c018ed1a0eff8a18005ac"},
+    {file = "mypy-1.11.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7b54c27783991399046837df5c7c9d325d921394757d09dbcbf96aee4649fe9"},
+    {file = "mypy-1.11.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:65f190a6349dec29c8d1a1cd4aa71284177aee5949e0502e6379b42873eddbe7"},
+    {file = "mypy-1.11.0-cp38-cp38-win_amd64.whl", hash = "sha256:dbe286303241fea8c2ea5466f6e0e6a046a135a7e7609167b07fd4e7baf151bf"},
+    {file = "mypy-1.11.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:104e9c1620c2675420abd1f6c44bab7dd33cc85aea751c985006e83dcd001095"},
+    {file = "mypy-1.11.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f006e955718ecd8d159cee9932b64fba8f86ee6f7728ca3ac66c3a54b0062abe"},
+    {file = "mypy-1.11.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:becc9111ca572b04e7e77131bc708480cc88a911adf3d0239f974c034b78085c"},
+    {file = "mypy-1.11.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6801319fe76c3f3a3833f2b5af7bd2c17bb93c00026a2a1b924e6762f5b19e13"},
+    {file = "mypy-1.11.0-cp39-cp39-win_amd64.whl", hash = "sha256:c1a184c64521dc549324ec6ef7cbaa6b351912be9cb5edb803c2808a0d7e85ac"},
+    {file = "mypy-1.11.0-py3-none-any.whl", hash = "sha256:56913ec8c7638b0091ef4da6fcc9136896914a9d60d54670a75880c3e5b99ace"},
+    {file = "mypy-1.11.0.tar.gz", hash = "sha256:93743608c7348772fdc717af4aeee1997293a1ad04bc0ea6efa15bf65385c538"},
+]
+
+[package.dependencies]
+mypy-extensions = ">=1.0.0"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+typing-extensions = ">=4.6.0"
+
+[package.extras]
+dmypy = ["psutil (>=4.0)"]
+install-types = ["pip"]
+mypyc = ["setuptools (>=50)"]
+reports = ["lxml"]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+description = "Type system extensions for programs checked with the mypy type checker."
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
+    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
+]
+
+[[package]]
+name = "packaging"
+version = "24.1"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
+    {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
+]
+
+[[package]]
+name = "pathspec"
+version = "0.12.1"
+description = "Utility library for gitignore style pattern matching of file paths."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"},
+    {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"},
+]
+
+[[package]]
+name = "pbr"
+version = "6.0.0"
+description = "Python Build Reasonableness"
+optional = false
+python-versions = ">=2.6"
+files = [
+    {file = "pbr-6.0.0-py2.py3-none-any.whl", hash = "sha256:4a7317d5e3b17a3dccb6a8cfe67dab65b20551404c52c8ed41279fa4f0cb4cda"},
+    {file = "pbr-6.0.0.tar.gz", hash = "sha256:d1377122a5a00e2f940ee482999518efe16d745d423a670c27773dfbc3c9a7d9"},
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.2.2"
+description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"},
+    {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"},
+]
+
+[package.extras]
+docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
+test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
+type = ["mypy (>=1.8)"]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+description = "plugin and hook calling mechanisms for python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
+]
+
+[package.extras]
+dev = ["pre-commit", "tox"]
+testing = ["pytest", "pytest-benchmark"]
+
+[[package]]
+name = "pygments"
+version = "2.18.0"
+description = "Pygments is a syntax highlighting package written in Python."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"},
+    {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"},
+]
+
+[package.extras]
+windows-terminal = ["colorama (>=0.4.6)"]
+
+[[package]]
+name = "pylint"
+version = "3.2.6"
+description = "python code static checker"
+optional = false
+python-versions = ">=3.8.0"
+files = [
+    {file = "pylint-3.2.6-py3-none-any.whl", hash = "sha256:03c8e3baa1d9fb995b12c1dbe00aa6c4bcef210c2a2634374aedeb22fb4a8f8f"},
+    {file = "pylint-3.2.6.tar.gz", hash = "sha256:a5d01678349454806cff6d886fb072294f56a58c4761278c97fb557d708e1eb3"},
+]
+
+[package.dependencies]
+astroid = ">=3.2.4,<=3.3.0-dev0"
+colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""}
+dill = [
+    {version = ">=0.2", markers = "python_version < \"3.11\""},
+    {version = ">=0.3.7", markers = "python_version >= \"3.12\""},
+    {version = ">=0.3.6", markers = "python_version >= \"3.11\" and python_version < \"3.12\""},
+]
+isort = ">=4.2.5,<5.13.0 || >5.13.0,<6"
+mccabe = ">=0.6,<0.8"
+platformdirs = ">=2.2.0"
+tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""}
+tomlkit = ">=0.10.1"
+typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""}
+
+[package.extras]
+spelling = ["pyenchant (>=3.2,<4.0)"]
+testutils = ["gitpython (>3)"]
+
+[[package]]
+name = "pytest"
+version = "8.3.2"
+description = "pytest: simple powerful testing with Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pytest-8.3.2-py3-none-any.whl", hash = "sha256:4ba08f9ae7dcf84ded419494d229b48d0903ea6407b030eaec46df5e6a73bba5"},
+    {file = "pytest-8.3.2.tar.gz", hash = "sha256:c132345d12ce551242c87269de812483f5bcc87cdbb4722e48487ba194f9fdce"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "sys_platform == \"win32\""}
+exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
+iniconfig = "*"
+packaging = "*"
+pluggy = ">=1.5,<2"
+tomli = {version = ">=1", markers = "python_version < \"3.11\""}
+
+[package.extras]
+dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
+
+[[package]]
+name = "pytest-cov"
+version = "5.0.0"
+description = "Pytest plugin for measuring coverage."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pytest-cov-5.0.0.tar.gz", hash = "sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857"},
+    {file = "pytest_cov-5.0.0-py3-none-any.whl", hash = "sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652"},
+]
+
+[package.dependencies]
+coverage = {version = ">=5.2.1", extras = ["toml"]}
+pytest = ">=4.6"
+
+[package.extras]
+testing = ["fields", "hunter", "process-tests", "pytest-xdist", "virtualenv"]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.1"
+description = "YAML parser and emitter for Python"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"},
+    {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"},
+    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"},
+    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"},
+    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"},
+    {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"},
+    {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"},
+    {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"},
+    {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"},
+    {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"},
+    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"},
+    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"},
+    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"},
+    {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"},
+    {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"},
+    {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"},
+    {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"},
+    {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"},
+    {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"},
+    {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"},
+    {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"},
+    {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"},
+    {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"},
+    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"},
+    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"},
+    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"},
+    {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"},
+    {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"},
+    {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"},
+    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"},
+    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"},
+    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"},
+    {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"},
+    {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"},
+    {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"},
+    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"},
+    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"},
+    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"},
+    {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"},
+    {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"},
+    {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"},
+    {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"},
+    {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"},
+    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"},
+    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"},
+    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"},
+    {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"},
+    {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"},
+    {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"},
+    {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"},
+]
+
+[[package]]
+name = "requests"
+version = "2.32.3"
+description = "Python HTTP for Humans."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"},
+    {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"},
+]
+
+[package.dependencies]
+certifi = ">=2017.4.17"
+charset-normalizer = ">=2,<4"
+idna = ">=2.5,<4"
+urllib3 = ">=1.21.1,<3"
+
+[package.extras]
+socks = ["PySocks (>=1.5.6,!=1.5.7)"]
+use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
+
+[[package]]
+name = "rich"
+version = "13.7.1"
+description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal"
+optional = false
+python-versions = ">=3.7.0"
+files = [
+    {file = "rich-13.7.1-py3-none-any.whl", hash = "sha256:4edbae314f59eb482f54e9e30bf00d33350aaa94f4bfcd4e9e3110e64d0d7222"},
+    {file = "rich-13.7.1.tar.gz", hash = "sha256:9be308cb1fe2f1f57d67ce99e95af38a1e2bc71ad9813b0e247cf7ffbcc3a432"},
+]
+
+[package.dependencies]
+markdown-it-py = ">=2.2.0"
+pygments = ">=2.13.0,<3.0.0"
+
+[package.extras]
+jupyter = ["ipywidgets (>=7.5.1,<9)"]
+
+[[package]]
+name = "ruff"
+version = "0.5.5"
+description = "An extremely fast Python linter and code formatter, written in Rust."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "ruff-0.5.5-py3-none-linux_armv6l.whl", hash = "sha256:605d589ec35d1da9213a9d4d7e7a9c761d90bba78fc8790d1c5e65026c1b9eaf"},
+    {file = "ruff-0.5.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:00817603822a3e42b80f7c3298c8269e09f889ee94640cd1fc7f9329788d7bf8"},
+    {file = "ruff-0.5.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:187a60f555e9f865a2ff2c6984b9afeffa7158ba6e1eab56cb830404c942b0f3"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe26fc46fa8c6e0ae3f47ddccfbb136253c831c3289bba044befe68f467bfb16"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4ad25dd9c5faac95c8e9efb13e15803cd8bbf7f4600645a60ffe17c73f60779b"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f70737c157d7edf749bcb952d13854e8f745cec695a01bdc6e29c29c288fc36e"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:cfd7de17cef6ab559e9f5ab859f0d3296393bc78f69030967ca4d87a541b97a0"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a09b43e02f76ac0145f86a08e045e2ea452066f7ba064fd6b0cdccb486f7c3e7"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d0b856cb19c60cd40198be5d8d4b556228e3dcd545b4f423d1ad812bfdca5884"},
+    {file = "ruff-0.5.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3687d002f911e8a5faf977e619a034d159a8373514a587249cc00f211c67a091"},
+    {file = "ruff-0.5.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:ac9dc814e510436e30d0ba535f435a7f3dc97f895f844f5b3f347ec8c228a523"},
+    {file = "ruff-0.5.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:af9bdf6c389b5add40d89b201425b531e0a5cceb3cfdcc69f04d3d531c6be74f"},
+    {file = "ruff-0.5.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d40a8533ed545390ef8315b8e25c4bb85739b90bd0f3fe1280a29ae364cc55d8"},
+    {file = "ruff-0.5.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:cab904683bf9e2ecbbe9ff235bfe056f0eba754d0168ad5407832928d579e7ab"},
+    {file = "ruff-0.5.5-py3-none-win32.whl", hash = "sha256:696f18463b47a94575db635ebb4c178188645636f05e934fdf361b74edf1bb2d"},
+    {file = "ruff-0.5.5-py3-none-win_amd64.whl", hash = "sha256:50f36d77f52d4c9c2f1361ccbfbd09099a1b2ea5d2b2222c586ab08885cf3445"},
+    {file = "ruff-0.5.5-py3-none-win_arm64.whl", hash = "sha256:3191317d967af701f1b73a31ed5788795936e423b7acce82a2b63e26eb3e89d6"},
+    {file = "ruff-0.5.5.tar.gz", hash = "sha256:cc5516bdb4858d972fbc31d246bdb390eab8df1a26e2353be2dbc0c2d7f5421a"},
+]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+description = "Python 2 and 3 compatibility utilities"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
+    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
+]
+
+[[package]]
+name = "snowballstemmer"
+version = "2.2.0"
+description = "This package provides 29 stemmers for 28 languages generated from Snowball algorithms."
+optional = false
+python-versions = "*"
+files = [
+    {file = "snowballstemmer-2.2.0-py2.py3-none-any.whl", hash = "sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a"},
+    {file = "snowballstemmer-2.2.0.tar.gz", hash = "sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1"},
+]
+
+[[package]]
+name = "sphinx"
+version = "7.4.7"
+description = "Python documentation generator"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "sphinx-7.4.7-py3-none-any.whl", hash = "sha256:c2419e2135d11f1951cd994d6eb18a1835bd8fdd8429f9ca375dc1f3281bd239"},
+    {file = "sphinx-7.4.7.tar.gz", hash = "sha256:242f92a7ea7e6c5b406fdc2615413890ba9f699114a9c09192d7dfead2ee9cfe"},
+]
+
+[package.dependencies]
+alabaster = ">=0.7.14,<0.8.0"
+babel = ">=2.13"
+colorama = {version = ">=0.4.6", markers = "sys_platform == \"win32\""}
+docutils = ">=0.20,<0.22"
+imagesize = ">=1.3"
+importlib-metadata = {version = ">=6.0", markers = "python_version < \"3.10\""}
+Jinja2 = ">=3.1"
+packaging = ">=23.0"
+Pygments = ">=2.17"
+requests = ">=2.30.0"
+snowballstemmer = ">=2.2"
+sphinxcontrib-applehelp = "*"
+sphinxcontrib-devhelp = "*"
+sphinxcontrib-htmlhelp = ">=2.0.0"
+sphinxcontrib-jsmath = "*"
+sphinxcontrib-qthelp = "*"
+sphinxcontrib-serializinghtml = ">=1.1.9"
+tomli = {version = ">=2", markers = "python_version < \"3.11\""}
+
+[package.extras]
+docs = ["sphinxcontrib-websupport"]
+lint = ["flake8 (>=6.0)", "importlib-metadata (>=6.0)", "mypy (==1.10.1)", "pytest (>=6.0)", "ruff (==0.5.2)", "sphinx-lint (>=0.9)", "tomli (>=2)", "types-docutils (==0.21.0.20240711)", "types-requests (>=2.30.0)"]
+test = ["cython (>=3.0)", "defusedxml (>=0.7.1)", "pytest (>=8.0)", "setuptools (>=70.0)", "typing_extensions (>=4.9)"]
+
+[[package]]
+name = "sphinxcontrib-applehelp"
+version = "1.0.8"
+description = "sphinxcontrib-applehelp is a Sphinx extension which outputs Apple help books"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "sphinxcontrib_applehelp-1.0.8-py3-none-any.whl", hash = "sha256:cb61eb0ec1b61f349e5cc36b2028e9e7ca765be05e49641c97241274753067b4"},
+    {file = "sphinxcontrib_applehelp-1.0.8.tar.gz", hash = "sha256:c40a4f96f3776c4393d933412053962fac2b84f4c99a7982ba42e09576a70619"},
+]
+
+[package.extras]
+lint = ["docutils-stubs", "flake8", "mypy"]
+standalone = ["Sphinx (>=5)"]
+test = ["pytest"]
+
+[[package]]
+name = "sphinxcontrib-devhelp"
+version = "1.0.6"
+description = "sphinxcontrib-devhelp is a sphinx extension which outputs Devhelp documents"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "sphinxcontrib_devhelp-1.0.6-py3-none-any.whl", hash = "sha256:6485d09629944511c893fa11355bda18b742b83a2b181f9a009f7e500595c90f"},
+    {file = "sphinxcontrib_devhelp-1.0.6.tar.gz", hash = "sha256:9893fd3f90506bc4b97bdb977ceb8fbd823989f4316b28c3841ec128544372d3"},
+]
+
+[package.extras]
+lint = ["docutils-stubs", "flake8", "mypy"]
+standalone = ["Sphinx (>=5)"]
+test = ["pytest"]
+
+[[package]]
+name = "sphinxcontrib-htmlhelp"
+version = "2.0.6"
+description = "sphinxcontrib-htmlhelp is a sphinx extension which renders HTML help files"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "sphinxcontrib_htmlhelp-2.0.6-py3-none-any.whl", hash = "sha256:1b9af5a2671a61410a868fce050cab7ca393c218e6205cbc7f590136f207395c"},
+    {file = "sphinxcontrib_htmlhelp-2.0.6.tar.gz", hash = "sha256:c6597da06185f0e3b4dc952777a04200611ef563882e0c244d27a15ee22afa73"},
+]
+
+[package.extras]
+lint = ["docutils-stubs", "flake8", "mypy"]
+standalone = ["Sphinx (>=5)"]
+test = ["html5lib", "pytest"]
+
+[[package]]
+name = "sphinxcontrib-jsmath"
+version = "1.0.1"
+description = "A sphinx extension which renders display math in HTML via JavaScript"
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8"},
+    {file = "sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178"},
+]
+
+[package.extras]
+test = ["flake8", "mypy", "pytest"]
+
+[[package]]
+name = "sphinxcontrib-qthelp"
+version = "1.0.8"
+description = "sphinxcontrib-qthelp is a sphinx extension which outputs QtHelp documents"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "sphinxcontrib_qthelp-1.0.8-py3-none-any.whl", hash = "sha256:323d6acc4189af76dfe94edd2a27d458902319b60fcca2aeef3b2180c106a75f"},
+    {file = "sphinxcontrib_qthelp-1.0.8.tar.gz", hash = "sha256:db3f8fa10789c7a8e76d173c23364bdf0ebcd9449969a9e6a3dd31b8b7469f03"},
+]
+
+[package.extras]
+lint = ["docutils-stubs", "flake8", "mypy"]
+standalone = ["Sphinx (>=5)"]
+test = ["defusedxml (>=0.7.1)", "pytest"]
+
+[[package]]
+name = "sphinxcontrib-serializinghtml"
+version = "1.1.10"
+description = "sphinxcontrib-serializinghtml is a sphinx extension which outputs \"serialized\" HTML files (json and pickle)"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "sphinxcontrib_serializinghtml-1.1.10-py3-none-any.whl", hash = "sha256:326369b8df80a7d2d8d7f99aa5ac577f51ea51556ed974e7716cfd4fca3f6cb7"},
+    {file = "sphinxcontrib_serializinghtml-1.1.10.tar.gz", hash = "sha256:93f3f5dc458b91b192fe10c397e324f262cf163d79f3282c158e8436a2c4511f"},
+]
+
+[package.extras]
+lint = ["docutils-stubs", "flake8", "mypy"]
+standalone = ["Sphinx (>=5)"]
+test = ["pytest"]
+
+[[package]]
+name = "stevedore"
+version = "5.2.0"
+description = "Manage dynamic plugins for Python applications"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "stevedore-5.2.0-py3-none-any.whl", hash = "sha256:1c15d95766ca0569cad14cb6272d4d31dae66b011a929d7c18219c176ea1b5c9"},
+    {file = "stevedore-5.2.0.tar.gz", hash = "sha256:46b93ca40e1114cea93d738a6c1e365396981bb6bb78c27045b7587c9473544d"},
+]
+
+[package.dependencies]
+pbr = ">=2.0.0,<2.1.0 || >2.1.0"
+
+[[package]]
+name = "tomli"
+version = "2.0.1"
+description = "A lil' TOML parser"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
+    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
+]
+
+[[package]]
+name = "tomlkit"
+version = "0.13.0"
+description = "Style preserving TOML library"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "tomlkit-0.13.0-py3-none-any.whl", hash = "sha256:7075d3042d03b80f603482d69bf0c8f345c2b30e41699fd8883227f89972b264"},
+    {file = "tomlkit-0.13.0.tar.gz", hash = "sha256:08ad192699734149f5b97b45f1f18dad7eb1b6d16bc72ad0c2335772650d7b72"},
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+description = "Backported and Experimental Type Hints for Python 3.8+"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
+    {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
+]
+
+[[package]]
+name = "urllib3"
+version = "2.2.2"
+description = "HTTP library with thread-safe connection pooling, file post, and more."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "urllib3-2.2.2-py3-none-any.whl", hash = "sha256:a448b2f64d686155468037e1ace9f2d2199776e17f0a46610480d311f73e3472"},
+    {file = "urllib3-2.2.2.tar.gz", hash = "sha256:dd505485549a7a552833da5e6063639d0d177c04f23bc3864e41e5dc5f612168"},
+]
+
+[package.extras]
+brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
+h2 = ["h2 (>=4,<5)"]
+socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
+zstd = ["zstandard (>=0.18.0)"]
+
+[[package]]
+name = "zipp"
+version = "3.19.2"
+description = "Backport of pathlib-compatible object wrapper for zip files"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "zipp-3.19.2-py3-none-any.whl", hash = "sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c"},
+    {file = "zipp-3.19.2.tar.gz", hash = "sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19"},
+]
+
+[package.extras]
+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]
+test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy", "pytest-ruff (>=0.2.1)"]
+
+[metadata]
+lock-version = "2.0"
+python-versions = ">=3.9"
+content-hash = "6ea4c2425b97c5bf3af44fb604475d87dcd7b12861e2fc5b84acaf7539c3e368"
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..a60f604
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,42 @@
+[tool.poetry]
+name = "m2r2"
+version = "1.0.0"
+description = "Markdown and reStructuredText in a single file."
+authors = ["CrossNox <ijmermet+m2r2@gmail.com>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.scripts]
+m2r2 = "m2r2:main"
+
+[tool.poetry.dependencies]
+python = ">=3.9"
+mistune = ">=2.0,<3.0"
+docutils = ">=0.16,<0.22"
+
+
+[tool.poetry.group.dev.dependencies]
+pygments = "^2.18.0"
+black = "^24.4.2"
+isort = "^5.13.2"
+pylint = "^3.2.6"
+mypy = "^1.11.0"
+ruff = "^0.5.5"
+bandit = "^1.7.9"
+
+[tool.poetry.group.testing.dependencies]
+pytest = "^8.3.2"
+pytest-cov = "^5.0.0"
+six = "^1.16.0"
+sphinx = "^7.4.7"
+
+[tool.bandit]
+exclude_dirs = ["tests"]
+
+[tool.mypy]
+ignore_missing_imports = true
+follow_imports = "skip"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
diff --git a/requirements-dev.txt b/requirements-dev.txt
deleted file mode 100644
index 17c16a1..0000000
--- a/requirements-dev.txt
+++ /dev/null
@@ -1,10 +0,0 @@
--r requirements-test.txt
-black==22.3.0
-bump2version==1.0.1
-flake8==3.7.8
-isort==4.3.21
-livereload
-mypy==0.770
-nox
-pre-commit==2.2.0
-pylint==2.4.4
diff --git a/requirements-test.txt b/requirements-test.txt
deleted file mode 100644
index 0dc9a78..0000000
--- a/requirements-test.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-pytest
-pytest-cov
-six
-sphinx
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 8c5e43d..0000000
--- a/setup.py
+++ /dev/null
@@ -1,61 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-from os import path
-
-try:
-    from setuptools import setup
-except ImportError:
-    from distutils.core import setup
-
-readme_file = path.join(path.dirname(path.abspath(__file__)), "README.md")
-try:
-    from m2r2 import parse_from_file
-
-    readme = parse_from_file(readme_file)
-except (ImportError, TypeError):
-    with open(readme_file) as f:
-        readme = f.read()
-
-
-__version__ = "1.0.0"
-
-install_requires = ["mistune>=2.0.0,<3.0", "docutils>=0.16,<1.0"]
-test_requirements = ["pygments"]
-
-setup(
-    name="m2r2",
-    version=__version__,
-    description="Markdown and reStructuredText in a single file.",
-    long_description=readme,
-    long_description_content_type="text/markdown",
-    author="Hiroyuki Takagi",
-    author_email="miyako.dev@gmail.com",
-    maintainer="CrossNox",
-    maintainer_email="ijmermet+m2r2@gmail.com",
-    url="https://github.com/crossnox/m2r2",
-    py_modules=["m2r2"],
-    entry_points={"console_scripts": "m2r2 = m2r2:main"},
-    include_package_data=True,
-    license="MIT",
-    zip_safe=False,
-    keywords="Markdown reStructuredText sphinx-extension",
-    classifiers=[
-        "Development Status :: 4 - Beta",
-        "Framework :: Sphinx :: Extension",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Natural Language :: English",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Topic :: Text Processing",
-    ],
-    install_requires=install_requires,
-    test_suite="tests",
-    tests_require=test_requirements,
-    python_requires=">=3.7",
-    packages=["m2r2"],
-)

From 39498a5f34ae2742230ee5dd905a89f57fae0ea6 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Sun, 28 Jul 2024 20:39:48 -0300
Subject: [PATCH 11/22] refactor cli

---
 .pre-commit-config.yaml |  11 ---
 m2r2/cli/m2r2.py        | 164 ++++++++++++++++++++++++----------------
 2 files changed, 97 insertions(+), 78 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 60c301e..cd01ea8 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -6,17 +6,6 @@ repos:
     - id: requirements-txt-fixer
 - repo: local
   hooks:
-    - id: flake8
-      name: flake8
-      entry: flake8
-      language: system
-      types: [python]
-      args: [--max-line-length=88]
-      exclude: |
-            (?x)^(
-                docs*|
-                test*
-            )$
     - id: isort
       name: isort
       entry: isort
diff --git a/m2r2/cli/m2r2.py b/m2r2/cli/m2r2.py
index c706367..3eda121 100644
--- a/m2r2/cli/m2r2.py
+++ b/m2r2/cli/m2r2.py
@@ -1,84 +1,114 @@
+import argparse
 import os
-from argparse import ArgumentParser, Namespace
+from pathlib import Path
 
 from m2r2 import convert
 
-parser = ArgumentParser()
-options = Namespace()
-parser.add_argument("input_file", nargs="*", help="files to convert to reST format")
-parser.add_argument(
-    "--overwrite",
-    action="store_true",
-    default=False,
-    help="overwrite output file without confirmaion",
-)
-parser.add_argument(
-    "--dry-run",
-    action="store_true",
-    default=False,
-    help="print conversion result and not save output file",
-)
-parser.add_argument(
-    "--no-underscore-emphasis",
-    action="store_true",
-    default=False,
-    help="do not use underscore (_) for emphasis",
-)
-parser.add_argument(
-    "--parse-relative-links",
-    action="store_true",
-    default=False,
-    help="parse relative links into ref or doc directives",
-)
-parser.add_argument(
-    "--anonymous-references",
-    action="store_true",
-    default=False,
-    help="use anonymous references in generated rst",
-)
-parser.add_argument(
-    "--disable-inline-math",
-    action="store_true",
-    default=False,
-    help="disable parsing inline math",
-)
-
-
-def parse_options():
-    parser.parse_known_args(namespace=options)
-
-
-def parse_from_file(file, encoding="utf-8", **kwargs):
-    if not os.path.exists(file):
-        raise OSError("No such file exists: {}".format(file))
-    with open(file, encoding=encoding) as f:
+
+def parse_arguments() -> argparse.Namespace | None:
+    parser = argparse.ArgumentParser(description="Convert files to reST format")
+    # TODO: add breaking change to changelog
+    parser.add_argument(
+        "input_files", nargs="*", type=Path, help="Files to convert to reST format"
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        default=False,
+        help="Overwrite output file without confirmation",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        default=False,
+        help="Print conversion result without saving output file",
+    )
+    parser.add_argument(
+        "--no-underscore-emphasis",
+        action="store_true",
+        default=False,
+        help="Do not use underscore (_) for emphasis",
+    )
+    parser.add_argument(
+        "--parse-relative-links",
+        action="store_true",
+        default=False,
+        help="Parse relative links into ref or doc directives",
+    )
+    parser.add_argument(
+        "--anonymous-references",
+        action="store_true",
+        default=False,
+        help="Use anonymous references in generated rst",
+    )
+    parser.add_argument(
+        "--disable-inline-math",
+        action="store_true",
+        default=False,
+        help="Disable parsing inline math",
+    )
+
+    args = parser.parse_args()
+
+    if not args.input_files:
+        parser.print_help()
+        return None
+
+    return args
+
+
+def parse_from_file(file: str | Path, encoding: str = "utf-8", **kwargs) -> str:
+    file_path = Path(file)
+    if not file_path.exists():
+        raise FileNotFoundError(f"No such file exists: {file_path}")
+
+    with open(file_path, encoding=encoding) as f:
         src = f.read()
-    output = convert(src, **kwargs)
-    return output
 
+    return convert(src, **kwargs)
 
-def save_to_file(file, src, encoding="utf-8", **kwargs):
-    target = os.path.splitext(file)[0] + ".rst"
-    if not options.overwrite and os.path.exists(target):
-        confirm = input("{} already exists. overwrite it? [y/n]: ".format(target))
-        if confirm.upper() not in ("Y", "YES"):
-            print("skip {}".format(file))
+
+def save_to_file(
+    file: str | Path, content: str, encoding: str = "utf-8", overwrite: bool = False
+) -> None:
+    """
+    Save content to a file, optionally overwriting existing files.
+
+    Args:
+        file (str): The input file path.
+        content (str): The content to be written to the file.
+        encoding (str, optional): The encoding to use for the file. Defaults to "utf-8".
+        overwrite (bool, optional): Whether to overwrite existing files without prompting. Defaults to False.
+
+    Returns:
+        None
+    """
+    target = Path(file).with_suffix(".rst")
+
+    if not overwrite and target.exists():
+        confirm = input(f"{target} already exists. Overwrite it? [y/N]: ").lower()
+        if confirm not in ("y", "yes"):
+            print(f"Skipping {file}")
             return
+
     with open(target, "w", encoding=encoding) as f:
-        f.write(src)
+        f.write(content)
 
 
 def main():
-    parse_options()  # parse cli options
-    if not options.input_file:
-        parser.print_help()
-        parser.exit(0)
-    for file in options.input_file:
-        output = parse_from_file(file)
-        if options.dry_run:
+    args = parse_arguments()
+
+    if args is None:
+        return
+
+    for file in args.input_files:
+        output = parse_from_file(
+            file,
+        )
+        if args.dry_run:
             print(output)
         else:
-            save_to_file(file, output)
+            save_to_file(file, output, overwrite=args.overwrite)
 
 
 if __name__ == "__main__":

From 80881b5b4a0ff06ddc1a37d0e619965c33e204a1 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Sun, 28 Jul 2024 20:40:15 -0300
Subject: [PATCH 12/22] add reminder

---
 m2r2/m2r2.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 05fa4b0..7c05943 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -13,6 +13,7 @@
 __version__ = get_distribution("m2r2").version
 
 
+# TODO: check this
 class M2R(mistune.Markdown):
     def __init__(self, renderer=None, block=None, inline=None, plugins=None):
         renderer = renderer or RestRenderer()

From ca4e29fb30e1eb756312397662499b42acdaa66e Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Sun, 28 Jul 2024 22:39:11 -0300
Subject: [PATCH 13/22] linters

---
 .pre-commit-config.yaml |  89 ++++++++++++++++---------------
 .pylintrc               |  12 -----
 dprint.json             |  29 +++++++++++
 m2r2/cli/m2r2.py        |   1 -
 m2r2/m2r2.py            |  22 ++++++--
 m2r2/parser.py          |   7 +--
 m2r2/rst/parser.py      |   6 +--
 m2r2/rst/renderer.py    |  87 ++++++++++++++-----------------
 poetry.lock             | 112 +++++++++++++++++++++++++++++++++++++++-
 pyproject.toml          |  29 ++++++++++-
 10 files changed, 272 insertions(+), 122 deletions(-)
 delete mode 100644 .pylintrc
 create mode 100644 dprint.json

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index cd01ea8..922265f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,46 +1,45 @@
 repos:
-- repo: https://github.com/pre-commit/pre-commit-hooks
-  rev: v4.3.0
-  hooks:
-    - id: trailing-whitespace
-    - id: requirements-txt-fixer
-- repo: local
-  hooks:
-    - id: isort
-      name: isort
-      entry: isort
-      language: system
-      types: [python]
-      args: [--multi-line=3,--trailing-comma,--force-grid-wrap=0,--use-parentheses,--line-width=88]
-      exclude: |
-            (?x)^(
-                docs*|
-                test*
-            )$
-    - id: black
-      name: black
-      entry: black
-      language: system
-      types: [python]
-      args: []
-      exclude: |
-            (?x)^(
-                docs*|
-                test*
-            )$
-    - id: mypy
-      name: mypy
-      entry: mypy
-      language: system
-      types: [python]
-      exclude: |
-            (?x)^(
-                docs*|
-                test*
-            )$
-    - id: pylint
-      name: pylint
-      entry: pylint
-      language: system
-      types: [python]
-      exclude: (tests|docs)*
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+      - id: trailing-whitespace
+      - id: requirements-txt-fixer
+  - repo: local
+    hooks:
+      - id: isort
+        name: isort
+        entry: poetry run isort
+        language: system
+        types: [python]
+        exclude: |
+          (?x)^(
+              docs*|
+              test*
+          )$
+      - id: black
+        name: black
+        entry: poetry run black
+        language: system
+        types: [python]
+        args: []
+        exclude: |
+          (?x)^(
+              docs*|
+              test*
+          )$
+      - id: mypy
+        name: mypy
+        entry: poetry run mypy
+        language: system
+        types: [python]
+        exclude: |
+          (?x)^(
+              docs*|
+              test*
+          )$
+      - id: pylint
+        name: pylint
+        entry: poetry run pylint
+        language: system
+        types: [python]
+        exclude: (tests|docs)*
diff --git a/.pylintrc b/.pylintrc
deleted file mode 100644
index 584ef4b..0000000
--- a/.pylintrc
+++ /dev/null
@@ -1,12 +0,0 @@
-[FORMAT]
-# Good variable names which should always be accepted, separated by a comma
-good-names=i,j,k,e,_,pk,x,y,f,logger,config,df,a,h3,ul,li,td,app,api,ma
-
-[MISCELLANEOUS]
-# List of note tags to take in consideration, separated by a comma.
-notes=XXX
-ignored-classes=SQLObject,Registrant,scoped_session
-
-[MESSAGES CONTROL]
-disable=bad-continuation,too-many-locals,len-as-condition
-
diff --git a/dprint.json b/dprint.json
new file mode 100644
index 0000000..ca07e6d
--- /dev/null
+++ b/dprint.json
@@ -0,0 +1,29 @@
+{
+  "typescript": {
+  },
+  "json": {
+  },
+  "markdown": {
+  },
+  "toml": {
+  },
+  "malva": {
+  },
+  "markup": {
+  },
+  "yaml": {
+  },
+  "excludes": [
+    "**/node_modules",
+    "**/*-lock.json"
+  ],
+  "plugins": [
+    "https://plugins.dprint.dev/typescript-0.91.4.wasm",
+    "https://plugins.dprint.dev/json-0.19.3.wasm",
+    "https://plugins.dprint.dev/markdown-0.17.2.wasm",
+    "https://plugins.dprint.dev/toml-0.6.2.wasm",
+    "https://plugins.dprint.dev/g-plane/malva-v0.5.1.wasm",
+    "https://plugins.dprint.dev/g-plane/markup_fmt-v0.11.0.wasm",
+    "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.4.0.wasm"
+  ]
+}
diff --git a/m2r2/cli/m2r2.py b/m2r2/cli/m2r2.py
index 3eda121..bec82dc 100644
--- a/m2r2/cli/m2r2.py
+++ b/m2r2/cli/m2r2.py
@@ -1,5 +1,4 @@
 import argparse
-import os
 from pathlib import Path
 
 from m2r2 import convert
diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 7c05943..532db1d 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -15,10 +15,26 @@
 
 # TODO: check this
 class M2R(mistune.Markdown):
-    def __init__(self, renderer=None, block=None, inline=None, plugins=None):
-        renderer = renderer or RestRenderer()
+    def __init__(
+        self,
+        renderer=None,
+        block=None,
+        inline=None,
+        plugins=None,
+        use_mermaid: bool = False,
+        parse_relative_links: bool = False,
+        anonymous_references: bool = False,
+        disable_inline_math: bool = True,
+    ):
+        renderer = renderer or RestRenderer(
+            use_mermaid=use_mermaid,
+            parse_relative_links=parse_relative_links,
+            anonymous_references=anonymous_references,
+        )
         block = block or RestBlockParser()
-        inline = inline or RestInlineParser(renderer)
+        inline = inline or RestInlineParser(
+            renderer, disable_inline_math=disable_inline_math
+        )
         super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
 
     def parse(self, text):
diff --git a/m2r2/parser.py b/m2r2/parser.py
index 35b8aff..c3d27fb 100644
--- a/m2r2/parser.py
+++ b/m2r2/parser.py
@@ -8,11 +8,8 @@ class M2RParser(rst.Parser):
     # Explicitly tell supported formats to sphinx
     supported = ("markdown", "md", "mkd")
 
-    def parse(self, inputstrings, document):
-        if isinstance(inputstrings, statemachine.StringList):
-            inputstring = "\n".join(inputstrings)
-        else:
-            inputstring = inputstrings
+    def parse(self, inputstring, document):
+        """Parse `inputstring` and populate `document`, a document tree."""
         config = document.settings.env.config
         converter = M2R(
             no_underscore_emphasis=config.no_underscore_emphasis,
diff --git a/m2r2/rst/parser.py b/m2r2/rst/parser.py
index 384800a..c2983d5 100644
--- a/m2r2/rst/parser.py
+++ b/m2r2/rst/parser.py
@@ -64,7 +64,7 @@ class RestInlineParser(mistune.InlineParser):
         r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
     )
 
-    RUlE_NAMES = (
+    RULE_NAMES = (
         "inline_math",
         "image_link",
         "rest_role",
@@ -120,7 +120,7 @@ def __init__(self, renderer, *args, **kwargs):
         if disable_inline_math:  # or getattr(options, "disable_inline_math", False):
             if inline_maths:
                 self.RULE_NAMES = tuple(
-                    x for x in self.RUlE_NAMES if x != "inline_math"
+                    x for x in self.RULE_NAMES if x != "inline_math"
                 )
         elif not inline_maths:
-            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
+            self.RULE_NAMES = ("inline_math", *self.RULE_NAMES)
diff --git a/m2r2/rst/renderer.py b/m2r2/rst/renderer.py
index 6a830cf..1efa975 100644
--- a/m2r2/rst/renderer.py
+++ b/m2r2/rst/renderer.py
@@ -43,7 +43,7 @@ def _indent_block(self, block):
 
     def _raw_html(self, html):
         self._include_raw_html = True
-        return r"\ :raw-html-m2r:`{}`\ ".format(html)
+        return rf"\ :raw-html-m2r:`{html}`\ "
 
     def block_code(self, code, lang=None):
         if lang == "math":
@@ -51,7 +51,7 @@ def block_code(self, code, lang=None):
         elif lang == "mermaid" and self.use_mermaid:
             first_line = "\n.. mermaid::\n\n"
         elif lang:
-            first_line = "\n.. code-block:: {}\n\n".format(lang)
+            first_line = f"\n.. code-block:: {lang}\n\n"
         elif _is_sphinx:
             first_line = "\n::\n\n"
         else:
@@ -60,7 +60,8 @@ def block_code(self, code, lang=None):
 
     def block_quote(self, text):
         # text includes some empty line
-        return "\n..\n\n{}\n\n".format(self._indent_block(text.strip("\n")))
+        quote_text = self._indent_block(text.strip("\n"))
+        return f"\n..\n\n{quote_text}\n\n"
 
     def block_text(self, text):
         return text
@@ -79,7 +80,7 @@ def header(self, text, level, raw=None):
         :param level: a number for the header level, for example: 1.
         :param raw: raw text content of the header.
         """
-        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
+        return f"\n{text}\n{self.hmarks[level] * column_width(text)}\n"
 
     def heading(self, text, level, raw=None):
         """Rendering header/heading tags like ``<h1>`` ``<h2>``.
@@ -228,42 +229,31 @@ def link(self, link, title, text):
             underscore = "__"
         else:
             underscore = "_"
+
         if title:
-            return self._raw_html(
-                '<a href="{link}" title="{title}">{text}</a>'.format(
-                    link=link, title=title, text=text
-                )
-            )
+            return self._raw_html(f'<a href="{link}" title="{title}">{text}</a>')
+
         if not self.parse_relative_links:
-            return r"\ `{text} <{target}>`{underscore}\ ".format(
-                target=link, text=text, underscore=underscore
-            )
-        else:
-            url_info = urlparse(link)
-            if url_info.scheme:
-                return r"\ `{text} <{target}>`{underscore}\ ".format(
-                    target=link, text=text, underscore=underscore
-                )
+            return rf"\ `{text} <{link}>`{underscore}\ "
+
+        url_info = urlparse(link)
+        if url_info.scheme:
+            return rf"\ `{text} <{link}>`{underscore}\ "
+
+        link_type = "doc"
+        anchor = url_info.fragment
+        if url_info.fragment:
+            if url_info.path:
+                # Can't link to anchors via doc directive.
+                anchor = ""
             else:
-                link_type = "doc"
-                anchor = url_info.fragment
-                if url_info.fragment:
-                    if url_info.path:
-                        # Can't link to anchors via doc directive.
-                        anchor = ""
-                    else:
-                        # Example: [text](#anchor)
-                        link_type = "ref"
-                doc_link = "{doc_name}{anchor}".format(
-                    # splittext approach works whether or not path is set. It
-                    # will return an empty string if unset, which leads to
-                    # anchor only ref.
-                    doc_name=os.path.splitext(url_info.path)[0],
-                    anchor=anchor,
-                )
-                return r"\ :{link_type}:`{text} <{doc_link}>`\ ".format(
-                    link_type=link_type, doc_link=doc_link, text=text
-                )
+                # Example: [text](#anchor)
+                link_type = "ref"
+        doc_link = f"{os.path.splitext(url_info.path)[0]}{anchor}"
+        # splittext approach works whether or not path is set. It
+        # will return an empty string if unset, which leads to
+        # anchor only ref.
+        return rf"\ :{link_type}:`{text} <{doc_link}>`\ "
 
     def image(self, src, title, text):
         """Rendering a image with title and text.
@@ -277,9 +267,9 @@ def image(self, src, title, text):
         return "\n".join(
             [
                 "",
-                ".. image:: {}".format(src),
-                "   :target: {}".format(src),
-                "   :alt: {}".format(text),
+                f".. image:: {src}",
+                f"   :target: {src}",
+                f"   :alt: {tex}",
                 "",
             ]
         )
@@ -301,7 +291,7 @@ def footnote_ref(self, key, index):
         :param key: identity key for the footnote.
         :param index: the index count of current footnote.
         """
-        return r"\ [#fn-{}]_\ ".format(key)
+        return rf"\ [#fn-{key}]_\ "
 
     def footnote_item(self, key, text):
         """Rendering a footnote item.
@@ -309,7 +299,7 @@ def footnote_item(self, key, text):
         :param key: identity key for the footnote.
         :param text: text content of the footnote.
         """
-        return ".. [#fn-{0}] {1}\n".format(key, text.strip())
+        return f".. [#fn-{key}] {text.strip()}\n"
 
     def footnotes(self, text):
         """Wrapper for all footnotes.
@@ -318,18 +308,17 @@ def footnotes(self, text):
         """
         if text:
             return "\n\n" + text
-        else:
-            return ""
+        return ""
 
-    """Below outputs are for rst."""
+    # Below outputs are for rst.
 
     def image_link(self, url, target, alt):
         return "\n".join(
             [
                 "",
-                ".. image:: {}".format(url),
-                "   :target: {}".format(target),
-                "   :alt: {}".format(alt),
+                f".. image:: {url}",
+                f"   :target: {target}",
+                f"   :alt: {alt}",
                 "",
             ]
         )
@@ -342,7 +331,7 @@ def rest_link(self, text):
 
     def inline_math(self, math):
         """Extension of recommonmark."""
-        return r":math:`{}`".format(math)
+        return rf":math:`{math}`"
 
     def eol_literal_marker(self, marker):
         """Extension of recommonmark."""
diff --git a/poetry.lock b/poetry.lock
index 999fa86..96e4cf7 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -434,6 +434,46 @@ MarkupSafe = ">=2.0"
 [package.extras]
 i18n = ["Babel (>=2.7)"]
 
+[[package]]
+name = "libcst"
+version = "1.4.0"
+description = "A concrete syntax tree with AST-like properties for Python 3.0 through 3.12 programs."
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "libcst-1.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:279b54568ea1f25add50ea4ba3d76d4f5835500c82f24d54daae4c5095b986aa"},
+    {file = "libcst-1.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3401dae41fe24565387a65baee3887e31a44e3e58066b0250bc3f3ccf85b1b5a"},
+    {file = "libcst-1.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1989fa12d3cd79118ebd29ebe2a6976d23d509b1a4226bc3d66fcb7cb50bd5d"},
+    {file = "libcst-1.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:addc6d585141a7677591868886f6bda0577529401a59d210aa8112114340e129"},
+    {file = "libcst-1.4.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:17d71001cb25e94cfe8c3d997095741a8c4aa7a6d234c0f972bc42818c88dfaf"},
+    {file = "libcst-1.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:2d47de16d105e7dd5f4e01a428d9f4dc1e71efd74f79766daf54528ce37f23c3"},
+    {file = "libcst-1.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e6227562fc5c9c1efd15dfe90b0971ae254461b8b6b23c1b617139b6003de1c1"},
+    {file = "libcst-1.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3399e6c95df89921511b44d8c5bf6a75bcbc2d51f1f6429763609ba005c10f6b"},
+    {file = "libcst-1.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48601e3e590e2d6a7ab8c019cf3937c70511a78d778ab3333764531253acdb33"},
+    {file = "libcst-1.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f42797309bb725f0f000510d5463175ccd7155395f09b5e7723971b0007a976d"},
+    {file = "libcst-1.4.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cb4e42ea107a37bff7f9fdbee9532d39f9ea77b89caa5c5112b37057b12e0838"},
+    {file = "libcst-1.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:9d0cc3c5a2a51fa7e1d579a828c0a2e46b2170024fd8b1a0691c8a52f3abb2d9"},
+    {file = "libcst-1.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7ece51d935bc9bf60b528473d2e5cc67cbb88e2f8146297e40ee2c7d80be6f13"},
+    {file = "libcst-1.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:81653dea1cdfa4c6520a7c5ffb95fa4d220cbd242e446c7a06d42d8636bfcbba"},
+    {file = "libcst-1.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6abce0e66bba2babfadc20530fd3688f672d565674336595b4623cd800b91ef"},
+    {file = "libcst-1.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5da9d7dc83801aba3b8d911f82dc1a375db0d508318bad79d9fb245374afe068"},
+    {file = "libcst-1.4.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c54aa66c86d8ece9c93156a2cf5ca512b0dce40142fe9e072c86af2bf892411"},
+    {file = "libcst-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:62e2682ee1567b6a89c91853865372bf34f178bfd237853d84df2b87b446e654"},
+    {file = "libcst-1.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b8ecdba8934632b4dadacb666cd3816627a6ead831b806336972ccc4ba7ca0e9"},
+    {file = "libcst-1.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8e54c777b8d27339b70f304d16fc8bc8674ef1bd34ed05ea874bf4921eb5a313"},
+    {file = "libcst-1.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:061d6855ef30efe38b8a292b7e5d57c8e820e71fc9ec9846678b60a934b53bbb"},
+    {file = "libcst-1.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb0abf627ee14903d05d0ad9b2c6865f1b21eb4081e2c7bea1033f85db2b8bae"},
+    {file = "libcst-1.4.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d024f44059a853b4b852cfc04fec33e346659d851371e46fc8e7c19de24d3da9"},
+    {file = "libcst-1.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:3c6a8faab9da48c5b371557d0999b4ca51f4f2cbd37ee8c2c4df0ac01c781465"},
+    {file = "libcst-1.4.0.tar.gz", hash = "sha256:449e0b16604f054fa7f27c3ffe86ea7ef6c409836fe68fe4e752a1894175db00"},
+]
+
+[package.dependencies]
+pyyaml = ">=5.2"
+
+[package.extras]
+dev = ["Sphinx (>=5.1.1)", "black (==23.12.1)", "build (>=0.10.0)", "coverage (>=4.5.4)", "fixit (==2.1.0)", "flake8 (==7.0.0)", "hypothesis (>=4.36.0)", "hypothesmith (>=0.0.4)", "jinja2 (==3.1.4)", "jupyter (>=1.0.0)", "maturin (>=0.8.3,<1.6)", "nbsphinx (>=0.4.2)", "prompt-toolkit (>=2.0.9)", "pyre-check (==0.9.18)", "setuptools-rust (>=1.5.2)", "setuptools-scm (>=6.0.1)", "slotscheck (>=0.7.1)", "sphinx-rtd-theme (>=0.4.3)", "ufmt (==2.6.0)", "usort (==1.0.8.post1)"]
+
 [[package]]
 name = "markdown-it-py"
 version = "3.0.0"
@@ -682,6 +722,24 @@ files = [
 dev = ["pre-commit", "tox"]
 testing = ["pytest", "pytest-benchmark"]
 
+[[package]]
+name = "pycln"
+version = "2.4.0"
+description = "A formatter for finding and removing unused import statements."
+optional = false
+python-versions = ">=3.7.0,<4"
+files = [
+    {file = "pycln-2.4.0-py3-none-any.whl", hash = "sha256:d1bf648df17077306100815d255d45430035b36f66bac635df04a323c61ba126"},
+    {file = "pycln-2.4.0.tar.gz", hash = "sha256:1f3eefb7be18a9ee06c3bdd0ba2e91218cd39317e20130325f107e96eb84b9f6"},
+]
+
+[package.dependencies]
+libcst = ">=0.3.10"
+pathspec = ">=0.9.0"
+pyyaml = ">=5.3.1"
+tomlkit = ">=0.11.1"
+typer = ">=0.4.1"
+
 [[package]]
 name = "pygments"
 version = "2.18.0"
@@ -891,6 +949,17 @@ files = [
     {file = "ruff-0.5.5.tar.gz", hash = "sha256:cc5516bdb4858d972fbc31d246bdb390eab8df1a26e2353be2dbc0c2d7f5421a"},
 ]
 
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+description = "Tool to Detect Surrounding Shell"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"},
+    {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"},
+]
+
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -1079,6 +1148,45 @@ files = [
     {file = "tomlkit-0.13.0.tar.gz", hash = "sha256:08ad192699734149f5b97b45f1f18dad7eb1b6d16bc72ad0c2335772650d7b72"},
 ]
 
+[[package]]
+name = "typer"
+version = "0.12.3"
+description = "Typer, build great CLIs. Easy to code. Based on Python type hints."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "typer-0.12.3-py3-none-any.whl", hash = "sha256:070d7ca53f785acbccba8e7d28b08dcd88f79f1fbda035ade0aecec71ca5c914"},
+    {file = "typer-0.12.3.tar.gz", hash = "sha256:49e73131481d804288ef62598d97a1ceef3058905aa536a1134f90891ba35482"},
+]
+
+[package.dependencies]
+click = ">=8.0.0"
+rich = ">=10.11.0"
+shellingham = ">=1.3.0"
+typing-extensions = ">=3.7.4.3"
+
+[[package]]
+name = "types-docutils"
+version = "0.21.0.20240724"
+description = "Typing stubs for docutils"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "types-docutils-0.21.0.20240724.tar.gz", hash = "sha256:29ff7e27660f4fe76ea61d7e54d05ca3ce3b733ca9e8e8721e0fa587dbc10489"},
+    {file = "types_docutils-0.21.0.20240724-py3-none-any.whl", hash = "sha256:bf51c6c488d23c0412f9b3ba10686fb1a6cb0b957ef04b45128d8a55c79ebb00"},
+]
+
+[[package]]
+name = "types-setuptools"
+version = "71.1.0.20240726"
+description = "Typing stubs for setuptools"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "types-setuptools-71.1.0.20240726.tar.gz", hash = "sha256:85ba28e9461bb1be86ebba4db0f1c2408f2b11115b1966334ea9dc464e29303e"},
+    {file = "types_setuptools-71.1.0.20240726-py3-none-any.whl", hash = "sha256:a7775376f36e0ff09bcad236bf265777590a66b11623e48c20bfc30f1444ea36"},
+]
+
 [[package]]
 name = "typing-extensions"
 version = "4.12.2"
@@ -1124,5 +1232,5 @@ test = ["big-O", "importlib-resources", "jaraco.functools", "jaraco.itertools",
 
 [metadata]
 lock-version = "2.0"
-python-versions = ">=3.9"
-content-hash = "6ea4c2425b97c5bf3af44fb604475d87dcd7b12861e2fc5b84acaf7539c3e368"
+python-versions = ">=3.9,<4"
+content-hash = "885494c777ba8a693e7cced802fbb38ee546d9f34fc266aa2d3ac269a07dea4e"
diff --git a/pyproject.toml b/pyproject.toml
index a60f604..26ae080 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -10,11 +10,10 @@ readme = "README.md"
 m2r2 = "m2r2:main"
 
 [tool.poetry.dependencies]
-python = ">=3.9"
+python = ">=3.9,<4"
 mistune = ">=2.0,<3.0"
 docutils = ">=0.16,<0.22"
 
-
 [tool.poetry.group.dev.dependencies]
 pygments = "^2.18.0"
 black = "^24.4.2"
@@ -23,6 +22,9 @@ pylint = "^3.2.6"
 mypy = "^1.11.0"
 ruff = "^0.5.5"
 bandit = "^1.7.9"
+pycln = "^2.4.0"
+types-docutils = "^0.21.0.20240724"
+types-setuptools = "^71.1.0.20240726"
 
 [tool.poetry.group.testing.dependencies]
 pytest = "^8.3.2"
@@ -37,6 +39,29 @@ exclude_dirs = ["tests"]
 ignore_missing_imports = true
 follow_imports = "skip"
 
+[tool.pylint.main]
+jobs = 0
+
+[tool.pylint.basic]
+good-names = ["e"]
+class-const-rgx = "(?:(?P<snake>[a-z_]+)|(?P<upper>[A-Z]+))$"
+
+[tool.pylint.design]
+max-locals = 16
+
+[tool.pylint."messages control"]
+disable = [
+  "fixme",
+  "unspecified-encoding",
+  "missing-class-docstring",
+  "missing-function-docstring",
+  "missing-module-docstring",
+  "unused-argument",
+]
+
+[tool.pylint.format]
+max-line-length = 88
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"

From 21956250ebf6907b971a4f243dee2067ee0f00ec Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Sun, 28 Jul 2024 22:52:07 -0300
Subject: [PATCH 14/22] linter

---
 m2r2/__init__.py       |  4 ++--
 m2r2/m2r2.py           | 16 +++++++++-------
 m2r2/parser.py         |  9 ++++-----
 m2r2/rst/directives.py | 17 ++++++++---------
 m2r2/rst/parser.py     |  2 +-
 m2r2/rst/renderer.py   | 33 +++++++++++++++++----------------
 m2r2/sphinx/m2r2.py    | 16 ++++++++--------
 7 files changed, 49 insertions(+), 48 deletions(-)

diff --git a/m2r2/__init__.py b/m2r2/__init__.py
index 96b2868..bb0d394 100644
--- a/m2r2/__init__.py
+++ b/m2r2/__init__.py
@@ -1,3 +1,3 @@
-from .m2r2 import M2R, convert
+from .m2r2 import M2R2, convert
 
-__all__ = ("M2R", "convert")
+__all__ = ("M2R2", "convert")
diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 532db1d..b463af0 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -14,7 +14,7 @@
 
 
 # TODO: check this
-class M2R(mistune.Markdown):
+class M2R2(mistune.Markdown):
     def __init__(
         self,
         renderer=None,
@@ -25,6 +25,7 @@ def __init__(
         parse_relative_links: bool = False,
         anonymous_references: bool = False,
         disable_inline_math: bool = True,
+        no_underscore_emphasis: bool = True,
     ):
         renderer = renderer or RestRenderer(
             use_mermaid=use_mermaid,
@@ -33,12 +34,14 @@ def __init__(
         )
         block = block or RestBlockParser()
         inline = inline or RestInlineParser(
-            renderer, disable_inline_math=disable_inline_math
+            renderer,
+            disable_inline_math=disable_inline_math,
+            no_underscore_emphasis=no_underscore_emphasis,
         )
         super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
 
-    def parse(self, text):
-        output = super().parse(text)
+    def parse(self, s, state=None):
+        output = super().parse(s, state)
         return self.post_process(output)
 
     def post_process(self, text):
@@ -51,9 +54,8 @@ def post_process(self, text):
         )
         if self.renderer._include_raw_html:
             return PROLOG + output
-        else:
-            return output
+        return output
 
 
 def convert(text, **kwargs):
-    return M2R(**kwargs)(text)
+    return M2R2(**kwargs)(text)
diff --git a/m2r2/parser.py b/m2r2/parser.py
index c3d27fb..271e141 100644
--- a/m2r2/parser.py
+++ b/m2r2/parser.py
@@ -1,21 +1,20 @@
-from docutils import statemachine
 from docutils.parsers import rst
 
-from m2r2 import M2R
+from m2r2 import M2R2
 
 
-class M2RParser(rst.Parser):
+class M2R2Parser(rst.Parser):
     # Explicitly tell supported formats to sphinx
     supported = ("markdown", "md", "mkd")
 
     def parse(self, inputstring, document):
         """Parse `inputstring` and populate `document`, a document tree."""
         config = document.settings.env.config
-        converter = M2R(
+        converter = M2R2(
             no_underscore_emphasis=config.no_underscore_emphasis,
             parse_relative_links=config.m2r_parse_relative_links,
             anonymous_references=config.m2r_anonymous_references,
             disable_inline_math=config.m2r_disable_inline_math,
             use_mermaid=config.m2r_use_mermaid,
         )
-        super(M2RParser, self).parse(converter(inputstring), document)
+        super().parse(converter(inputstring), document)
diff --git a/m2r2/rst/directives.py b/m2r2/rst/directives.py
index 58b1da7..cfd2ef9 100644
--- a/m2r2/rst/directives.py
+++ b/m2r2/rst/directives.py
@@ -3,7 +3,7 @@
 from docutils import io, nodes, statemachine, utils
 from docutils.parsers import rst
 
-from m2r2 import M2R
+from m2r2 import M2R2
 
 
 class MdInclude(rst.Directive):
@@ -26,7 +26,7 @@ def run(self):
         docutils version: 0.12
         """
         if not self.state.document.settings.file_insertion_enabled:
-            raise self.warning('"%s" directive disabled.' % self.name)
+            raise self.warning(f'"{self.name}" directive disabled.')
         source = self.state_machine.input_lines.source(
             self.lineno - self.state_machine.input_offset - 1
         )
@@ -53,14 +53,13 @@ def run(self):
             )
         except UnicodeEncodeError:
             raise self.severe(
-                'Problems with "%s" directive path:\n'
-                'Cannot encode input file path "%s" '
-                "(wrong locale?)." % (self.name, str(path))
+                f'Problems with "{self.name}" directive path:\n'
+                f'Cannot encode input file path "{path}" '
+                "(wrong locale?)."
             )
         except IOError as error:
             raise self.severe(
-                'Problems with "%s" directive path:\n%s.'
-                % (self.name, io.error_string(error))
+                f'Problems with "{self.name}" directive path:\n{io.error_string(error)}.'
             )
 
         # read from the file
@@ -74,11 +73,11 @@ def run(self):
                 rawtext = include_file.read()
         except UnicodeError as error:
             raise self.severe(
-                'Problem with "%s" directive:\n%s' % (self.name, io.error_string(error))
+                f'Problem with "{self.name}" directive:\n{io.error_string(error)}'
             )
 
         config = self.state.document.settings.env.config
-        converter = M2R(
+        converter = M2R2(
             no_underscore_emphasis=config.no_underscore_emphasis,
             parse_relative_links=config.m2r_parse_relative_links,
             anonymous_references=config.m2r_anonymous_references,
diff --git a/m2r2/rst/parser.py b/m2r2/rst/parser.py
index c2983d5..9802124 100644
--- a/m2r2/rst/parser.py
+++ b/m2r2/rst/parser.py
@@ -109,7 +109,7 @@ def no_underscore_emphasis(self):
         self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
 
     def __init__(self, renderer, *args, **kwargs):
-        # no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
+        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
         disable_inline_math = kwargs.pop("disable_inline_math", False)
         super().__init__(renderer, *args, **kwargs)
         # if not _is_sphinx:
diff --git a/m2r2/rst/renderer.py b/m2r2/rst/renderer.py
index 1efa975..d6454fc 100644
--- a/m2r2/rst/renderer.py
+++ b/m2r2/rst/renderer.py
@@ -25,7 +25,7 @@ def __init__(self, *args, **kwargs):
         self.parse_relative_links = kwargs.pop("parse_relative_links", False)
         self.anonymous_references = kwargs.pop("anonymous_references", False)
         self.use_mermaid = kwargs.pop("use_mermaid", False)
-        super(RestRenderer, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         # if not _is_sphinx:
         #    parse_options()
         #    if getattr(options, "parse_relative_links", False):
@@ -88,7 +88,7 @@ def heading(self, text, level, raw=None):
         :param level: a number for the header level, for example: 1.
         :param raw: raw text content of the header.
         """
-        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * column_width(text))
+        return f"\n{text}\n{self.hmarks[level] * column_width(text)}\n"
 
     def thematic_break(self):
         """Rendering method for ``<hr>`` tag."""
@@ -105,7 +105,9 @@ def list(self, body, ordered, level, start):
         for i, line in enumerate(lines):
             if line and not line.startswith(self.list_marker):
                 lines[i] = " " * len(mark) + line
-        return "\n{}\n".format("\n".join(lines)).replace(self.list_marker, mark)
+
+        list_lines = "\n".join(lines)
+        return f"\n{list_lines}\n".replace(self.list_marker, mark)
 
     def list_item(self, text, level):
         """Rendering list item snippet. Like ``<li>``."""
@@ -163,17 +165,17 @@ def double_emphasis(self, text):
 
         :param text: text content for emphasis.
         """
-        return r"\ **{}**\ ".format(text)
+        return rf"\ **{text}**\ "
 
     def emphasis(self, text):
         """Rendering *emphasis* text.
 
         :param text: text content for emphasis.
         """
-        return r"\ *{}*\ ".format(text)
+        return rf"\ *{text}*\ "
 
     def strong(self, text):
-        return r"**{}**".format(text)
+        return rf"**{text}**"
 
     def codespan(self, text):
         """Rendering inline `code` text.
@@ -181,14 +183,13 @@ def codespan(self, text):
         :param text: text content for inline code.
         """
         if "``" not in text:
-            return r"\ ``{}``\ ".format(text)
-        else:
-            # actually, docutils split spaces in literal
-            return self._raw_html(
-                '<code class="docutils literal">'
-                '<span class="pre">{}</span>'
-                "</code>".format(text.replace("`", "&#96;"))
-            )
+            return rf"\ ``{text}``\ "
+        # actually, docutils split spaces in literal
+        return self._raw_html(
+            '<code class="docutils literal">'
+            f'<span class="pre">{text.replace("`", "&#96;")}</span>'
+            "</code>"
+        )
 
     def linebreak(self):
         """Rendering line break like ``<br>``."""
@@ -201,7 +202,7 @@ def strikethrough(self, text):
 
         :param text: text content for strikethrough.
         """
-        return self._raw_html("<del>{}</del>".format(text))
+        return self._raw_html(f"<del>{text}</del>")
 
     def text(self, text):
         """Rendering unformatted text.
@@ -269,7 +270,7 @@ def image(self, src, title, text):
                 "",
                 f".. image:: {src}",
                 f"   :target: {src}",
-                f"   :alt: {tex}",
+                f"   :alt: {text}",
                 "",
             ]
         )
diff --git a/m2r2/sphinx/m2r2.py b/m2r2/sphinx/m2r2.py
index 51e59c0..c21d441 100644
--- a/m2r2/sphinx/m2r2.py
+++ b/m2r2/sphinx/m2r2.py
@@ -1,5 +1,5 @@
 from m2r2.m2r2 import __version__
-from m2r2.parser import M2RParser
+from m2r2.parser import M2R2Parser
 from m2r2.rst.directives import MdInclude
 
 _is_sphinx = False
@@ -17,14 +17,14 @@ def setup(app):
         "m2r_use_mermaid", "sphinxcontrib.mermaid" in app.config.extensions, "env"
     )
     try:
-        app.add_source_parser(".md", M2RParser)  # for older sphinx versions
+        app.add_source_parser(".md", M2R2Parser)  # for older sphinx versions
     except (TypeError, AttributeError):
         app.add_source_suffix(".md", "markdown")
-        app.add_source_parser(M2RParser)
+        app.add_source_parser(M2R2Parser)
     app.add_directive("mdinclude", MdInclude)
-    metadata = dict(
-        version=__version__,
-        parallel_read_safe=True,
-        parallel_write_safe=True,
-    )
+    metadata = {
+        "version": __version__,
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
     return metadata

From bd57e6e1cc7f6cccfb0c8de3de3766a8cd83b988 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 29 Jul 2024 00:42:54 -0300
Subject: [PATCH 15/22] all over again

---
 m2r2/m2r2.py | 364 ++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 330 insertions(+), 34 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index b463af0..9df7e74 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -3,45 +3,232 @@
 
 from __future__ import print_function, unicode_literals
 
+import os
+import re
+from urllib.parse import urlparse
+
 import mistune
+from docutils import io, nodes, statemachine, utils
+from docutils.parsers import rst
+from docutils.utils import column_width
+from mistune.renderers import BaseRenderer
 from pkg_resources import get_distribution
 
-from m2r2.constants import PROLOG
-from m2r2.rst.parser import RestBlockParser, RestInlineParser
-from m2r2.rst.renderer import RestRenderer
-
 __version__ = get_distribution("m2r2").version
 
+PROLOG = """\
+.. role:: raw-html-m2r(raw)
+   :format: html
+
+"""
+
+
+class RestRenderer(BaseRenderer):
+    _include_raw_html = False
+    list_indent_re = re.compile(r"^(\s*(#\.|\*)\s)")
+    indent = " " * 3
+    list_marker = "{#__rest_list_mark__#}"
+    hmarks = {
+        1: "=",
+        2: "-",
+        3: "^",
+        4: "~",
+        5: '"',
+        6: "#",
+    }
+
+    def __init__(self, **kwargs):
+        self.parse_relative_links = kwargs.pop("parse_relative_links", False)
+        self.anonymous_references = kwargs.pop("anonymous_references", False)
+        self.use_mermaid = kwargs.pop("use_mermaid", False)
+        super().__init__(**kwargs)
+
+    def finalize(self, data):
+        return "".join(filter(lambda x: x is not None, data))
+
+    def _indent_block(self, block):
+        return "\n".join(
+            self.indent + line if line else "" for line in block.splitlines()
+        )
+
+    def _raw_html(self, html):
+        self._include_raw_html = True
+        return r"\ :raw-html-m2r:`{}`\ ".format(html)
+
+    def block_text(self, text) -> str:
+        print(f"block_text={text}")
+        return f"{text}\n"
+
+    def newline(self):
+        return ""
+
+    def block_code(self, children, info=None):
+        print(f"block_code={children=}, {info=}")
+        lang = info.strip() if info else None
+        if lang == "math":
+            first_line = "\n.. math::\n\n"
+        elif lang == "mermaid" and self.use_mermaid:
+            first_line = "\n.. mermaid::\n\n"
+        elif lang:
+            first_line = "\n.. code-block:: {}\n\n".format(lang)
+        else:
+            first_line = "\n.. code-block::\n\n"
+        return first_line + self._indent_block(children) + "\n"
+
+    def block_quote(self, text):
+        return "\n..\n\n{}\n\n".format(self._indent_block(text.strip("\n")))
+
+    def block_html(self, html):
+        return "\n\n.. raw:: html\n\n" + self._indent_block(html) + "\n\n"
+
+    def heading(self, text, level):
+        return "\n{0}\n{1}\n".format(text, self.hmarks[level] * len(text))
+
+    def thematic_break(self):
+        return "\n----\n"
+
+    def list(self, text, ordered, level, start=None):
+        mark = "#. " if ordered else "* "
+        lines = text.splitlines()
+        for i, line in enumerate(lines):
+            if line and not line.startswith(self.list_marker):
+                lines[i] = " " * len(mark) + line
+        return "\n{}\n".format("\n".join(lines)).replace(self.list_marker, mark)
+
+    def list_item(self, text, level):
+        return "\n" + self.list_marker + text
+
+    def paragraph(self, text):
+        print(f"paragraph={text}")
+        if text[-2:] == "::":
+            text = text[:-1]
+        return f"\n{text}\n"
+
+    def table(self, text):
+        table = "\n.. list-table::\n"
+        rows = text.split("\n")
+        if rows and not rows[0].isspace():
+            table = (
+                table
+                + self.indent
+                + ":header-rows: 1\n\n"
+                + self._indent_block(rows[0])
+                + "\n"
+            )
+            rows = rows[1:]
+        else:
+            table = table + "\n"
+        table = table + self._indent_block("\n".join(rows)) + "\n\n"
+        return table
+
+    def table_row(self, text):
+        contents = text.splitlines()
+        if not contents:
+            return ""
+        clist = ["* " + contents[0]]
+        if len(contents) > 1:
+            for c in contents[1:]:
+                clist.append("  " + c)
+        return "\n".join(clist) + "\n"
+
+    def table_cell(self, text, align=None, is_head=False):
+        return "- " + text + "\n"
+
+    def strong(self, text):
+        return r"\ **{}**\ ".format(text)
+
+    def emphasis(self, text):
+        return r"\ *{}*\ ".format(text)
+
+    def codespan(self, text):
+        if "``" not in text:
+            return r"\ ``{}``\ ".format(text)
+        else:
+            # actually, docutils split spaces in literal
+            return self._raw_html(
+                '<code class="docutils literal">'
+                '<span class="pre">{}</span>'
+                "</code>".format(text.replace("`", "&#96;"))
+            )
+
+    def linebreak(self):
+        return self._raw_html("<br>") + "\n"
+
+    def strikethrough(self, text):
+        return self._raw_html("<del>{}</del>".format(text))
+
+    def text(self, text):
+        return text
+
+    def link(self, link, children=None, title=None):
+        if self.anonymous_references:
+            underscore = "__"
+        else:
+            underscore = "_"
+        if title:
+            return self._raw_html(
+                '<a href="{link}" title="{title}">{text}</a>'.format(
+                    link=link, title=title, text=children or link
+                )
+            )
+        if not self.parse_relative_links:
+            return r"\ `{text} <{target}>`{underscore}\ ".format(
+                target=link, text=children or link, underscore=underscore
+            )
+        else:
+            url_info = urlparse(link)
+            if url_info.scheme:
+                return r"\ `{text} <{target}>`{underscore}\ ".format(
+                    target=link, text=children or link, underscore=underscore
+                )
+            else:
+                link_type = "doc"
+                anchor = url_info.fragment
+                if url_info.fragment:
+                    if url_info.path:
+                        anchor = ""
+                    else:
+                        link_type = "ref"
+                doc_link = "{doc_name}{anchor}".format(
+                    doc_name=os.path.splitext(url_info.path)[0],
+                    anchor=anchor,
+                )
+                return r"\ :{link_type}:`{text} <{doc_link}>`\ ".format(
+                    link_type=link_type, doc_link=doc_link, text=children or link
+                )
+
+    def image(self, src, alt="", title=None):
+        return "\n".join(
+            [
+                "",
+                ".. image:: {}".format(src),
+                "   :target: {}".format(src),
+                "   :alt: {}".format(alt),
+                "",
+            ]
+        )
+
+    def inline_html(self, html):
+        return self._raw_html(html)
+
+    def footnote_ref(self, key, index):
+        return r"\ [#fn-{}]_\ ".format(key)
+
+    def footnote_item(self, key, text):
+        return ".. [#fn-{0}] {1}\n".format(key, text.strip())
+
+    def footnotes(self, text):
+        return "\n\n" + text if text else ""
+
 
-# TODO: check this
 class M2R2(mistune.Markdown):
-    def __init__(
-        self,
-        renderer=None,
-        block=None,
-        inline=None,
-        plugins=None,
-        use_mermaid: bool = False,
-        parse_relative_links: bool = False,
-        anonymous_references: bool = False,
-        disable_inline_math: bool = True,
-        no_underscore_emphasis: bool = True,
-    ):
-        renderer = renderer or RestRenderer(
-            use_mermaid=use_mermaid,
-            parse_relative_links=parse_relative_links,
-            anonymous_references=anonymous_references,
-        )
-        block = block or RestBlockParser()
-        inline = inline or RestInlineParser(
-            renderer,
-            disable_inline_math=disable_inline_math,
-            no_underscore_emphasis=no_underscore_emphasis,
-        )
-        super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
-
-    def parse(self, s, state=None):
-        output = super().parse(s, state)
+    def __init__(self, **kwargs):
+        renderer = RestRenderer(**kwargs)
+        plugins = []
+        super().__init__(renderer=renderer, plugins=plugins)
+
+    def parse(self, text):
+        output = super().parse(text)
         return self.post_process(output)
 
     def post_process(self, text):
@@ -53,8 +240,117 @@ def post_process(self, text):
             .replace("\\ .", ".")
         )
         if self.renderer._include_raw_html:
-            return PROLOG + output
-        return output
+            return (
+                PROLOG + output
+            )  # You might need to define 'prolog' if it's used in your original code
+        else:
+            return output
+
+
+class M2R2Parser(rst.Parser, object):
+    # Explicitly tell supported formats to sphinx
+    supported = ("markdown", "md", "mkd")
+
+    def parse(self, inputstrings, document):
+        if isinstance(inputstrings, statemachine.StringList):
+            inputstring = "\n".join(inputstrings)
+        else:
+            inputstring = inputstrings
+        config = document.settings.env.config
+        converter = M2R2(
+            no_underscore_emphasis=config.no_underscore_emphasis,
+            parse_relative_links=config.m2r_parse_relative_links,
+            anonymous_references=config.m2r_anonymous_references,
+            disable_inline_math=config.m2r_disable_inline_math,
+            use_mermaid=config.m2r_use_mermaid,
+        )
+        super(M2R2Parser, self).parse(converter(inputstring), document)
+
+
+class MdInclude(rst.Directive):
+    """Directive class to include markdown in sphinx.
+
+    Load a file and convert it to rst and insert as a node. Currently
+    directive-specific options are not implemented.
+    """
+
+    required_arguments = 1
+    optional_arguments = 0
+    option_spec = {
+        "start-line": int,
+        "end-line": int,
+    }
+
+    def run(self):
+        """Most of this method is from ``docutils.parser.rst.Directive``.
+
+        docutils version: 0.12
+        """
+        if not self.state.document.settings.file_insertion_enabled:
+            raise self.warning('"%s" directive disabled.' % self.name)
+        source = self.state_machine.input_lines.source(
+            self.lineno - self.state_machine.input_offset - 1
+        )
+        source_dir = os.path.dirname(os.path.abspath(source))
+        path = rst.directives.path(self.arguments[0])
+        path = os.path.normpath(os.path.join(source_dir, path))
+        path = utils.relative_path(None, path)
+        path = nodes.reprunicode(path)
+
+        # get options (currently not use directive-specific options)
+        encoding = self.options.get(
+            "encoding", self.state.document.settings.input_encoding
+        )
+        e_handler = self.state.document.settings.input_encoding_error_handler
+        tab_width = self.options.get(
+            "tab-width", self.state.document.settings.tab_width
+        )
+
+        # open the including file
+        try:
+            self.state.document.settings.record_dependencies.add(path)
+            include_file = io.FileInput(
+                source_path=path, encoding=encoding, error_handler=e_handler
+            )
+        except UnicodeEncodeError:
+            raise self.severe(
+                'Problems with "%s" directive path:\n'
+                'Cannot encode input file path "%s" '
+                "(wrong locale?)." % (self.name, str(path))
+            )
+        except IOError as error:
+            raise self.severe(
+                'Problems with "%s" directive path:\n%s.'
+                % (self.name, io.error_string(error))
+            )
+
+        # read from the file
+        startline = self.options.get("start-line", None)
+        endline = self.options.get("end-line", None)
+        try:
+            if startline or (endline is not None):
+                lines = include_file.readlines()
+                rawtext = "".join(lines[startline:endline])
+            else:
+                rawtext = include_file.read()
+        except UnicodeError as error:
+            raise self.severe(
+                'Problem with "%s" directive:\n%s' % (self.name, io.error_string(error))
+            )
+
+        config = self.state.document.settings.env.config
+        converter = M2R2(
+            no_underscore_emphasis=config.no_underscore_emphasis,
+            parse_relative_links=config.m2r_parse_relative_links,
+            anonymous_references=config.m2r_anonymous_references,
+            disable_inline_math=config.m2r_disable_inline_math,
+            use_mermaid=config.m2r_use_mermaid,
+        )
+        include_lines = statemachine.string2lines(
+            converter(rawtext), tab_width, convert_whitespace=True
+        )
+        self.state_machine.insert_input(include_lines, path)
+        return []
 
 
 def convert(text, **kwargs):

From 7eb852b2425ee092c98fcfbdc46c850f4b8f2920 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 29 Jul 2024 02:27:16 -0300
Subject: [PATCH 16/22] 31/44

---
 m2r2/m2r2.py | 161 +++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 157 insertions(+), 4 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 9df7e74..2080bc5 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -220,12 +220,165 @@ def footnote_item(self, key, text):
     def footnotes(self, text):
         return "\n\n" + text if text else ""
 
+    """Below outputs are for rst."""
+
+    def image_link(self, url, target, alt):
+        return "\n".join(
+            [
+                "",
+                ".. image:: {}".format(url),
+                "   :target: {}".format(target),
+                "   :alt: {}".format(alt),
+                "",
+            ]
+        )
+
+    def rest_role(self, text):
+        return text
+
+    def rest_link(self, text):
+        return text
+
+    def inline_math(self, math):
+        """Extension of recommonmark."""
+        return r":math:`{}`".format(math)
+
+    def eol_literal_marker(self, marker):
+        """Extension of recommonmark."""
+        return marker
+
+    def directive(self, text):
+        return "\n" + text
+
+    def rest_code_block(self, text):
+        return "\n\n"
+
+
+from typing import Any, Dict, Match, Tuple
+
+import mistune
+
+from m2r2.typing import Element, State, Token
+
+
+class RestBlockParser(mistune.BlockParser):
+    DIRECTIVE = re.compile(
+        r"^( *\.\..*?)\n(?=\S)",
+        re.DOTALL | re.MULTILINE,
+    )
+    ONELINE_DIRECTIVE = re.compile(
+        r"^( *\.\..*?)$",
+        re.DOTALL | re.MULTILINE,
+    )
+    REST_CODE_BLOCK = re.compile(
+        r"^::\s*$",
+        re.DOTALL | re.MULTILINE,
+    )
+    RULE_NAMES = mistune.BlockParser.RULE_NAMES + (
+        "directive",
+        "oneline_directive",
+        "rest_code_block",
+    )
+
+    def parse_directive(self, match: Match, state: State) -> Token:
+        return {"type": "directive", "text": match.group(1)}
+
+    def parse_oneline_directive(self, match: Match, state: State) -> Token:
+        # reuse directive output
+        return {"type": "directive", "text": match.group(1)}
+
+    def parse_rest_code_block(self, match: Match, state: State) -> Token:
+        return {"type": "rest_code_block", "text": ""}
+
+
+class RestInlineParser(mistune.InlineParser):
+    IMAGE_LINK = re.compile(
+        r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
+    )
+    REST_ROLE = re.compile(r":.*?:`.*?`|`[^`]+`:.*?:")
+    REST_LINK = re.compile(r"`[^`]*?`_")
+    INLINE_MATH = re.compile(r"`\$(.*?)\$`")
+    EOL_LITERAL_MARKER = re.compile(r"(\s+)?::\s*$")
+    # add colon and space as special text
+    TEXT = re.compile(r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)")
+    # __word__ or **word**
+    DOUBLE_EMPHASIS = re.compile(r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)")
+    # _word_ or *word*
+    EMPHASIS = re.compile(
+        r"^\b_((?:__|[^_])+?)_\b"  # _word_
+        r"|"
+        r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
+    )
+
+    RUlE_NAMES = (
+        "inline_math",
+        "image_link",
+        "rest_role",
+        "rest_link",
+        "eol_literal_marker",
+    ) + mistune.InlineParser.RULE_NAMES
+
+    def parse_double_emphasis(self, match: Match, state: State) -> Element:
+        # may include code span
+        return "double_emphasis", match.group("text")
+
+    def parse_emphasis(self, match: Match, state: State) -> Element:
+        # may include code span
+        return "emphasis", match.group("text") or match.group(1)
+
+    def parse_image_link(self, match: Match, state: State) -> Element:
+        """Pass through rest role."""
+        alt, src, target = match.groups()
+        return "image_link", src, target, alt
+
+    def parse_rest_role(self, match: Match, state: State) -> Element:
+        """Pass through rest role."""
+        return "rest_role", match.group(0)
+
+    def parse_rest_link(self, match: Match, state: State) -> Element:
+        """Pass through rest link."""
+        return "rest_link", match.group(0)
+
+    def parse_inline_math(self, match: Match, state: State) -> Element:
+        """Pass through rest link."""
+        return "inline_math", match.group(2)
+
+    def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
+        """Pass through rest link."""
+        marker = ":" if match.group(1) is None else ""
+        return "eol_literal_marker", marker
+
+    def no_underscore_emphasis(self):
+        self.DOUBLE_EMPHASIS = re.compile(
+            r"^\*{2}(?P<text>[\s\S]+?)\*{2}(?!\*)"  # **word**
+        )
+        self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
+
+    def __init__(self, renderer, *args, **kwargs):
+        # no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
+        disable_inline_math = kwargs.pop("disable_inline_math", False)
+        super().__init__(renderer, *args, **kwargs)
+        # if not _is_sphinx:
+        #    parse_options()
+        # if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
+        #    self.rules.no_underscore_emphasis()
+        inline_maths = "inline_math" in self.RULE_NAMES
+        if disable_inline_math:  # or getattr(options, "disable_inline_math", False):
+            if inline_maths:
+                self.RULE_NAMES = tuple(
+                    x for x in self.RUlE_NAMES if x != "inline_math"
+                )
+        elif not inline_maths:
+            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
+
 
 class M2R2(mistune.Markdown):
-    def __init__(self, **kwargs):
-        renderer = RestRenderer(**kwargs)
-        plugins = []
-        super().__init__(renderer=renderer, plugins=plugins)
+    def __init__(self, renderer=None, block=None, inline=None, plugins=None, **kwargs):
+        disable_inline_math = kwargs.pop("disable_inline_math", False)
+        renderer = renderer or RestRenderer(**kwargs)
+        block = block or RestBlockParser()
+        inline = inline or RestInlineParser(renderer, disable_inline_math)
+        super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
 
     def parse(self, text):
         output = super().parse(text)

From 064498de7571720301559204575cb83ad4e5cc07 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 29 Jul 2024 02:31:52 -0300
Subject: [PATCH 17/22] 19/56

---
 m2r2/m2r2.py | 24 +++++++++++-------------
 1 file changed, 11 insertions(+), 13 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 2080bc5..4024695 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -292,25 +292,23 @@ def parse_rest_code_block(self, match: Match, state: State) -> Token:
 
 
 class RestInlineParser(mistune.InlineParser):
-    IMAGE_LINK = re.compile(
-        r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
-    )
-    REST_ROLE = re.compile(r":.*?:`.*?`|`[^`]+`:.*?:")
-    REST_LINK = re.compile(r"`[^`]*?`_")
-    INLINE_MATH = re.compile(r"`\$(.*?)\$`")
-    EOL_LITERAL_MARKER = re.compile(r"(\s+)?::\s*$")
+    IMAGE_LINK = r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
+    REST_ROLE = r":.*?:`.*?`|`[^`]+`:.*?:"
+    REST_LINK = r"`[^`]*?`_"
+    INLINE_MATH = r"`\$(.*?)\$`"
+    EOL_LITERAL_MARKER = r"(\s+)?::\s*$"
     # add colon and space as special text
-    TEXT = re.compile(r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)")
+    TEXT = r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)"
     # __word__ or **word**
-    DOUBLE_EMPHASIS = re.compile(r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)")
+    DOUBLE_EMPHASIS = r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)"
     # _word_ or *word*
-    EMPHASIS = re.compile(
+    EMPHASIS = (
         r"^\b_((?:__|[^_])+?)_\b"  # _word_
         r"|"
         r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
     )
 
-    RUlE_NAMES = (
+    RULE_NAMES = (
         "inline_math",
         "image_link",
         "rest_role",
@@ -366,10 +364,10 @@ def __init__(self, renderer, *args, **kwargs):
         if disable_inline_math:  # or getattr(options, "disable_inline_math", False):
             if inline_maths:
                 self.RULE_NAMES = tuple(
-                    x for x in self.RUlE_NAMES if x != "inline_math"
+                    x for x in self.RULE_NAMES if x != "inline_math"
                 )
         elif not inline_maths:
-            self.RUlE_NAMES = ("inline_math", *self.RUlE_NAMES)
+            self.RULE_NAMES = ("inline_math", *self.RULE_NAMES)
 
 
 class M2R2(mistune.Markdown):

From da9d18f6a38c1c475bc5eb635397d24108b1a835 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 29 Jul 2024 16:00:07 -0300
Subject: [PATCH 18/22] 17/58

---
 m2r2/m2r2.py | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 4024695..101e031 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -138,6 +138,7 @@ def strong(self, text):
         return r"\ **{}**\ ".format(text)
 
     def emphasis(self, text):
+        print(f"emphasis {text=}")
         return r"\ *{}*\ ".format(text)
 
     def codespan(self, text):
@@ -346,18 +347,24 @@ def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
         marker = ":" if match.group(1) is None else ""
         return "eol_literal_marker", marker
 
-    def no_underscore_emphasis(self):
-        self.DOUBLE_EMPHASIS = re.compile(
-            r"^\*{2}(?P<text>[\s\S]+?)\*{2}(?!\*)"  # **word**
-        )
-        self.EMPHASIS = re.compile(r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)")  # *word*
+    def disable_underscore_emphasis(self):
+        print("Running no_underscore_emphasis")
+        self.deregister_rule("underscore_emphasis")
+
+    def deregister_rule(self, rule):
+        self.rules.remove(rule)
 
     def __init__(self, renderer, *args, **kwargs):
         # no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
         disable_inline_math = kwargs.pop("disable_inline_math", False)
+        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
         super().__init__(renderer, *args, **kwargs)
         # if not _is_sphinx:
         #    parse_options()
+
+        if no_underscore_emphasis:
+            self.disable_underscore_emphasis()
+
         # if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
         #    self.rules.no_underscore_emphasis()
         inline_maths = "inline_math" in self.RULE_NAMES
@@ -373,9 +380,14 @@ def __init__(self, renderer, *args, **kwargs):
 class M2R2(mistune.Markdown):
     def __init__(self, renderer=None, block=None, inline=None, plugins=None, **kwargs):
         disable_inline_math = kwargs.pop("disable_inline_math", False)
+        no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
         renderer = renderer or RestRenderer(**kwargs)
         block = block or RestBlockParser()
-        inline = inline or RestInlineParser(renderer, disable_inline_math)
+        inline = inline or RestInlineParser(
+            renderer,
+            disable_inline_math=disable_inline_math,
+            no_underscore_emphasis=no_underscore_emphasis,
+        )
         super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
 
     def parse(self, text):

From 9067139e0e1d067366512fcb8b1caf4f652c10fa Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Mon, 29 Jul 2024 16:09:11 -0300
Subject: [PATCH 19/22] update

---
 m2r2/m2r2.py | 46 +++++++++++-----------------------------------
 1 file changed, 11 insertions(+), 35 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 101e031..5de2468 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -293,21 +293,11 @@ def parse_rest_code_block(self, match: Match, state: State) -> Token:
 
 
 class RestInlineParser(mistune.InlineParser):
+    INLINE_MATH = r"`\$(.*?)\$`"
     IMAGE_LINK = r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
     REST_ROLE = r":.*?:`.*?`|`[^`]+`:.*?:"
     REST_LINK = r"`[^`]*?`_"
-    INLINE_MATH = r"`\$(.*?)\$`"
     EOL_LITERAL_MARKER = r"(\s+)?::\s*$"
-    # add colon and space as special text
-    TEXT = r"^[\s\S]+?(?=[\\<!\[:_*`~ ]|https?://| {2,}\n|$)"
-    # __word__ or **word**
-    DOUBLE_EMPHASIS = r"^([_*]){2}(?P<text>[\s\S]+?)\1{2}(?!\1)"
-    # _word_ or *word*
-    EMPHASIS = (
-        r"^\b_((?:__|[^_])+?)_\b"  # _word_
-        r"|"
-        r"^\*(?P<text>(?:\*\*|[^\*])+?)\*(?!\*)"  # *word*
-    )
 
     RULE_NAMES = (
         "inline_math",
@@ -315,15 +305,8 @@ class RestInlineParser(mistune.InlineParser):
         "rest_role",
         "rest_link",
         "eol_literal_marker",
-    ) + mistune.InlineParser.RULE_NAMES
-
-    def parse_double_emphasis(self, match: Match, state: State) -> Element:
-        # may include code span
-        return "double_emphasis", match.group("text")
-
-    def parse_emphasis(self, match: Match, state: State) -> Element:
-        # may include code span
-        return "emphasis", match.group("text") or match.group(1)
+        *mistune.InlineParser.RULE_NAMES,
+    )
 
     def parse_image_link(self, match: Match, state: State) -> Element:
         """Pass through rest role."""
@@ -348,9 +331,11 @@ def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
         return "eol_literal_marker", marker
 
     def disable_underscore_emphasis(self):
-        print("Running no_underscore_emphasis")
         self.deregister_rule("underscore_emphasis")
 
+    def disable_inline_math(self):
+        self.deregister_rule("inline_math")
+
     def deregister_rule(self, rule):
         self.rules.remove(rule)
 
@@ -358,23 +343,14 @@ def __init__(self, renderer, *args, **kwargs):
         # no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
         disable_inline_math = kwargs.pop("disable_inline_math", False)
         no_underscore_emphasis = kwargs.pop("no_underscore_emphasis", False)
+
         super().__init__(renderer, *args, **kwargs)
-        # if not _is_sphinx:
-        #    parse_options()
 
         if no_underscore_emphasis:
             self.disable_underscore_emphasis()
 
-        # if no_underscore_emphasis or getattr(options, "no_underscore_emphasis", False):
-        #    self.rules.no_underscore_emphasis()
-        inline_maths = "inline_math" in self.RULE_NAMES
-        if disable_inline_math:  # or getattr(options, "disable_inline_math", False):
-            if inline_maths:
-                self.RULE_NAMES = tuple(
-                    x for x in self.RULE_NAMES if x != "inline_math"
-                )
-        elif not inline_maths:
-            self.RULE_NAMES = ("inline_math", *self.RULE_NAMES)
+        if disable_inline_math:
+            self.disable_inline_math()
 
 
 class M2R2(mistune.Markdown):
@@ -390,8 +366,8 @@ def __init__(self, renderer=None, block=None, inline=None, plugins=None, **kwarg
         )
         super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
 
-    def parse(self, text):
-        output = super().parse(text)
+    def parse(self, s, state=None):
+        output = super().parse(s, state)
         return self.post_process(output)
 
     def post_process(self, text):

From 295b9c3e65a309faadecc6ef0ddc83586d236056 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Tue, 30 Jul 2024 00:02:10 -0300
Subject: [PATCH 20/22] 15/60

---
 m2r2/m2r2.py | 30 +++++++++++++++++++++++++++---
 1 file changed, 27 insertions(+), 3 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index 5de2468..bb85108 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -294,7 +294,24 @@ def parse_rest_code_block(self, match: Match, state: State) -> Token:
 
 class RestInlineParser(mistune.InlineParser):
     INLINE_MATH = r"`\$(.*?)\$`"
-    IMAGE_LINK = r"\[!\[(?P<alt>.*?)\]\((?P<url>.*?)\).*?\]\((?P<target>.*?)\)"
+    STD_LINK = (
+        r"\[(" + mistune.inline_parser.LINK_TEXT + r")\]\(\s*"
+        r"(<(?:\\[<>]?|[^\s<>\\])*>|"
+        r"(?:\\[()]?|\([^\s\x00-\x1f\\]*\)|[^\s\x00-\x1f()\\])*?)"
+        r"(?:\s+("
+        r""""(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)"""
+        r"))?\s*\)"
+    )
+    IMAGE_LINK = (
+        r"\[!" + STD_LINK + r"\]\(\s*"
+        r"(<(?:\\[<>]?|[^\s<>\\])*>|"
+        r"(?:\\[()]?|\([^\s\x00-\x1f\\]*\)|[^\s\x00-\x1f()\\])*?)"
+        r"(?:\s+("
+        r""""(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)"""
+        r"))?\s*\)"
+    )
+    IMAGE = r"!" + STD_LINK
+
     REST_ROLE = r":.*?:`.*?`|`[^`]+`:.*?:"
     REST_LINK = r"`[^`]*?`_"
     EOL_LITERAL_MARKER = r"(\s+)?::\s*$"
@@ -302,15 +319,22 @@ class RestInlineParser(mistune.InlineParser):
     RULE_NAMES = (
         "inline_math",
         "image_link",
+        "image",
         "rest_role",
         "rest_link",
         "eol_literal_marker",
         *mistune.InlineParser.RULE_NAMES,
     )
 
+    def parse_image(self, match: Match, state: State) -> Element:
+        """Parse image."""
+        alt, src, title = re.match(self.IMAGE, match.group()).groups()
+        return "image", src, alt, title
+
     def parse_image_link(self, match: Match, state: State) -> Element:
-        """Pass through rest role."""
-        alt, src, target = match.groups()
+        """Parse image link."""
+        # TODO: document the hell of re.scanner
+        alt, src, _, target, _ = re.match(self.IMAGE_LINK, match.group()).groups()
         return "image_link", src, target, alt
 
     def parse_rest_role(self, match: Match, state: State) -> Element:

From f496d30da73cc67ba634f1ba929d169629decba4 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Tue, 30 Jul 2024 00:07:53 -0300
Subject: [PATCH 21/22] 14/61

---
 m2r2/m2r2.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index bb85108..d6bfa87 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -347,7 +347,9 @@ def parse_rest_link(self, match: Match, state: State) -> Element:
 
     def parse_inline_math(self, match: Match, state: State) -> Element:
         """Pass through rest link."""
-        return "inline_math", match.group(2)
+        # WHY HERE TOO
+        # TODO: CRY
+        return "inline_math", match.group().strip("`").strip("$")
 
     def parse_eol_literal_marker(self, match: Match, state: State) -> Element:
         """Pass through rest link."""

From af66a6d5aba2eab821af69fadd5bbb754be61f51 Mon Sep 17 00:00:00 2001
From: CrossNox <ijmermet@gmail.com>
Date: Tue, 30 Jul 2024 00:24:49 -0300
Subject: [PATCH 22/22] 13/62

---
 m2r2/m2r2.py | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/m2r2/m2r2.py b/m2r2/m2r2.py
index d6bfa87..545c8c7 100644
--- a/m2r2/m2r2.py
+++ b/m2r2/m2r2.py
@@ -105,22 +105,29 @@ def paragraph(self, text):
         return f"\n{text}\n"
 
     def table(self, text):
+        print(f"table {text=}")
         table = "\n.. list-table::\n"
         rows = text.split("\n")
-        if rows and not rows[0].isspace():
-            table = (
-                table
-                + self.indent
-                + ":header-rows: 1\n\n"
-                + self._indent_block(rows[0])
-                + "\n"
-            )
-            rows = rows[1:]
-        else:
-            table = table + "\n"
-        table = table + self._indent_block("\n".join(rows)) + "\n\n"
+        table = table + self._indent_block("\n".join(text.split("\n"))) + "\n\n"
         return table
 
+    def table_head(self, text):
+        print(f"table_head {text=}")
+        contents = text.splitlines()
+        if not contents:
+            return ""
+        clist = ["* " + contents[0]]
+        if len(contents) > 1:
+            for c in contents[1:]:
+                clist.append("  " + c)
+        bottom = "\n".join(clist) + "\n"
+        return f""":header-rows: 1
+
+{bottom}"""
+
+    def table_body(self, text):
+        return text
+
     def table_row(self, text):
         contents = text.splitlines()
         if not contents:
@@ -379,6 +386,9 @@ def __init__(self, renderer, *args, **kwargs):
             self.disable_inline_math()
 
 
+from mistune.plugins import plugin_table
+
+
 class M2R2(mistune.Markdown):
     def __init__(self, renderer=None, block=None, inline=None, plugins=None, **kwargs):
         disable_inline_math = kwargs.pop("disable_inline_math", False)
@@ -390,6 +400,9 @@ def __init__(self, renderer=None, block=None, inline=None, plugins=None, **kwarg
             disable_inline_math=disable_inline_math,
             no_underscore_emphasis=no_underscore_emphasis,
         )
+        if plugins is None:
+            plugins = []
+        plugins.append(plugin_table)
         super().__init__(renderer=renderer, block=block, inline=inline, plugins=plugins)
 
     def parse(self, s, state=None):