two version of R2R are hereHEADmaster

81 files changed, 13247 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/__init__.py b/.venv/lib/python3.12/site-packages/docutils/parsers/__init__.py
new file mode 100644
index 00000000..f1bb268e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/__init__.py
@@ -0,0 +1,92 @@
+# $Id: __init__.py 9048 2022-03-29 21:50:15Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+This package contains Docutils parser modules.
+"""
+
+__docformat__ = 'reStructuredText'
+
+from importlib import import_module
+
+from docutils import Component, frontend
+
+
+class Parser(Component):
+    settings_spec = (
+        'Generic Parser Options',
+        None,
+        (('Disable directives that insert the contents of an external file; '
+          'replaced with a "warning" system message.',
+          ['--no-file-insertion'],
+          {'action': 'store_false', 'default': 1,
+           'dest': 'file_insertion_enabled',
+           'validator': frontend.validate_boolean}),
+         ('Enable directives that insert the contents '
+          'of an external file. (default)',
+          ['--file-insertion-enabled'],
+          {'action': 'store_true'}),
+         ('Disable the "raw" directive; '
+          'replaced with a "warning" system message.',
+          ['--no-raw'],
+          {'action': 'store_false', 'default': 1, 'dest': 'raw_enabled',
+           'validator': frontend.validate_boolean}),
+         ('Enable the "raw" directive. (default)',
+          ['--raw-enabled'],
+          {'action': 'store_true'}),
+         ('Maximal number of characters in an input line. Default 10 000.',
+          ['--line-length-limit'],
+          {'metavar': '<length>', 'type': 'int', 'default': 10000,
+           'validator': frontend.validate_nonnegative_int}),
+         )
+        )
+    component_type = 'parser'
+    config_section = 'parsers'
+
+    def parse(self, inputstring, document):
+        """Override to parse `inputstring` into document tree `document`."""
+        raise NotImplementedError('subclass must override this method')
+
+    def setup_parse(self, inputstring, document):
+        """Initial parse setup.  Call at start of `self.parse()`."""
+        self.inputstring = inputstring
+        # provide fallbacks in case the document has only generic settings
+        document.settings.setdefault('file_insertion_enabled', False)
+        document.settings.setdefault('raw_enabled', False)
+        document.settings.setdefault('line_length_limit', 10000)
+        self.document = document
+        document.reporter.attach_observer(document.note_parse_message)
+
+    def finish_parse(self):
+        """Finalize parse details.  Call at end of `self.parse()`."""
+        self.document.reporter.detach_observer(
+            self.document.note_parse_message)
+
+
+_parser_aliases = {  # short names for known parsers
+                   'null': 'docutils.parsers.null',
+                   # reStructuredText
+                   'rst': 'docutils.parsers.rst',
+                   'restructuredtext': 'docutils.parsers.rst',
+                   'rest': 'docutils.parsers.rst',
+                   'restx': 'docutils.parsers.rst',
+                   'rtxt': 'docutils.parsers.rst',
+                   # 3rd-party Markdown parsers
+                   'recommonmark': 'docutils.parsers.recommonmark_wrapper',
+                   'myst': 'myst_parser.docutils_',
+                   # 'pycmark': works out of the box
+                   # dispatcher for 3rd-party Markdown parsers
+                   'commonmark': 'docutils.parsers.commonmark_wrapper',
+                   'markdown': 'docutils.parsers.commonmark_wrapper',
+                  }
+
+
+def get_parser_class(parser_name):
+    """Return the Parser class from the `parser_name` module."""
+    name = parser_name.lower()
+    try:
+        module = import_module(_parser_aliases.get(name, name))
+    except ImportError as err:
+        raise ImportError(f'Parser "{parser_name}" not found. {err}')
+    return module.Parser
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/commonmark_wrapper.py b/.venv/lib/python3.12/site-packages/docutils/parsers/commonmark_wrapper.py
new file mode 100644
index 00000000..ea538a6b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/commonmark_wrapper.py
@@ -0,0 +1,56 @@
+#! /usr/bin/env python3
+# :Copyright: © 2022 Günter Milde.
+# :License: Released under the terms of the `2-Clause BSD license`_, in short:
+#
+#    Copying and distribution of this file, with or without modification,
+#    are permitted in any medium without royalty provided the copyright
+#    notice and this notice are preserved.
+#    This file is offered as-is, without any warranty.
+#
+# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
+#
+# Revision: $Revision: 9561 $
+# Date: $Date: 2024-03-14 17:34:48 +0100 (Do, 14. Mär 2024) $
+"""
+An interface for parsing CommonMark input.
+
+Select a locally installed parser from the following 3rd-party
+parser packages:
+
+:pycmark:       https://pypi.org/project/pycmark/
+:myst:          https://pypi.org/project/myst-docutils/
+:recommonmark:  https://pypi.org/project/recommonmark/ (deprecated)
+
+The first parser class that can be successfully imported is mapped to
+`commonmark_wrapper.Parser`.
+
+This module is provisional:
+the API is not settled and may change with any minor Docutils version.
+"""
+
+import docutils.parsers
+
+
+commonmark_parser_names = ('pycmark', 'myst', 'recommonmark')
+"""Names of compatible drop-in CommonMark parsers"""
+
+Parser = None
+parser_name = ''
+
+for name in commonmark_parser_names:
+    try:
+        Parser = docutils.parsers.get_parser_class(name)
+    except ImportError:
+        continue
+    parser_name = name
+    break
+
+if Parser is None:
+    raise ImportError(
+              'Parsing "CommonMark" requires one of the packages\n'
+              f'{commonmark_parser_names} available at https://pypi.org')
+
+if parser_name == 'myst':
+    if not Parser.settings_defaults:
+        Parser.settings_defaults = {}
+    Parser.settings_defaults['myst_commonmark_only'] = True
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/null.py b/.venv/lib/python3.12/site-packages/docutils/parsers/null.py
new file mode 100644
index 00000000..238c4502
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/null.py
@@ -0,0 +1,20 @@
+# $Id: null.py 4564 2006-05-21 20:44:42Z wiemann $
+# Author: Martin Blais <blais@furius.ca>
+# Copyright: This module has been placed in the public domain.
+
+"""A do-nothing parser."""
+
+from docutils import parsers
+
+
+class Parser(parsers.Parser):
+
+    """A do-nothing parser."""
+
+    supported = ('null',)
+
+    config_section = 'null parser'
+    config_section_dependencies = ('parsers',)
+
+    def parse(self, inputstring, document):
+        pass
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/recommonmark_wrapper.py b/.venv/lib/python3.12/site-packages/docutils/parsers/recommonmark_wrapper.py
new file mode 100644
index 00000000..151a8bde
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/recommonmark_wrapper.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# :Copyright: © 2020 Günter Milde.
+# :License: Released under the terms of the `2-Clause BSD license`_, in short:
+#
+#    Copying and distribution of this file, with or without modification,
+#    are permitted in any medium without royalty provided the copyright
+#    notice and this notice are preserved.
+#    This file is offered as-is, without any warranty.
+#
+# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause
+#
+# Revision: $Revision: 9302 $
+# Date: $Date: 2022-12-02 18:14:05 +0100 (Fr, 02. Dez 2022) $
+"""
+A parser for CommonMark Markdown text using `recommonmark`__.
+
+__ https://pypi.org/project/recommonmark/
+
+.. important:: This module is provisional
+
+   * The "recommonmark" package is unmaintained and deprecated.
+     This wrapper module will be removed in a future Docutils version.
+
+   * The API is not settled and may change with any minor Docutils version.
+"""
+
+from docutils import Component
+from docutils import nodes
+
+try:
+    # If possible, import Sphinx's 'addnodes'
+    from sphinx import addnodes
+except ImportError:
+    # stub to prevent errors if Sphinx isn't installed
+    import sys
+    import types
+
+    class pending_xref(nodes.Inline, nodes.Element): ... # NoQA
+
+    sys.modules['sphinx'] = sphinx = types.ModuleType('sphinx')
+    sphinx.addnodes = addnodes = types.SimpleNamespace()
+    addnodes.pending_xref = pending_xref
+try:
+    import recommonmark
+    from recommonmark.parser import CommonMarkParser
+except ImportError as err:
+    raise ImportError(
+        'Parsing "recommonmark" Markdown flavour requires the\n'
+        '  package https://pypi.org/project/recommonmark.'
+    ) from err
+else:
+    if recommonmark.__version__ < '0.6.0':
+        raise ImportError('The installed version of "recommonmark" is too old.'
+                          ' Update with "pip install -U recommonmark".')
+
+
+# auxiliary function for `document.findall()`
+def is_literal(node):
+    return isinstance(node, (nodes.literal, nodes.literal_block))
+
+
+class Parser(CommonMarkParser):
+    """MarkDown parser based on recommonmark.
+
+    This parser is provisional:
+    the API is not settled and may change with any minor Docutils version.
+    """
+    supported = ('recommonmark', 'commonmark', 'markdown', 'md')
+    """Formats this parser supports."""
+
+    config_section = 'recommonmark parser'
+    config_section_dependencies = ('parsers',)
+
+    def get_transforms(self):
+        return Component.get_transforms(self)  # + [AutoStructify]
+
+    def parse(self, inputstring, document):
+        """Use the upstream parser and clean up afterwards.
+        """
+        # check for exorbitantly long lines
+        for i, line in enumerate(inputstring.split('\n')):
+            if len(line) > document.settings.line_length_limit:
+                error = document.reporter.error(
+                    'Line %d exceeds the line-length-limit.'%(i+1))
+                document.append(error)
+                return
+
+        # pass to upstream parser
+        try:
+            CommonMarkParser.parse(self, inputstring, document)
+        except Exception as err:
+            if document.settings.traceback:
+                raise err
+            error = document.reporter.error('Parsing with "recommonmark" '
+                                            'returned the error:\n%s'%err)
+            document.append(error)
+
+        # Post-Processing
+        # ---------------
+
+        # merge adjoining Text nodes:
+        for node in document.findall(nodes.TextElement):
+            children = node.children
+            i = 0
+            while i+1 < len(children):
+                if (isinstance(children[i], nodes.Text)
+                    and isinstance(children[i+1], nodes.Text)):
+                    children[i] = nodes.Text(children[i]+children.pop(i+1))
+                    children[i].parent = node
+                else:
+                    i += 1
+
+        # add "code" class argument to literal elements (inline and block)
+        for node in document.findall(is_literal):
+            if 'code' not in node['classes']:
+                node['classes'].append('code')
+        # move "language" argument to classes
+        for node in document.findall(nodes.literal_block):
+            if 'language' in node.attributes:
+                node['classes'].append(node['language'])
+                del node['language']
+
+        # replace raw nodes if raw is not allowed
+        if not document.settings.raw_enabled:
+            for node in document.findall(nodes.raw):
+                warning = document.reporter.warning('Raw content disabled.')
+                node.parent.replace(node, warning)
+
+        # drop pending_xref (Sphinx cross reference extension)
+        for node in document.findall(addnodes.pending_xref):
+            reference = node.children[0]
+            if 'name' not in reference:
+                reference['name'] = nodes.fully_normalize_name(
+                                                    reference.astext())
+            node.parent.replace(node, reference)
+
+    def visit_document(self, node):
+        """Dummy function to prevent spurious warnings.
+
+        cf. https://github.com/readthedocs/recommonmark/issues/177
+        """
+        pass
+
+    # Overwrite parent method with version that
+    # doesn't pass deprecated `rawsource` argument to nodes.Text:
+    def visit_text(self, mdnode):
+        self.current_node.append(nodes.Text(mdnode.literal))
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/__init__.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/__init__.py
new file mode 100644
index 00000000..460a2e95
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/__init__.py
@@ -0,0 +1,413 @@
+# $Id: __init__.py 9258 2022-11-21 14:51:43Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+This is ``docutils.parsers.rst`` package. It exports a single class, `Parser`,
+the reStructuredText parser.
+
+
+Usage
+=====
+
+1. Create a parser::
+
+       parser = docutils.parsers.rst.Parser()
+
+   Several optional arguments may be passed to modify the parser's behavior.
+   Please see `Customizing the Parser`_ below for details.
+
+2. Gather input (a multi-line string), by reading a file or the standard
+   input::
+
+       input = sys.stdin.read()
+
+3. Create a new empty `docutils.nodes.document` tree::
+
+       document = docutils.utils.new_document(source, settings)
+
+   See `docutils.utils.new_document()` for parameter details.
+
+4. Run the parser, populating the document tree::
+
+       parser.parse(input, document)
+
+
+Parser Overview
+===============
+
+The reStructuredText parser is implemented as a state machine, examining its
+input one line at a time. To understand how the parser works, please first
+become familiar with the `docutils.statemachine` module, then see the
+`states` module.
+
+
+Customizing the Parser
+----------------------
+
+Anything that isn't already customizable is that way simply because that type
+of customizability hasn't been implemented yet.  Patches welcome!
+
+When instantiating an object of the `Parser` class, two parameters may be
+passed: ``rfc2822`` and ``inliner``.  Pass ``rfc2822=True`` to enable an
+initial RFC-2822 style header block, parsed as a "field_list" element (with
+"class" attribute set to "rfc2822").  Currently this is the only body-level
+element which is customizable without subclassing.  (Tip: subclass `Parser`
+and change its "state_classes" and "initial_state" attributes to refer to new
+classes. Contact the author if you need more details.)
+
+The ``inliner`` parameter takes an instance of `states.Inliner` or a subclass.
+It handles inline markup recognition.  A common extension is the addition of
+further implicit hyperlinks, like "RFC 2822".  This can be done by subclassing
+`states.Inliner`, adding a new method for the implicit markup, and adding a
+``(pattern, method)`` pair to the "implicit_dispatch" attribute of the
+subclass.  See `states.Inliner.implicit_inline()` for details.  Explicit
+inline markup can be customized in a `states.Inliner` subclass via the
+``patterns.initial`` and ``dispatch`` attributes (and new methods as
+appropriate).
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+import docutils.parsers
+import docutils.statemachine
+from docutils.parsers.rst import roles, states
+from docutils import frontend, nodes
+from docutils.transforms import universal
+
+
+class Parser(docutils.parsers.Parser):
+
+    """The reStructuredText parser."""
+
+    supported = ('rst', 'restructuredtext', 'rest', 'restx', 'rtxt', 'rstx')
+    """Aliases this parser supports."""
+
+    settings_spec = docutils.parsers.Parser.settings_spec + (
+        'reStructuredText Parser Options',
+        None,
+        (('Recognize and link to standalone PEP references (like "PEP 258").',
+          ['--pep-references'],
+          {'action': 'store_true', 'validator': frontend.validate_boolean}),
+         ('Base URL for PEP references '
+          '(default "https://peps.python.org/").',
+          ['--pep-base-url'],
+          {'metavar': '<URL>', 'default': 'https://peps.python.org/',
+           'validator': frontend.validate_url_trailing_slash}),
+         ('Template for PEP file part of URL. (default "pep-%04d")',
+          ['--pep-file-url-template'],
+          {'metavar': '<URL>', 'default': 'pep-%04d'}),
+         ('Recognize and link to standalone RFC references (like "RFC 822").',
+          ['--rfc-references'],
+          {'action': 'store_true', 'validator': frontend.validate_boolean}),
+         ('Base URL for RFC references '
+          '(default "https://tools.ietf.org/html/").',
+          ['--rfc-base-url'],
+          {'metavar': '<URL>', 'default': 'https://tools.ietf.org/html/',
+           'validator': frontend.validate_url_trailing_slash}),
+         ('Set number of spaces for tab expansion (default 8).',
+          ['--tab-width'],
+          {'metavar': '<width>', 'type': 'int', 'default': 8,
+           'validator': frontend.validate_nonnegative_int}),
+         ('Remove spaces before footnote references.',
+          ['--trim-footnote-reference-space'],
+          {'action': 'store_true', 'validator': frontend.validate_boolean}),
+         ('Leave spaces before footnote references.',
+          ['--leave-footnote-reference-space'],
+          {'action': 'store_false', 'dest': 'trim_footnote_reference_space'}),
+         ('Token name set for parsing code with Pygments: one of '
+          '"long", "short", or "none" (no parsing). Default is "long".',
+          ['--syntax-highlight'],
+          {'choices': ['long', 'short', 'none'],
+           'default': 'long', 'metavar': '<format>'}),
+         ('Change straight quotation marks to typographic form: '
+          'one of "yes", "no", "alt[ernative]" (default "no").',
+          ['--smart-quotes'],
+          {'default': False, 'metavar': '<yes/no/alt>',
+           'validator': frontend.validate_ternary}),
+         ('Characters to use as "smart quotes" for <language>. ',
+          ['--smartquotes-locales'],
+          {'metavar': '<language:quotes[,language:quotes,...]>',
+           'action': 'append',
+           'validator': frontend.validate_smartquotes_locales}),
+         ('Inline markup recognized at word boundaries only '
+          '(adjacent to punctuation or whitespace). '
+          'Force character-level inline markup recognition with '
+          '"\\ " (backslash + space). Default.',
+          ['--word-level-inline-markup'],
+          {'action': 'store_false', 'dest': 'character_level_inline_markup'}),
+         ('Inline markup recognized anywhere, regardless of surrounding '
+          'characters. Backslash-escapes must be used to avoid unwanted '
+          'markup recognition. Useful for East Asian languages. '
+          'Experimental.',
+          ['--character-level-inline-markup'],
+          {'action': 'store_true', 'default': False,
+           'dest': 'character_level_inline_markup'}),
+         )
+        )
+
+    config_section = 'restructuredtext parser'
+    config_section_dependencies = ('parsers',)
+
+    def __init__(self, rfc2822=False, inliner=None):
+        if rfc2822:
+            self.initial_state = 'RFC2822Body'
+        else:
+            self.initial_state = 'Body'
+        self.state_classes = states.state_classes
+        self.inliner = inliner
+
+    def get_transforms(self):
+        return super().get_transforms() + [universal.SmartQuotes]
+
+    def parse(self, inputstring, document):
+        """Parse `inputstring` and populate `document`, a document tree."""
+        self.setup_parse(inputstring, document)
+        # provide fallbacks in case the document has only generic settings
+        self.document.settings.setdefault('tab_width', 8)
+        self.document.settings.setdefault('syntax_highlight', 'long')
+        self.statemachine = states.RSTStateMachine(
+              state_classes=self.state_classes,
+              initial_state=self.initial_state,
+              debug=document.reporter.debug_flag)
+        inputlines = docutils.statemachine.string2lines(
+              inputstring, tab_width=document.settings.tab_width,
+              convert_whitespace=True)
+        for i, line in enumerate(inputlines):
+            if len(line) > self.document.settings.line_length_limit:
+                error = self.document.reporter.error(
+                            'Line %d exceeds the line-length-limit.'%(i+1))
+                self.document.append(error)
+                break
+        else:
+            self.statemachine.run(inputlines, document, inliner=self.inliner)
+        # restore the "default" default role after parsing a document
+        if '' in roles._roles:
+            del roles._roles['']
+        self.finish_parse()
+
+
+class DirectiveError(Exception):
+
+    """
+    Store a message and a system message level.
+
+    To be thrown from inside directive code.
+
+    Do not instantiate directly -- use `Directive.directive_error()`
+    instead!
+    """
+
+    def __init__(self, level, message):
+        """Set error `message` and `level`"""
+        Exception.__init__(self)
+        self.level = level
+        self.msg = message
+
+
+class Directive:
+
+    """
+    Base class for reStructuredText directives.
+
+    The following attributes may be set by subclasses.  They are
+    interpreted by the directive parser (which runs the directive
+    class):
+
+    - `required_arguments`: The number of required arguments (default:
+      0).
+
+    - `optional_arguments`: The number of optional arguments (default:
+      0).
+
+    - `final_argument_whitespace`: A boolean, indicating if the final
+      argument may contain whitespace (default: False).
+
+    - `option_spec`: A dictionary, mapping known option names to
+      conversion functions such as `int` or `float` (default: {}, no
+      options).  Several conversion functions are defined in the
+      directives/__init__.py module.
+
+      Option conversion functions take a single parameter, the option
+      argument (a string or ``None``), validate it and/or convert it
+      to the appropriate form.  Conversion functions may raise
+      `ValueError` and `TypeError` exceptions.
+
+    - `has_content`: A boolean; True if content is allowed.  Client
+      code must handle the case where content is required but not
+      supplied (an empty content list will be supplied).
+
+    Arguments are normally single whitespace-separated words.  The
+    final argument may contain whitespace and/or newlines if
+    `final_argument_whitespace` is True.
+
+    If the form of the arguments is more complex, specify only one
+    argument (either required or optional) and set
+    `final_argument_whitespace` to True; the client code must do any
+    context-sensitive parsing.
+
+    When a directive implementation is being run, the directive class
+    is instantiated, and the `run()` method is executed.  During
+    instantiation, the following instance variables are set:
+
+    - ``name`` is the directive type or name (string).
+
+    - ``arguments`` is the list of positional arguments (strings).
+
+    - ``options`` is a dictionary mapping option names (strings) to
+      values (type depends on option conversion functions; see
+      `option_spec` above).
+
+    - ``content`` is a list of strings, the directive content line by line.
+
+    - ``lineno`` is the absolute line number of the first line
+      of the directive.
+
+    - ``content_offset`` is the line offset of the first line
+      of the content from the beginning of the current input.
+      Used when initiating a nested parse.
+
+    - ``block_text`` is a string containing the entire directive.
+
+    - ``state`` is the state which called the directive function.
+
+    - ``state_machine`` is the state machine which controls the state
+      which called the directive function.
+
+    - ``reporter`` is the state machine's `reporter` instance.
+
+    Directive functions return a list of nodes which will be inserted
+    into the document tree at the point where the directive was
+    encountered.  This can be an empty list if there is nothing to
+    insert.
+
+    For ordinary directives, the list must contain body elements or
+    structural elements.  Some directives are intended specifically
+    for substitution definitions, and must return a list of `Text`
+    nodes and/or inline elements (suitable for inline insertion, in
+    place of the substitution reference).  Such directives must verify
+    substitution definition context, typically using code like this::
+
+        if not isinstance(state, states.SubstitutionDef):
+            error = self.reporter.error(
+                'Invalid context: the "%s" directive can only be used '
+                'within a substitution definition.' % (name),
+                nodes.literal_block(block_text, block_text), line=lineno)
+            return [error]
+    """
+
+    # There is a "Creating reStructuredText Directives" how-to at
+    # <https://docutils.sourceforge.io/docs/howto/rst-directives.html>.  If you
+    # update this docstring, please update the how-to as well.
+
+    required_arguments = 0
+    """Number of required directive arguments."""
+
+    optional_arguments = 0
+    """Number of optional arguments after the required arguments."""
+
+    final_argument_whitespace = False
+    """May the final argument contain whitespace?"""
+
+    option_spec = None
+    """Mapping of option names to validator functions."""
+
+    has_content = False
+    """May the directive have content?"""
+
+    def __init__(self, name, arguments, options, content, lineno,
+                 content_offset, block_text, state, state_machine):
+        self.name = name
+        self.arguments = arguments
+        self.options = options
+        self.content = content
+        self.lineno = lineno
+        self.content_offset = content_offset
+        self.block_text = block_text
+        self.state = state
+        self.state_machine = state_machine
+        self.reporter = state_machine.reporter
+
+    def run(self):
+        raise NotImplementedError('Must override run() in subclass.')
+
+    # Directive errors:
+
+    def directive_error(self, level, message):
+        """
+        Return a DirectiveError suitable for being thrown as an exception.
+
+        Call "raise self.directive_error(level, message)" from within
+        a directive implementation to return one single system message
+        at level `level`, which automatically gets the directive block
+        and the line number added.
+
+        Preferably use the `debug`, `info`, `warning`, `error`, or `severe`
+        wrapper methods, e.g. ``self.error(message)`` to generate an
+        ERROR-level directive error.
+        """
+        return DirectiveError(level, message)
+
+    def debug(self, message):
+        return self.directive_error(0, message)
+
+    def info(self, message):
+        return self.directive_error(1, message)
+
+    def warning(self, message):
+        return self.directive_error(2, message)
+
+    def error(self, message):
+        return self.directive_error(3, message)
+
+    def severe(self, message):
+        return self.directive_error(4, message)
+
+    # Convenience methods:
+
+    def assert_has_content(self):
+        """
+        Throw an ERROR-level DirectiveError if the directive doesn't
+        have contents.
+        """
+        if not self.content:
+            raise self.error('Content block expected for the "%s" directive; '
+                             'none found.' % self.name)
+
+    def add_name(self, node):
+        """Append self.options['name'] to node['names'] if it exists.
+
+        Also normalize the name string and register it as explicit target.
+        """
+        if 'name' in self.options:
+            name = nodes.fully_normalize_name(self.options.pop('name'))
+            if 'name' in node:
+                del node['name']
+            node['names'].append(name)
+            self.state.document.note_explicit_target(node, node)
+
+
+def convert_directive_function(directive_fn):
+    """
+    Define & return a directive class generated from `directive_fn`.
+
+    `directive_fn` uses the old-style, functional interface.
+    """
+
+    class FunctionalDirective(Directive):
+
+        option_spec = getattr(directive_fn, 'options', None)
+        has_content = getattr(directive_fn, 'content', False)
+        _argument_spec = getattr(directive_fn, 'arguments', (0, 0, False))
+        required_arguments, optional_arguments, final_argument_whitespace \
+            = _argument_spec
+
+        def run(self):
+            return directive_fn(
+                self.name, self.arguments, self.options, self.content,
+                self.lineno, self.content_offset, self.block_text,
+                self.state, self.state_machine)
+
+    # Return new-style directive.
+    return FunctionalDirective
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/__init__.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/__init__.py
new file mode 100644
index 00000000..ebbdfe3b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/__init__.py
@@ -0,0 +1,466 @@
+# $Id: __init__.py 9426 2023-07-03 12:38:54Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+This package contains directive implementation modules.
+"""
+
+__docformat__ = 'reStructuredText'
+
+import re
+import codecs
+from importlib import import_module
+
+from docutils import nodes, parsers
+from docutils.utils import split_escaped_whitespace, escape2null
+from docutils.parsers.rst.languages import en as _fallback_language_module
+
+
+_directive_registry = {
+      'attention': ('admonitions', 'Attention'),
+      'caution': ('admonitions', 'Caution'),
+      'code': ('body', 'CodeBlock'),
+      'danger': ('admonitions', 'Danger'),
+      'error': ('admonitions', 'Error'),
+      'important': ('admonitions', 'Important'),
+      'note': ('admonitions', 'Note'),
+      'tip': ('admonitions', 'Tip'),
+      'hint': ('admonitions', 'Hint'),
+      'warning': ('admonitions', 'Warning'),
+      'admonition': ('admonitions', 'Admonition'),
+      'sidebar': ('body', 'Sidebar'),
+      'topic': ('body', 'Topic'),
+      'line-block': ('body', 'LineBlock'),
+      'parsed-literal': ('body', 'ParsedLiteral'),
+      'math': ('body', 'MathBlock'),
+      'rubric': ('body', 'Rubric'),
+      'epigraph': ('body', 'Epigraph'),
+      'highlights': ('body', 'Highlights'),
+      'pull-quote': ('body', 'PullQuote'),
+      'compound': ('body', 'Compound'),
+      'container': ('body', 'Container'),
+      # 'questions': ('body', 'question_list'),
+      'table': ('tables', 'RSTTable'),
+      'csv-table': ('tables', 'CSVTable'),
+      'list-table': ('tables', 'ListTable'),
+      'image': ('images', 'Image'),
+      'figure': ('images', 'Figure'),
+      'contents': ('parts', 'Contents'),
+      'sectnum': ('parts', 'Sectnum'),
+      'header': ('parts', 'Header'),
+      'footer': ('parts', 'Footer'),
+      # 'footnotes': ('parts', 'footnotes'),
+      # 'citations': ('parts', 'citations'),
+      'target-notes': ('references', 'TargetNotes'),
+      'meta': ('misc', 'Meta'),
+      # 'imagemap': ('html', 'imagemap'),
+      'raw': ('misc', 'Raw'),
+      'include': ('misc', 'Include'),
+      'replace': ('misc', 'Replace'),
+      'unicode': ('misc', 'Unicode'),
+      'class': ('misc', 'Class'),
+      'role': ('misc', 'Role'),
+      'default-role': ('misc', 'DefaultRole'),
+      'title': ('misc', 'Title'),
+      'date': ('misc', 'Date'),
+      'restructuredtext-test-directive': ('misc', 'TestDirective'),
+      }
+"""Mapping of directive name to (module name, class name).  The
+directive name is canonical & must be lowercase.  Language-dependent
+names are defined in the ``language`` subpackage."""
+
+_directives = {}
+"""Cache of imported directives."""
+
+
+def directive(directive_name, language_module, document):
+    """
+    Locate and return a directive function from its language-dependent name.
+    If not found in the current language, check English.  Return None if the
+    named directive cannot be found.
+    """
+    normname = directive_name.lower()
+    messages = []
+    msg_text = []
+    if normname in _directives:
+        return _directives[normname], messages
+    canonicalname = None
+    try:
+        canonicalname = language_module.directives[normname]
+    except AttributeError as error:
+        msg_text.append('Problem retrieving directive entry from language '
+                        'module %r: %s.' % (language_module, error))
+    except KeyError:
+        msg_text.append('No directive entry for "%s" in module "%s".'
+                        % (directive_name, language_module.__name__))
+    if not canonicalname:
+        try:
+            canonicalname = _fallback_language_module.directives[normname]
+            msg_text.append('Using English fallback for directive "%s".'
+                            % directive_name)
+        except KeyError:
+            msg_text.append('Trying "%s" as canonical directive name.'
+                            % directive_name)
+            # The canonical name should be an English name, but just in case:
+            canonicalname = normname
+    if msg_text:
+        message = document.reporter.info(
+            '\n'.join(msg_text), line=document.current_line)
+        messages.append(message)
+    try:
+        modulename, classname = _directive_registry[canonicalname]
+    except KeyError:
+        # Error handling done by caller.
+        return None, messages
+    try:
+        module = import_module('docutils.parsers.rst.directives.'+modulename)
+    except ImportError as detail:
+        messages.append(document.reporter.error(
+            'Error importing directive module "%s" (directive "%s"):\n%s'
+            % (modulename, directive_name, detail),
+            line=document.current_line))
+        return None, messages
+    try:
+        directive = getattr(module, classname)
+        _directives[normname] = directive
+    except AttributeError:
+        messages.append(document.reporter.error(
+            'No directive class "%s" in module "%s" (directive "%s").'
+            % (classname, modulename, directive_name),
+            line=document.current_line))
+        return None, messages
+    return directive, messages
+
+
+def register_directive(name, directive):
+    """
+    Register a nonstandard application-defined directive function.
+    Language lookups are not needed for such functions.
+    """
+    _directives[name] = directive
+
+
+# conversion functions for `Directive.option_spec`
+# ------------------------------------------------
+#
+# see also `parsers.rst.Directive` in ../__init__.py.
+
+
+def flag(argument):
+    """
+    Check for a valid flag option (no argument) and return ``None``.
+    (Directive option conversion function.)
+
+    Raise ``ValueError`` if an argument is found.
+    """
+    if argument and argument.strip():
+        raise ValueError('no argument is allowed; "%s" supplied' % argument)
+    else:
+        return None
+
+
+def unchanged_required(argument):
+    """
+    Return the argument text, unchanged.
+    (Directive option conversion function.)
+
+    Raise ``ValueError`` if no argument is found.
+    """
+    if argument is None:
+        raise ValueError('argument required but none supplied')
+    else:
+        return argument  # unchanged!
+
+
+def unchanged(argument):
+    """
+    Return the argument text, unchanged.
+    (Directive option conversion function.)
+
+    No argument implies empty string ("").
+    """
+    if argument is None:
+        return ''
+    else:
+        return argument  # unchanged!
+
+
+def path(argument):
+    """
+    Return the path argument unwrapped (with newlines removed).
+    (Directive option conversion function.)
+
+    Raise ``ValueError`` if no argument is found.
+    """
+    if argument is None:
+        raise ValueError('argument required but none supplied')
+    else:
+        return ''.join(s.strip() for s in argument.splitlines())
+
+
+def uri(argument):
+    """
+    Return the URI argument with unescaped whitespace removed.
+    (Directive option conversion function.)
+
+    Raise ``ValueError`` if no argument is found.
+    """
+    if argument is None:
+        raise ValueError('argument required but none supplied')
+    else:
+        parts = split_escaped_whitespace(escape2null(argument))
+        return ' '.join(''.join(nodes.unescape(part).split())
+                        for part in parts)
+
+
+def nonnegative_int(argument):
+    """
+    Check for a nonnegative integer argument; raise ``ValueError`` if not.
+    (Directive option conversion function.)
+    """
+    value = int(argument)
+    if value < 0:
+        raise ValueError('negative value; must be positive or zero')
+    return value
+
+
+def percentage(argument):
+    """
+    Check for an integer percentage value with optional percent sign.
+    (Directive option conversion function.)
+    """
+    try:
+        argument = argument.rstrip(' %')
+    except AttributeError:
+        pass
+    return nonnegative_int(argument)
+
+
+length_units = ['em', 'ex', 'px', 'in', 'cm', 'mm', 'pt', 'pc']
+
+
+def get_measure(argument, units):
+    """
+    Check for a positive argument of one of the units and return a
+    normalized string of the form "<value><unit>" (without space in
+    between).
+    (Directive option conversion function.)
+
+    To be called from directive option conversion functions.
+    """
+    match = re.match(r'^([0-9.]+) *(%s)$' % '|'.join(units), argument)
+    try:
+        float(match.group(1))
+    except (AttributeError, ValueError):
+        raise ValueError(
+            'not a positive measure of one of the following units:\n%s'
+            % ' '.join('"%s"' % i for i in units))
+    return match.group(1) + match.group(2)
+
+
+def length_or_unitless(argument):
+    return get_measure(argument, length_units + [''])
+
+
+def length_or_percentage_or_unitless(argument, default=''):
+    """
+    Return normalized string of a length or percentage unit.
+    (Directive option conversion function.)
+
+    Add <default> if there is no unit. Raise ValueError if the argument is not
+    a positive measure of one of the valid CSS units (or without unit).
+
+    >>> length_or_percentage_or_unitless('3 pt')
+    '3pt'
+    >>> length_or_percentage_or_unitless('3%', 'em')
+    '3%'
+    >>> length_or_percentage_or_unitless('3')
+    '3'
+    >>> length_or_percentage_or_unitless('3', 'px')
+    '3px'
+    """
+    try:
+        return get_measure(argument, length_units + ['%'])
+    except ValueError:
+        try:
+            return get_measure(argument, ['']) + default
+        except ValueError:
+            # raise ValueError with list of valid units:
+            return get_measure(argument, length_units + ['%'])
+
+
+def class_option(argument):
+    """
+    Convert the argument into a list of ID-compatible strings and return it.
+    (Directive option conversion function.)
+
+    Raise ``ValueError`` if no argument is found.
+    """
+    if argument is None:
+        raise ValueError('argument required but none supplied')
+    names = argument.split()
+    class_names = []
+    for name in names:
+        class_name = nodes.make_id(name)
+        if not class_name:
+            raise ValueError('cannot make "%s" into a class name' % name)
+        class_names.append(class_name)
+    return class_names
+
+
+unicode_pattern = re.compile(
+    r'(?:0x|x|\\x|U\+?|\\u)([0-9a-f]+)$|&#x([0-9a-f]+);$', re.IGNORECASE)
+
+
+def unicode_code(code):
+    r"""
+    Convert a Unicode character code to a Unicode character.
+    (Directive option conversion function.)
+
+    Codes may be decimal numbers, hexadecimal numbers (prefixed by ``0x``,
+    ``x``, ``\x``, ``U+``, ``u``, or ``\u``; e.g. ``U+262E``), or XML-style
+    numeric character entities (e.g. ``&#x262E;``).  Other text remains as-is.
+
+    Raise ValueError for illegal Unicode code values.
+    """
+    try:
+        if code.isdigit():                  # decimal number
+            return chr(int(code))
+        else:
+            match = unicode_pattern.match(code)
+            if match:                       # hex number
+                value = match.group(1) or match.group(2)
+                return chr(int(value, 16))
+            else:                           # other text
+                return code
+    except OverflowError as detail:
+        raise ValueError('code too large (%s)' % detail)
+
+
+def single_char_or_unicode(argument):
+    """
+    A single character is returned as-is.  Unicode character codes are
+    converted as in `unicode_code`.  (Directive option conversion function.)
+    """
+    char = unicode_code(argument)
+    if len(char) > 1:
+        raise ValueError('%r invalid; must be a single character or '
+                         'a Unicode code' % char)
+    return char
+
+
+def single_char_or_whitespace_or_unicode(argument):
+    """
+    As with `single_char_or_unicode`, but "tab" and "space" are also supported.
+    (Directive option conversion function.)
+    """
+    if argument == 'tab':
+        char = '\t'
+    elif argument == 'space':
+        char = ' '
+    else:
+        char = single_char_or_unicode(argument)
+    return char
+
+
+def positive_int(argument):
+    """
+    Converts the argument into an integer.  Raises ValueError for negative,
+    zero, or non-integer values.  (Directive option conversion function.)
+    """
+    value = int(argument)
+    if value < 1:
+        raise ValueError('negative or zero value; must be positive')
+    return value
+
+
+def positive_int_list(argument):
+    """
+    Converts a space- or comma-separated list of values into a Python list
+    of integers.
+    (Directive option conversion function.)
+
+    Raises ValueError for non-positive-integer values.
+    """
+    if ',' in argument:
+        entries = argument.split(',')
+    else:
+        entries = argument.split()
+    return [positive_int(entry) for entry in entries]
+
+
+def encoding(argument):
+    """
+    Verifies the encoding argument by lookup.
+    (Directive option conversion function.)
+
+    Raises ValueError for unknown encodings.
+    """
+    try:
+        codecs.lookup(argument)
+    except LookupError:
+        raise ValueError('unknown encoding: "%s"' % argument)
+    return argument
+
+
+def choice(argument, values):
+    """
+    Directive option utility function, supplied to enable options whose
+    argument must be a member of a finite set of possible values (must be
+    lower case).  A custom conversion function must be written to use it.  For
+    example::
+
+        from docutils.parsers.rst import directives
+
+        def yesno(argument):
+            return directives.choice(argument, ('yes', 'no'))
+
+    Raise ``ValueError`` if no argument is found or if the argument's value is
+    not valid (not an entry in the supplied list).
+    """
+    try:
+        value = argument.lower().strip()
+    except AttributeError:
+        raise ValueError('must supply an argument; choose from %s'
+                         % format_values(values))
+    if value in values:
+        return value
+    else:
+        raise ValueError('"%s" unknown; choose from %s'
+                         % (argument, format_values(values)))
+
+
+def format_values(values):
+    return '%s, or "%s"' % (', '.join('"%s"' % s for s in values[:-1]),
+                            values[-1])
+
+
+def value_or(values, other):
+    """
+    Directive option conversion function.
+
+    The argument can be any of `values` or `argument_type`.
+    """
+    def auto_or_other(argument):
+        if argument in values:
+            return argument
+        else:
+            return other(argument)
+    return auto_or_other
+
+
+def parser_name(argument):
+    """
+    Return a docutils parser whose name matches the argument.
+    (Directive option conversion function.)
+
+    Return `None`, if the argument evaluates to `False`.
+    Raise `ValueError` if importing the parser module fails.
+    """
+    if not argument:
+        return None
+    try:
+        return parsers.get_parser_class(argument)
+    except ImportError as err:
+        raise ValueError(str(err))
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/admonitions.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/admonitions.py
new file mode 100644
index 00000000..1990099e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/admonitions.py
@@ -0,0 +1,101 @@
+# $Id: admonitions.py 9475 2023-11-13 22:30:00Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+Admonition directives.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+from docutils.parsers.rst import Directive
+from docutils.parsers.rst import directives
+from docutils.parsers.rst.roles import set_classes
+from docutils import nodes
+
+
+class BaseAdmonition(Directive):
+
+    final_argument_whitespace = True
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+    has_content = True
+
+    node_class = None
+    """Subclasses must set this to the appropriate admonition node class."""
+
+    def run(self):
+        set_classes(self.options)
+        self.assert_has_content()
+        text = '\n'.join(self.content)
+        admonition_node = self.node_class(text, **self.options)
+        self.add_name(admonition_node)
+        admonition_node.source, admonition_node.line = \
+            self.state_machine.get_source_and_line(self.lineno)
+        if self.node_class is nodes.admonition:
+            title_text = self.arguments[0]
+            textnodes, messages = self.state.inline_text(title_text,
+                                                         self.lineno)
+            title = nodes.title(title_text, '', *textnodes)
+            title.source, title.line = (
+                    self.state_machine.get_source_and_line(self.lineno))
+            admonition_node += title
+            admonition_node += messages
+            if 'classes' not in self.options:
+                admonition_node['classes'] += ['admonition-'
+                                               + nodes.make_id(title_text)]
+        self.state.nested_parse(self.content, self.content_offset,
+                                admonition_node)
+        return [admonition_node]
+
+
+class Admonition(BaseAdmonition):
+
+    required_arguments = 1
+    node_class = nodes.admonition
+
+
+class Attention(BaseAdmonition):
+
+    node_class = nodes.attention
+
+
+class Caution(BaseAdmonition):
+
+    node_class = nodes.caution
+
+
+class Danger(BaseAdmonition):
+
+    node_class = nodes.danger
+
+
+class Error(BaseAdmonition):
+
+    node_class = nodes.error
+
+
+class Hint(BaseAdmonition):
+
+    node_class = nodes.hint
+
+
+class Important(BaseAdmonition):
+
+    node_class = nodes.important
+
+
+class Note(BaseAdmonition):
+
+    node_class = nodes.note
+
+
+class Tip(BaseAdmonition):
+
+    node_class = nodes.tip
+
+
+class Warning(BaseAdmonition):
+
+    node_class = nodes.warning
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/body.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/body.py
new file mode 100644
index 00000000..5cb90416
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/body.py
@@ -0,0 +1,305 @@
+# $Id: body.py 9500 2023-12-14 22:38:49Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+Directives for additional body elements.
+
+See `docutils.parsers.rst.directives` for API details.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+from docutils import nodes
+from docutils.parsers.rst import Directive
+from docutils.parsers.rst import directives
+from docutils.parsers.rst.roles import set_classes
+from docutils.utils.code_analyzer import Lexer, LexerError, NumberLines
+
+
+class BasePseudoSection(Directive):
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+    has_content = True
+
+    node_class = None
+    """Node class to be used (must be set in subclasses)."""
+
+    def run(self):
+        if not (self.state_machine.match_titles
+                or isinstance(self.state_machine.node, nodes.sidebar)):
+            raise self.error('The "%s" directive may not be used within '
+                             'topics or body elements.' % self.name)
+        self.assert_has_content()
+        if self.arguments:  # title (in sidebars optional)
+            title_text = self.arguments[0]
+            textnodes, messages = self.state.inline_text(
+                                      title_text, self.lineno)
+            titles = [nodes.title(title_text, '', *textnodes)]
+            # Sidebar uses this code.
+            if 'subtitle' in self.options:
+                textnodes, more_messages = self.state.inline_text(
+                    self.options['subtitle'], self.lineno)
+                titles.append(nodes.subtitle(self.options['subtitle'], '',
+                                             *textnodes))
+                messages.extend(more_messages)
+        else:
+            titles = []
+            messages = []
+        text = '\n'.join(self.content)
+        node = self.node_class(text, *(titles + messages))
+        node['classes'] += self.options.get('class', [])
+        self.add_name(node)
+        if text:
+            self.state.nested_parse(self.content, self.content_offset, node)
+        return [node]
+
+
+class Topic(BasePseudoSection):
+
+    node_class = nodes.topic
+
+
+class Sidebar(BasePseudoSection):
+
+    node_class = nodes.sidebar
+
+    required_arguments = 0
+    optional_arguments = 1
+    option_spec = BasePseudoSection.option_spec.copy()
+    option_spec['subtitle'] = directives.unchanged_required
+
+    def run(self):
+        if isinstance(self.state_machine.node, nodes.sidebar):
+            raise self.error('The "%s" directive may not be used within a '
+                             'sidebar element.' % self.name)
+        if 'subtitle' in self.options and not self.arguments:
+            raise self.error('The "subtitle" option may not be used '
+                             'without a title.')
+
+        return BasePseudoSection.run(self)
+
+
+class LineBlock(Directive):
+
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+    has_content = True
+
+    def run(self):
+        self.assert_has_content()
+        block = nodes.line_block(classes=self.options.get('class', []))
+        self.add_name(block)
+        node_list = [block]
+        for line_text in self.content:
+            text_nodes, messages = self.state.inline_text(
+                line_text.strip(), self.lineno + self.content_offset)
+            line = nodes.line(line_text, '', *text_nodes)
+            if line_text.strip():
+                line.indent = len(line_text) - len(line_text.lstrip())
+            block += line
+            node_list.extend(messages)
+            self.content_offset += 1
+        self.state.nest_line_block_lines(block)
+        return node_list
+
+
+class ParsedLiteral(Directive):
+
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+    has_content = True
+
+    def run(self):
+        set_classes(self.options)
+        self.assert_has_content()
+        text = '\n'.join(self.content)
+        text_nodes, messages = self.state.inline_text(text, self.lineno)
+        node = nodes.literal_block(text, '', *text_nodes, **self.options)
+        node.line = self.content_offset + 1
+        self.add_name(node)
+        return [node] + messages
+
+
+class CodeBlock(Directive):
+    """Parse and mark up content of a code block.
+
+    Configuration setting: syntax_highlight
+       Highlight Code content with Pygments?
+       Possible values: ('long', 'short', 'none')
+
+    """
+    optional_arguments = 1
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged,
+                   'number-lines': directives.unchanged  # integer or None
+                   }
+    has_content = True
+
+    def run(self):
+        self.assert_has_content()
+        if self.arguments:
+            language = self.arguments[0]
+        else:
+            language = ''
+        set_classes(self.options)
+        classes = ['code']
+        if language:
+            classes.append(language)
+        if 'classes' in self.options:
+            classes.extend(self.options['classes'])
+
+        # set up lexical analyzer
+        try:
+            tokens = Lexer('\n'.join(self.content), language,
+                           self.state.document.settings.syntax_highlight)
+        except LexerError as error:
+            if self.state.document.settings.report_level > 2:
+                # don't report warnings -> insert without syntax highlight
+                tokens = Lexer('\n'.join(self.content), language, 'none')
+            else:
+                raise self.warning(error)
+
+        if 'number-lines' in self.options:
+            # optional argument `startline`, defaults to 1
+            try:
+                startline = int(self.options['number-lines'] or 1)
+            except ValueError:
+                raise self.error(':number-lines: with non-integer start value')
+            endline = startline + len(self.content)
+            # add linenumber filter:
+            tokens = NumberLines(tokens, startline, endline)
+
+        node = nodes.literal_block('\n'.join(self.content), classes=classes)
+        self.add_name(node)
+        # if called from "include", set the source
+        if 'source' in self.options:
+            node.attributes['source'] = self.options['source']
+        # analyze content and add nodes for every token
+        for classes, value in tokens:
+            if classes:
+                node += nodes.inline(value, value, classes=classes)
+            else:
+                # insert as Text to decrease the verbosity of the output
+                node += nodes.Text(value)
+
+        return [node]
+
+
+class MathBlock(Directive):
+
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged,
+                   # TODO: Add Sphinx' ``mathbase.py`` option 'nowrap'?
+                   # 'nowrap': directives.flag,
+                   }
+    has_content = True
+
+    def run(self):
+        set_classes(self.options)
+        self.assert_has_content()
+        # join lines, separate blocks
+        content = '\n'.join(self.content).split('\n\n')
+        _nodes = []
+        for block in content:
+            if not block:
+                continue
+            node = nodes.math_block(self.block_text, block, **self.options)
+            (node.source,
+             node.line) = self.state_machine.get_source_and_line(self.lineno)
+            self.add_name(node)
+            _nodes.append(node)
+        return _nodes
+
+
+class Rubric(Directive):
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+
+    def run(self):
+        set_classes(self.options)
+        rubric_text = self.arguments[0]
+        textnodes, messages = self.state.inline_text(rubric_text, self.lineno)
+        rubric = nodes.rubric(rubric_text, '', *textnodes, **self.options)
+        self.add_name(rubric)
+        return [rubric] + messages
+
+
+class BlockQuote(Directive):
+
+    has_content = True
+    classes = []
+
+    def run(self):
+        self.assert_has_content()
+        elements = self.state.block_quote(self.content, self.content_offset)
+        for element in elements:
+            if isinstance(element, nodes.block_quote):
+                element['classes'] += self.classes
+        return elements
+
+
+class Epigraph(BlockQuote):
+
+    classes = ['epigraph']
+
+
+class Highlights(BlockQuote):
+
+    classes = ['highlights']
+
+
+class PullQuote(BlockQuote):
+
+    classes = ['pull-quote']
+
+
+class Compound(Directive):
+
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+    has_content = True
+
+    def run(self):
+        self.assert_has_content()
+        text = '\n'.join(self.content)
+        node = nodes.compound(text)
+        node['classes'] += self.options.get('class', [])
+        self.add_name(node)
+        self.state.nested_parse(self.content, self.content_offset, node)
+        return [node]
+
+
+class Container(Directive):
+
+    optional_arguments = 1
+    final_argument_whitespace = True
+    option_spec = {'name': directives.unchanged}
+    has_content = True
+
+    def run(self):
+        self.assert_has_content()
+        text = '\n'.join(self.content)
+        try:
+            if self.arguments:
+                classes = directives.class_option(self.arguments[0])
+            else:
+                classes = []
+        except ValueError:
+            raise self.error(
+                'Invalid class attribute value for "%s" directive: "%s".'
+                % (self.name, self.arguments[0]))
+        node = nodes.container(text)
+        node['classes'].extend(classes)
+        self.add_name(node)
+        self.state.nested_parse(self.content, self.content_offset, node)
+        return [node]
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/html.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/html.py
new file mode 100644
index 00000000..c22a26f2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/html.py
@@ -0,0 +1,21 @@
+# $Id: html.py 9062 2022-05-30 21:09:09Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+Dummy module for backwards compatibility.
+
+This module is provisional: it will be removed in Docutils 2.0.
+"""
+
+__docformat__ = 'reStructuredText'
+
+import warnings
+
+from docutils.parsers.rst.directives.misc import MetaBody, Meta  # noqa: F401
+
+warnings.warn('The `docutils.parsers.rst.directive.html` module'
+              ' will be removed in Docutils 2.0.'
+              ' Since Docutils 0.18, the "Meta" node is defined in'
+              ' `docutils.parsers.rst.directives.misc`.',
+              DeprecationWarning, stacklevel=2)
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/images.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/images.py
new file mode 100644
index 00000000..bcde3a39
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/images.py
@@ -0,0 +1,173 @@
+# $Id: images.py 9500 2023-12-14 22:38:49Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+Directives for figures and simple images.
+"""
+
+__docformat__ = 'reStructuredText'
+
+from urllib.request import url2pathname
+
+try:  # check for the Python Imaging Library
+    import PIL.Image
+except ImportError:
+    try:  # sometimes PIL modules are put in PYTHONPATH's root
+        import Image
+        class PIL: pass  # noqa:E701  dummy wrapper
+        PIL.Image = Image
+    except ImportError:
+        PIL = None
+
+from docutils import nodes
+from docutils.nodes import fully_normalize_name, whitespace_normalize_name
+from docutils.parsers.rst import Directive
+from docutils.parsers.rst import directives, states
+from docutils.parsers.rst.roles import set_classes
+
+
+class Image(Directive):
+
+    align_h_values = ('left', 'center', 'right')
+    align_v_values = ('top', 'middle', 'bottom')
+    align_values = align_v_values + align_h_values
+    loading_values = ('embed', 'link', 'lazy')
+
+    def align(argument):
+        # This is not callable as `self.align()`.  We cannot make it a
+        # staticmethod because we're saving an unbound method in
+        # option_spec below.
+        return directives.choice(argument, Image.align_values)
+
+    def loading(argument):
+        # This is not callable as `self.loading()` (see above).
+        return directives.choice(argument, Image.loading_values)
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    option_spec = {'alt': directives.unchanged,
+                   'height': directives.length_or_unitless,
+                   'width': directives.length_or_percentage_or_unitless,
+                   'scale': directives.percentage,
+                   'align': align,
+                   'target': directives.unchanged_required,
+                   'loading': loading,
+                   'class': directives.class_option,
+                   'name': directives.unchanged}
+
+    def run(self):
+        if 'align' in self.options:
+            if isinstance(self.state, states.SubstitutionDef):
+                # Check for align_v_values.
+                if self.options['align'] not in self.align_v_values:
+                    raise self.error(
+                        'Error in "%s" directive: "%s" is not a valid value '
+                        'for the "align" option within a substitution '
+                        'definition.  Valid values for "align" are: "%s".'
+                        % (self.name, self.options['align'],
+                           '", "'.join(self.align_v_values)))
+            elif self.options['align'] not in self.align_h_values:
+                raise self.error(
+                    'Error in "%s" directive: "%s" is not a valid value for '
+                    'the "align" option.  Valid values for "align" are: "%s".'
+                    % (self.name, self.options['align'],
+                       '", "'.join(self.align_h_values)))
+        messages = []
+        reference = directives.uri(self.arguments[0])
+        self.options['uri'] = reference
+        reference_node = None
+        if 'target' in self.options:
+            block = states.escape2null(
+                self.options['target']).splitlines()
+            block = [line for line in block]
+            target_type, data = self.state.parse_target(
+                block, self.block_text, self.lineno)
+            if target_type == 'refuri':
+                reference_node = nodes.reference(refuri=data)
+            elif target_type == 'refname':
+                reference_node = nodes.reference(
+                    refname=fully_normalize_name(data),
+                    name=whitespace_normalize_name(data))
+                reference_node.indirect_reference_name = data
+                self.state.document.note_refname(reference_node)
+            else:                           # malformed target
+                messages.append(data)       # data is a system message
+            del self.options['target']
+        set_classes(self.options)
+        image_node = nodes.image(self.block_text, **self.options)
+        (image_node.source,
+         image_node.line) = self.state_machine.get_source_and_line(self.lineno)
+        self.add_name(image_node)
+        if reference_node:
+            reference_node += image_node
+            return messages + [reference_node]
+        else:
+            return messages + [image_node]
+
+
+class Figure(Image):
+
+    def align(argument):
+        return directives.choice(argument, Figure.align_h_values)
+
+    def figwidth_value(argument):
+        if argument.lower() == 'image':
+            return 'image'
+        else:
+            return directives.length_or_percentage_or_unitless(argument, 'px')
+
+    option_spec = Image.option_spec.copy()
+    option_spec['figwidth'] = figwidth_value
+    option_spec['figclass'] = directives.class_option
+    option_spec['align'] = align
+    has_content = True
+
+    def run(self):
+        figwidth = self.options.pop('figwidth', None)
+        figclasses = self.options.pop('figclass', None)
+        align = self.options.pop('align', None)
+        (image_node,) = Image.run(self)
+        if isinstance(image_node, nodes.system_message):
+            return [image_node]
+        figure_node = nodes.figure('', image_node)
+        (figure_node.source, figure_node.line
+         ) = self.state_machine.get_source_and_line(self.lineno)
+        if figwidth == 'image':
+            if PIL and self.state.document.settings.file_insertion_enabled:
+                imagepath = url2pathname(image_node['uri'])
+                try:
+                    with PIL.Image.open(imagepath) as img:
+                        figure_node['width'] = '%dpx' % img.size[0]
+                except (OSError, UnicodeEncodeError):
+                    pass  # TODO: warn/info?
+                else:
+                    self.state.document.settings.record_dependencies.add(
+                        imagepath.replace('\\', '/'))
+        elif figwidth is not None:
+            figure_node['width'] = figwidth
+        if figclasses:
+            figure_node['classes'] += figclasses
+        if align:
+            figure_node['align'] = align
+        if self.content:
+            node = nodes.Element()          # anonymous container for parsing
+            self.state.nested_parse(self.content, self.content_offset, node)
+            first_node = node[0]
+            if isinstance(first_node, nodes.paragraph):
+                caption = nodes.caption(first_node.rawsource, '',
+                                        *first_node.children)
+                caption.source = first_node.source
+                caption.line = first_node.line
+                figure_node += caption
+            elif not (isinstance(first_node, nodes.comment)
+                      and len(first_node) == 0):
+                error = self.reporter.error(
+                      'Figure caption must be a paragraph or empty comment.',
+                      nodes.literal_block(self.block_text, self.block_text),
+                      line=self.lineno)
+                return [figure_node, error]
+            if len(node) > 1:
+                figure_node += nodes.legend('', *node[1:])
+        return [figure_node]
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/misc.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/misc.py
new file mode 100644
index 00000000..c16e9430
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/misc.py
@@ -0,0 +1,642 @@
+# $Id: misc.py 9492 2023-11-29 16:58:13Z milde $
+# Authors: David Goodger <goodger@python.org>; Dethe Elza
+# Copyright: This module has been placed in the public domain.
+
+"""Miscellaneous directives."""
+
+__docformat__ = 'reStructuredText'
+
+from pathlib import Path
+import re
+import time
+from urllib.request import urlopen
+from urllib.error import URLError
+
+from docutils import io, nodes, statemachine, utils
+from docutils.parsers.rst import Directive, convert_directive_function
+from docutils.parsers.rst import directives, roles, states
+from docutils.parsers.rst.directives.body import CodeBlock, NumberLines
+from docutils.transforms import misc
+
+
+def adapt_path(path, source='', root_prefix='/'):
+    # Adapt path to files to include or embed.
+    # `root_prefix` is prepended to absolute paths (cf. root_prefix setting),
+    # `source` is the `current_source` of the including directive (which may
+    # be a file included by the main document).
+    if path.startswith('/'):
+        base = Path(root_prefix)
+        path = path[1:]
+    else:
+        base = Path(source).parent
+    # pepend "base" and convert to relative path for shorter system messages
+    return utils.relative_path(None, base/path)
+
+
+class Include(Directive):
+
+    """
+    Include content read from a separate source file.
+
+    Content may be parsed by the parser, or included as a literal
+    block.  The encoding of the included file can be specified.  Only
+    a part of the given file argument may be included by specifying
+    start and end line or text to match before and/or after the text
+    to be used.
+
+    https://docutils.sourceforge.io/docs/ref/rst/directives.html#including-an-external-document-fragment
+    """
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    option_spec = {'literal': directives.flag,
+                   'code': directives.unchanged,
+                   'encoding': directives.encoding,
+                   'parser': directives.parser_name,
+                   'tab-width': int,
+                   'start-line': int,
+                   'end-line': int,
+                   'start-after': directives.unchanged_required,
+                   'end-before': directives.unchanged_required,
+                   # ignored except for 'literal' or 'code':
+                   'number-lines': directives.unchanged,  # integer or None
+                   'class': directives.class_option,
+                   'name': directives.unchanged}
+
+    standard_include_path = Path(states.__file__).parent / 'include'
+
+    def run(self):
+        """Include a file as part of the content of this reST file.
+
+        Depending on the options, the file (or a clipping) is
+        converted to nodes and returned or inserted into the input stream.
+        """
+        settings = self.state.document.settings
+        if not settings.file_insertion_enabled:
+            raise self.warning('"%s" directive disabled.' % self.name)
+        tab_width = self.options.get('tab-width', settings.tab_width)
+        current_source = self.state.document.current_source
+        path = directives.path(self.arguments[0])
+        if path.startswith('<') and path.endswith('>'):
+            path = '/' + path[1:-1]
+            root_prefix = self.standard_include_path
+        else:
+            root_prefix = settings.root_prefix
+        path = adapt_path(path, current_source, root_prefix)
+        encoding = self.options.get('encoding', settings.input_encoding)
+        error_handler = settings.input_encoding_error_handler
+        try:
+            include_file = io.FileInput(source_path=path,
+                                        encoding=encoding,
+                                        error_handler=error_handler)
+        except UnicodeEncodeError:
+            raise self.severe(f'Problems with "{self.name}" directive path:\n'
+                              f'Cannot encode input file path "{path}" '
+                              '(wrong locale?).')
+        except OSError as error:
+            raise self.severe(f'Problems with "{self.name}" directive '
+                              f'path:\n{io.error_string(error)}.')
+        else:
+            settings.record_dependencies.add(path)
+
+        # Get to-be-included content
+        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(f'Problem with "{self.name}" directive:\n'
+                              + io.error_string(error))
+        # start-after/end-before: no restrictions on newlines in match-text,
+        # and no restrictions on matching inside lines vs. line boundaries
+        after_text = self.options.get('start-after', None)
+        if after_text:
+            # skip content in rawtext before *and incl.* a matching text
+            after_index = rawtext.find(after_text)
+            if after_index < 0:
+                raise self.severe('Problem with "start-after" option of "%s" '
+                                  'directive:\nText not found.' % self.name)
+            rawtext = rawtext[after_index + len(after_text):]
+        before_text = self.options.get('end-before', None)
+        if before_text:
+            # skip content in rawtext after *and incl.* a matching text
+            before_index = rawtext.find(before_text)
+            if before_index < 0:
+                raise self.severe('Problem with "end-before" option of "%s" '
+                                  'directive:\nText not found.' % self.name)
+            rawtext = rawtext[:before_index]
+
+        include_lines = statemachine.string2lines(rawtext, tab_width,
+                                                  convert_whitespace=True)
+        for i, line in enumerate(include_lines):
+            if len(line) > settings.line_length_limit:
+                raise self.warning('"%s": line %d exceeds the'
+                                   ' line-length-limit.' % (path, i+1))
+
+        if 'literal' in self.options:
+            # Don't convert tabs to spaces, if `tab_width` is negative.
+            if tab_width >= 0:
+                text = rawtext.expandtabs(tab_width)
+            else:
+                text = rawtext
+            literal_block = nodes.literal_block(
+                                rawtext, source=path,
+                                classes=self.options.get('class', []))
+            literal_block.line = 1
+            self.add_name(literal_block)
+            if 'number-lines' in self.options:
+                try:
+                    startline = int(self.options['number-lines'] or 1)
+                except ValueError:
+                    raise self.error(':number-lines: with non-integer '
+                                     'start value')
+                endline = startline + len(include_lines)
+                if text.endswith('\n'):
+                    text = text[:-1]
+                tokens = NumberLines([([], text)], startline, endline)
+                for classes, value in tokens:
+                    if classes:
+                        literal_block += nodes.inline(value, value,
+                                                      classes=classes)
+                    else:
+                        literal_block += nodes.Text(value)
+            else:
+                literal_block += nodes.Text(text)
+            return [literal_block]
+
+        if 'code' in self.options:
+            self.options['source'] = path
+            # Don't convert tabs to spaces, if `tab_width` is negative:
+            if tab_width < 0:
+                include_lines = rawtext.splitlines()
+            codeblock = CodeBlock(self.name,
+                                  [self.options.pop('code')],  # arguments
+                                  self.options,
+                                  include_lines,  # content
+                                  self.lineno,
+                                  self.content_offset,
+                                  self.block_text,
+                                  self.state,
+                                  self.state_machine)
+            return codeblock.run()
+
+        # Prevent circular inclusion:
+        clip_options = (startline, endline, before_text, after_text)
+        include_log = self.state.document.include_log
+        # log entries are tuples (<source>, <clip-options>)
+        if not include_log:  # new document, initialize with document source
+            include_log.append((utils.relative_path(None, current_source),
+                                (None, None, None, None)))
+        if (path, clip_options) in include_log:
+            master_paths = (pth for (pth, opt) in reversed(include_log))
+            inclusion_chain = '\n> '.join((path, *master_paths))
+            raise self.warning('circular inclusion in "%s" directive:\n%s'
+                               % (self.name, inclusion_chain))
+
+        if 'parser' in self.options:
+            # parse into a dummy document and return created nodes
+            document = utils.new_document(path, settings)
+            document.include_log = include_log + [(path, clip_options)]
+            parser = self.options['parser']()
+            parser.parse('\n'.join(include_lines), document)
+            # clean up doctree and complete parsing
+            document.transformer.populate_from_components((parser,))
+            document.transformer.apply_transforms()
+            return document.children
+
+        # Include as rST source:
+        #
+        # mark end (cf. parsers.rst.states.Body.comment())
+        include_lines += ['', '.. end of inclusion from "%s"' % path]
+        self.state_machine.insert_input(include_lines, path)
+        # update include-log
+        include_log.append((path, clip_options))
+        return []
+
+
+class Raw(Directive):
+
+    """
+    Pass through content unchanged
+
+    Content is included in output based on type argument
+
+    Content may be included inline (content section of directive) or
+    imported from a file or url.
+    """
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    option_spec = {'file': directives.path,
+                   'url': directives.uri,
+                   'encoding': directives.encoding,
+                   'class': directives.class_option}
+    has_content = True
+
+    def run(self):
+        settings = self.state.document.settings
+        if (not settings.raw_enabled
+            or (not settings.file_insertion_enabled
+                and ('file' in self.options or 'url' in self.options))):
+            raise self.warning('"%s" directive disabled.' % self.name)
+        attributes = {'format': ' '.join(self.arguments[0].lower().split())}
+        encoding = self.options.get('encoding', settings.input_encoding)
+        error_handler = settings.input_encoding_error_handler
+        if self.content:
+            if 'file' in self.options or 'url' in self.options:
+                raise self.error(
+                    '"%s" directive may not both specify an external file '
+                    'and have content.' % self.name)
+            text = '\n'.join(self.content)
+        elif 'file' in self.options:
+            if 'url' in self.options:
+                raise self.error(
+                    'The "file" and "url" options may not be simultaneously '
+                    'specified for the "%s" directive.' % self.name)
+            path = adapt_path(self.options['file'],
+                              self.state.document.current_source,
+                              settings.root_prefix)
+            try:
+                raw_file = io.FileInput(source_path=path,
+                                        encoding=encoding,
+                                        error_handler=error_handler)
+            except OSError as error:
+                raise self.severe(f'Problems with "{self.name}" directive '
+                                  f'path:\n{io.error_string(error)}.')
+            else:
+                # TODO: currently, raw input files are recorded as
+                # dependencies even if not used for the chosen output format.
+                settings.record_dependencies.add(path)
+            try:
+                text = raw_file.read()
+            except UnicodeError as error:
+                raise self.severe(f'Problem with "{self.name}" directive:\n'
+                                  + io.error_string(error))
+            attributes['source'] = path
+        elif 'url' in self.options:
+            source = self.options['url']
+            try:
+                raw_text = urlopen(source).read()
+            except (URLError, OSError) as error:
+                raise self.severe(f'Problems with "{self.name}" directive URL '
+                                  f'"{self.options["url"]}":\n'
+                                  f'{io.error_string(error)}.')
+            raw_file = io.StringInput(source=raw_text, source_path=source,
+                                      encoding=encoding,
+                                      error_handler=error_handler)
+            try:
+                text = raw_file.read()
+            except UnicodeError as error:
+                raise self.severe(f'Problem with "{self.name}" directive:\n'
+                                  + io.error_string(error))
+            attributes['source'] = source
+        else:
+            # This will always fail because there is no content.
+            self.assert_has_content()
+        raw_node = nodes.raw('', text, classes=self.options.get('class', []),
+                             **attributes)
+        (raw_node.source,
+         raw_node.line) = self.state_machine.get_source_and_line(self.lineno)
+        return [raw_node]
+
+
+class Replace(Directive):
+
+    has_content = True
+
+    def run(self):
+        if not isinstance(self.state, states.SubstitutionDef):
+            raise self.error(
+                'Invalid context: the "%s" directive can only be used within '
+                'a substitution definition.' % self.name)
+        self.assert_has_content()
+        text = '\n'.join(self.content)
+        element = nodes.Element(text)
+        self.state.nested_parse(self.content, self.content_offset,
+                                element)
+        # element might contain [paragraph] + system_message(s)
+        node = None
+        messages = []
+        for elem in element:
+            if not node and isinstance(elem, nodes.paragraph):
+                node = elem
+            elif isinstance(elem, nodes.system_message):
+                elem['backrefs'] = []
+                messages.append(elem)
+            else:
+                return [
+                    self.reporter.error(
+                        f'Error in "{self.name}" directive: may contain '
+                        'a single paragraph only.', line=self.lineno)]
+        if node:
+            return messages + node.children
+        return messages
+
+
+class Unicode(Directive):
+
+    r"""
+    Convert Unicode character codes (numbers) to characters.  Codes may be
+    decimal numbers, hexadecimal numbers (prefixed by ``0x``, ``x``, ``\x``,
+    ``U+``, ``u``, or ``\u``; e.g. ``U+262E``), or XML-style numeric character
+    entities (e.g. ``&#x262E;``).  Text following ".." is a comment and is
+    ignored.  Spaces are ignored, and any other text remains as-is.
+    """
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    option_spec = {'trim': directives.flag,
+                   'ltrim': directives.flag,
+                   'rtrim': directives.flag}
+
+    comment_pattern = re.compile(r'( |\n|^)\.\. ')
+
+    def run(self):
+        if not isinstance(self.state, states.SubstitutionDef):
+            raise self.error(
+                'Invalid context: the "%s" directive can only be used within '
+                'a substitution definition.' % self.name)
+        substitution_definition = self.state_machine.node
+        if 'trim' in self.options:
+            substitution_definition.attributes['ltrim'] = 1
+            substitution_definition.attributes['rtrim'] = 1
+        if 'ltrim' in self.options:
+            substitution_definition.attributes['ltrim'] = 1
+        if 'rtrim' in self.options:
+            substitution_definition.attributes['rtrim'] = 1
+        codes = self.comment_pattern.split(self.arguments[0])[0].split()
+        element = nodes.Element()
+        for code in codes:
+            try:
+                decoded = directives.unicode_code(code)
+            except ValueError as error:
+                raise self.error('Invalid character code: %s\n%s'
+                                 % (code, io.error_string(error)))
+            element += nodes.Text(decoded)
+        return element.children
+
+
+class Class(Directive):
+
+    """
+    Set a "class" attribute on the directive content or the next element.
+    When applied to the next element, a "pending" element is inserted, and a
+    transform does the work later.
+    """
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+    has_content = True
+
+    def run(self):
+        try:
+            class_value = directives.class_option(self.arguments[0])
+        except ValueError:
+            raise self.error(
+                'Invalid class attribute value for "%s" directive: "%s".'
+                % (self.name, self.arguments[0]))
+        node_list = []
+        if self.content:
+            container = nodes.Element()
+            self.state.nested_parse(self.content, self.content_offset,
+                                    container)
+            for node in container:
+                node['classes'].extend(class_value)
+            node_list.extend(container.children)
+        else:
+            pending = nodes.pending(
+                misc.ClassAttribute,
+                {'class': class_value, 'directive': self.name},
+                self.block_text)
+            self.state_machine.document.note_pending(pending)
+            node_list.append(pending)
+        return node_list
+
+
+class Role(Directive):
+
+    has_content = True
+
+    argument_pattern = re.compile(r'(%s)\s*(\(\s*(%s)\s*\)\s*)?$'
+                                  % ((states.Inliner.simplename,) * 2))
+
+    def run(self):
+        """Dynamically create and register a custom interpreted text role."""
+        if self.content_offset > self.lineno or not self.content:
+            raise self.error('"%s" directive requires arguments on the first '
+                             'line.' % self.name)
+        args = self.content[0]
+        match = self.argument_pattern.match(args)
+        if not match:
+            raise self.error('"%s" directive arguments not valid role names: '
+                             '"%s".' % (self.name, args))
+        new_role_name = match.group(1)
+        base_role_name = match.group(3)
+        messages = []
+        if base_role_name:
+            base_role, messages = roles.role(
+                base_role_name, self.state_machine.language, self.lineno,
+                self.state.reporter)
+            if base_role is None:
+                error = self.state.reporter.error(
+                    'Unknown interpreted text role "%s".' % base_role_name,
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                return messages + [error]
+        else:
+            base_role = roles.generic_custom_role
+        assert not hasattr(base_role, 'arguments'), (
+            'Supplemental directive arguments for "%s" directive not '
+            'supported (specified by "%r" role).' % (self.name, base_role))
+        try:
+            converted_role = convert_directive_function(base_role)
+            (arguments, options, content, content_offset
+             ) = self.state.parse_directive_block(
+                    self.content[1:], self.content_offset,
+                    converted_role, option_presets={})
+        except states.MarkupError as detail:
+            error = self.reporter.error(
+                'Error in "%s" directive:\n%s.' % (self.name, detail),
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            return messages + [error]
+        if 'class' not in options:
+            try:
+                options['class'] = directives.class_option(new_role_name)
+            except ValueError as detail:
+                error = self.reporter.error(
+                    'Invalid argument for "%s" directive:\n%s.'
+                    % (self.name, detail),
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                return messages + [error]
+        role = roles.CustomRole(new_role_name, base_role, options, content)
+        roles.register_local_role(new_role_name, role)
+        return messages
+
+
+class DefaultRole(Directive):
+
+    """Set the default interpreted text role."""
+
+    optional_arguments = 1
+    final_argument_whitespace = False
+
+    def run(self):
+        if not self.arguments:
+            if '' in roles._roles:
+                # restore the "default" default role
+                del roles._roles['']
+            return []
+        role_name = self.arguments[0]
+        role, messages = roles.role(role_name, self.state_machine.language,
+                                    self.lineno, self.state.reporter)
+        if role is None:
+            error = self.state.reporter.error(
+                'Unknown interpreted text role "%s".' % role_name,
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            return messages + [error]
+        roles._roles[''] = role
+        return messages
+
+
+class Title(Directive):
+
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+
+    def run(self):
+        self.state_machine.document['title'] = self.arguments[0]
+        return []
+
+
+class MetaBody(states.SpecializedBody):
+
+    def field_marker(self, match, context, next_state):
+        """Meta element."""
+        node, blank_finish = self.parsemeta(match)
+        self.parent += node
+        return [], next_state, []
+
+    def parsemeta(self, match):
+        name = self.parse_field_marker(match)
+        name = nodes.unescape(utils.escape2null(name))
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end())
+        node = nodes.meta()
+        node['content'] = nodes.unescape(utils.escape2null(
+                                            ' '.join(indented)))
+        if not indented:
+            line = self.state_machine.line
+            msg = self.reporter.info(
+                  'No content for meta tag "%s".' % name,
+                  nodes.literal_block(line, line))
+            return msg, blank_finish
+        tokens = name.split()
+        try:
+            attname, val = utils.extract_name_value(tokens[0])[0]
+            node[attname.lower()] = val
+        except utils.NameValueError:
+            node['name'] = tokens[0]
+        for token in tokens[1:]:
+            try:
+                attname, val = utils.extract_name_value(token)[0]
+                node[attname.lower()] = val
+            except utils.NameValueError as detail:
+                line = self.state_machine.line
+                msg = self.reporter.error(
+                      'Error parsing meta tag attribute "%s": %s.'
+                      % (token, detail), nodes.literal_block(line, line))
+                return msg, blank_finish
+        return node, blank_finish
+
+
+class Meta(Directive):
+
+    has_content = True
+
+    SMkwargs = {'state_classes': (MetaBody,)}
+
+    def run(self):
+        self.assert_has_content()
+        node = nodes.Element()
+        new_line_offset, blank_finish = self.state.nested_list_parse(
+            self.content, self.content_offset, node,
+            initial_state='MetaBody', blank_finish=True,
+            state_machine_kwargs=self.SMkwargs)
+        if (new_line_offset - self.content_offset) != len(self.content):
+            # incomplete parse of block?
+            error = self.reporter.error(
+                'Invalid meta directive.',
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            node += error
+        # insert at begin of document
+        index = self.state.document.first_child_not_matching_class(
+                                        (nodes.Titular, nodes.meta)) or 0
+        self.state.document[index:index] = node.children
+        return []
+
+
+class Date(Directive):
+
+    has_content = True
+
+    def run(self):
+        if not isinstance(self.state, states.SubstitutionDef):
+            raise self.error(
+                'Invalid context: the "%s" directive can only be used within '
+                'a substitution definition.' % self.name)
+        format_str = '\n'.join(self.content) or '%Y-%m-%d'
+        # @@@
+        # Use timestamp from the `SOURCE_DATE_EPOCH`_ environment variable?
+        # Pro: Docutils-generated documentation
+        #      can easily be part of `reproducible software builds`__
+        #
+        #      __ https://reproducible-builds.org/
+        #
+        # Con: Changes the specs, hard to predict behaviour,
+        #
+        # See also the discussion about \date \time \year in TeX
+        # http://tug.org/pipermail/tex-k/2016-May/002704.html
+        # source_date_epoch = os.environ.get('SOURCE_DATE_EPOCH')
+        # if (source_date_epoch):
+        #     text = time.strftime(format_str,
+        #                          time.gmtime(int(source_date_epoch)))
+        # else:
+        text = time.strftime(format_str)
+        return [nodes.Text(text)]
+
+
+class TestDirective(Directive):
+
+    """This directive is useful only for testing purposes."""
+
+    optional_arguments = 1
+    final_argument_whitespace = True
+    option_spec = {'option': directives.unchanged_required}
+    has_content = True
+
+    def run(self):
+        if self.content:
+            text = '\n'.join(self.content)
+            info = self.reporter.info(
+                'Directive processed. Type="%s", arguments=%r, options=%r, '
+                'content:' % (self.name, self.arguments, self.options),
+                nodes.literal_block(text, text), line=self.lineno)
+        else:
+            info = self.reporter.info(
+                'Directive processed. Type="%s", arguments=%r, options=%r, '
+                'content: None' % (self.name, self.arguments, self.options),
+                line=self.lineno)
+        return [info]
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/parts.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/parts.py
new file mode 100644
index 00000000..adb01d03
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/parts.py
@@ -0,0 +1,126 @@
+# $Id: parts.py 8993 2022-01-29 13:20:04Z milde $
+# Authors: David Goodger <goodger@python.org>; Dmitry Jemerov
+# Copyright: This module has been placed in the public domain.
+
+"""
+Directives for document parts.
+"""
+
+__docformat__ = 'reStructuredText'
+
+from docutils import nodes, languages
+from docutils.transforms import parts
+from docutils.parsers.rst import Directive
+from docutils.parsers.rst import directives
+
+
+class Contents(Directive):
+
+    """
+    Table of contents.
+
+    The table of contents is generated in two passes: initial parse and
+    transform.  During the initial parse, a 'pending' element is generated
+    which acts as a placeholder, storing the TOC title and any options
+    internally.  At a later stage in the processing, the 'pending' element is
+    replaced by a 'topic' element, a title and the table of contents proper.
+    """
+
+    backlinks_values = ('top', 'entry', 'none')
+
+    def backlinks(arg):
+        value = directives.choice(arg, Contents.backlinks_values)
+        if value == 'none':
+            return None
+        else:
+            return value
+
+    optional_arguments = 1
+    final_argument_whitespace = True
+    option_spec = {'depth': directives.nonnegative_int,
+                   'local': directives.flag,
+                   'backlinks': backlinks,
+                   'class': directives.class_option}
+
+    def run(self):
+        if not (self.state_machine.match_titles
+                or isinstance(self.state_machine.node, nodes.sidebar)):
+            raise self.error('The "%s" directive may not be used within '
+                             'topics or body elements.' % self.name)
+        document = self.state_machine.document
+        language = languages.get_language(document.settings.language_code,
+                                          document.reporter)
+        if self.arguments:
+            title_text = self.arguments[0]
+            text_nodes, messages = self.state.inline_text(title_text,
+                                                          self.lineno)
+            title = nodes.title(title_text, '', *text_nodes)
+        else:
+            messages = []
+            if 'local' in self.options:
+                title = None
+            else:
+                title = nodes.title('', language.labels['contents'])
+        topic = nodes.topic(classes=['contents'])
+        topic['classes'] += self.options.get('class', [])
+        # the latex2e writer needs source and line for a warning:
+        topic.source, topic.line = self.state_machine.get_source_and_line()
+        topic.line -= 1
+        if 'local' in self.options:
+            topic['classes'].append('local')
+        if title:
+            name = title.astext()
+            topic += title
+        else:
+            name = language.labels['contents']
+        name = nodes.fully_normalize_name(name)
+        if not document.has_name(name):
+            topic['names'].append(name)
+        document.note_implicit_target(topic)
+        pending = nodes.pending(parts.Contents, rawsource=self.block_text)
+        pending.details.update(self.options)
+        document.note_pending(pending)
+        topic += pending
+        return [topic] + messages
+
+
+class Sectnum(Directive):
+
+    """Automatic section numbering."""
+
+    option_spec = {'depth': int,
+                   'start': int,
+                   'prefix': directives.unchanged_required,
+                   'suffix': directives.unchanged_required}
+
+    def run(self):
+        pending = nodes.pending(parts.SectNum)
+        pending.details.update(self.options)
+        self.state_machine.document.note_pending(pending)
+        return [pending]
+
+
+class Header(Directive):
+
+    """Contents of document header."""
+
+    has_content = True
+
+    def run(self):
+        self.assert_has_content()
+        header = self.state_machine.document.get_decoration().get_header()
+        self.state.nested_parse(self.content, self.content_offset, header)
+        return []
+
+
+class Footer(Directive):
+
+    """Contents of document footer."""
+
+    has_content = True
+
+    def run(self):
+        self.assert_has_content()
+        footer = self.state_machine.document.get_decoration().get_footer()
+        self.state.nested_parse(self.content, self.content_offset, footer)
+        return []
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/references.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/references.py
new file mode 100644
index 00000000..96921f9d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/references.py
@@ -0,0 +1,29 @@
+# $Id: references.py 7062 2011-06-30 22:14:29Z milde $
+# Authors: David Goodger <goodger@python.org>; Dmitry Jemerov
+# Copyright: This module has been placed in the public domain.
+
+"""
+Directives for references and targets.
+"""
+
+__docformat__ = 'reStructuredText'
+
+from docutils import nodes
+from docutils.transforms import references
+from docutils.parsers.rst import Directive
+from docutils.parsers.rst import directives
+
+
+class TargetNotes(Directive):
+
+    """Target footnote generation."""
+
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged}
+
+    def run(self):
+        pending = nodes.pending(references.TargetNotes)
+        self.add_name(pending)
+        pending.details.update(self.options)
+        self.state_machine.document.note_pending(pending)
+        return [pending]
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/tables.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/tables.py
new file mode 100644
index 00000000..2cc266ff
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/directives/tables.py
@@ -0,0 +1,538 @@
+# $Id: tables.py 9492 2023-11-29 16:58:13Z milde $
+# Authors: David Goodger <goodger@python.org>; David Priest
+# Copyright: This module has been placed in the public domain.
+
+"""
+Directives for table elements.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+import csv
+from urllib.request import urlopen
+from urllib.error import URLError
+import warnings
+
+from docutils import nodes, statemachine
+from docutils.io import FileInput, StringInput
+from docutils.parsers.rst import Directive
+from docutils.parsers.rst import directives
+from docutils.parsers.rst.directives.misc import adapt_path
+from docutils.utils import SystemMessagePropagation
+
+
+def align(argument):
+    return directives.choice(argument, ('left', 'center', 'right'))
+
+
+class Table(Directive):
+
+    """
+    Generic table base class.
+    """
+
+    optional_arguments = 1
+    final_argument_whitespace = True
+    option_spec = {'class': directives.class_option,
+                   'name': directives.unchanged,
+                   'align': align,
+                   'width': directives.length_or_percentage_or_unitless,
+                   'widths': directives.value_or(('auto', 'grid'),
+                                                 directives.positive_int_list)}
+    has_content = True
+
+    def make_title(self):
+        if self.arguments:
+            title_text = self.arguments[0]
+            text_nodes, messages = self.state.inline_text(title_text,
+                                                          self.lineno)
+            title = nodes.title(title_text, '', *text_nodes)
+            (title.source,
+             title.line) = self.state_machine.get_source_and_line(self.lineno)
+        else:
+            title = None
+            messages = []
+        return title, messages
+
+    def check_table_dimensions(self, rows, header_rows, stub_columns):
+        if len(rows) < header_rows:
+            error = self.reporter.error('%s header row(s) specified but '
+                'only %s row(s) of data supplied ("%s" directive).'
+                % (header_rows, len(rows), self.name),
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            raise SystemMessagePropagation(error)
+        if len(rows) == header_rows > 0:
+            error = self.reporter.error(
+                f'Insufficient data supplied ({len(rows)} row(s)); '
+                'no data remaining for table body, '
+                f'required by "{self.name}" directive.',
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            raise SystemMessagePropagation(error)
+        for row in rows:
+            if len(row) < stub_columns:
+                error = self.reporter.error(
+                    f'{stub_columns} stub column(s) specified '
+                    f'but only {len(row)} columns(s) of data supplied '
+                    f'("{self.name}" directive).',
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(error)
+            if len(row) == stub_columns > 0:
+                error = self.reporter.error(
+                    'Insufficient data supplied (%s columns(s)); '
+                    'no data remaining for table body, required '
+                    'by "%s" directive.' % (len(row), self.name),
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(error)
+
+    def set_table_width(self, table_node):
+        if 'width' in self.options:
+            table_node['width'] = self.options.get('width')
+
+    @property
+    def widths(self):
+        return self.options.get('widths', '')
+
+    def get_column_widths(self, n_cols):
+        if isinstance(self.widths, list):
+            if len(self.widths) != n_cols:
+                # TODO: use last value for missing columns?
+                error = self.reporter.error('"%s" widths do not match the '
+                    'number of columns in table (%s).' % (self.name, n_cols),
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(error)
+            col_widths = self.widths
+        elif n_cols:
+            col_widths = [100 // n_cols] * n_cols
+        else:
+            error = self.reporter.error('No table data detected in CSV file.',
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            raise SystemMessagePropagation(error)
+        return col_widths
+
+    def extend_short_rows_with_empty_cells(self, columns, parts):
+        for part in parts:
+            for row in part:
+                if len(row) < columns:
+                    row.extend([(0, 0, 0, [])] * (columns - len(row)))
+
+
+class RSTTable(Table):
+    """
+    Class for the `"table" directive`__ for formal tables using rST syntax.
+
+    __ https://docutils.sourceforge.io/docs/ref/rst/directives.html
+    """
+
+    def run(self):
+        if not self.content:
+            warning = self.reporter.warning('Content block expected '
+                'for the "%s" directive; none found.' % self.name,
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            return [warning]
+        title, messages = self.make_title()
+        node = nodes.Element()          # anonymous container for parsing
+        self.state.nested_parse(self.content, self.content_offset, node)
+        if len(node) != 1 or not isinstance(node[0], nodes.table):
+            error = self.reporter.error('Error parsing content block for the '
+                '"%s" directive: exactly one table expected.' % self.name,
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            return [error]
+        table_node = node[0]
+        table_node['classes'] += self.options.get('class', [])
+        self.set_table_width(table_node)
+        if 'align' in self.options:
+            table_node['align'] = self.options.get('align')
+        if isinstance(self.widths, list):
+            tgroup = table_node[0]
+            try:
+                col_widths = self.get_column_widths(tgroup["cols"])
+            except SystemMessagePropagation as detail:
+                return [detail.args[0]]
+            colspecs = [child for child in tgroup.children
+                        if child.tagname == 'colspec']
+            for colspec, col_width in zip(colspecs, col_widths):
+                colspec['colwidth'] = col_width
+        if self.widths == 'auto':
+            table_node['classes'] += ['colwidths-auto']
+        elif self.widths:  # "grid" or list of integers
+            table_node['classes'] += ['colwidths-given']
+        self.add_name(table_node)
+        if title:
+            table_node.insert(0, title)
+        return [table_node] + messages
+
+
+class CSVTable(Table):
+
+    option_spec = {'header-rows': directives.nonnegative_int,
+                   'stub-columns': directives.nonnegative_int,
+                   'header': directives.unchanged,
+                   'width': directives.length_or_percentage_or_unitless,
+                   'widths': directives.value_or(('auto', ),
+                                                 directives.positive_int_list),
+                   'file': directives.path,
+                   'url': directives.uri,
+                   'encoding': directives.encoding,
+                   'class': directives.class_option,
+                   'name': directives.unchanged,
+                   'align': align,
+                   # field delimiter char
+                   'delim': directives.single_char_or_whitespace_or_unicode,
+                   # treat whitespace after delimiter as significant
+                   'keepspace': directives.flag,
+                   # text field quote/unquote char:
+                   'quote': directives.single_char_or_unicode,
+                   # char used to escape delim & quote as-needed:
+                   'escape': directives.single_char_or_unicode}
+
+    class DocutilsDialect(csv.Dialect):
+
+        """CSV dialect for `csv_table` directive."""
+
+        delimiter = ','
+        quotechar = '"'
+        doublequote = True
+        skipinitialspace = True
+        strict = True
+        lineterminator = '\n'
+        quoting = csv.QUOTE_MINIMAL
+
+        def __init__(self, options):
+            if 'delim' in options:
+                self.delimiter = options['delim']
+            if 'keepspace' in options:
+                self.skipinitialspace = False
+            if 'quote' in options:
+                self.quotechar = options['quote']
+            if 'escape' in options:
+                self.doublequote = False
+                self.escapechar = options['escape']
+            super().__init__()
+
+    class HeaderDialect(csv.Dialect):
+        """
+        CSV dialect used for the "header" option data.
+
+        Deprecated. Will be removed in Docutils 0.22.
+        """
+        # The separate HeaderDialect was introduced in revision 2294
+        # (2004-06-17) in the sandbox before the "csv-table" directive moved
+        # to the trunk in r2309. Discussion in docutils-devel around this time
+        # did not mention a rationale (part of the discussion was in private
+        # mail).
+        # This is in conflict with the documentation, which always said:
+        # "Must use the same CSV format as the main CSV data."
+        # and did not change in this aspect.
+        #
+        # Maybe it was intended to have similar escape rules for rST and CSV,
+        # however with the current implementation this means we need
+        # `\\` for rST markup and ``\\\\`` for a literal backslash
+        # in the "option" header but ``\`` and ``\\`` in the header-lines and
+        # table cells of the main CSV data.
+        delimiter = ','
+        quotechar = '"'
+        escapechar = '\\'
+        doublequote = False
+        skipinitialspace = True
+        strict = True
+        lineterminator = '\n'
+        quoting = csv.QUOTE_MINIMAL
+
+        def __init__(self):
+            warnings.warn('CSVTable.HeaderDialect will be removed '
+                          'in Docutils 0.22.',
+                          PendingDeprecationWarning, stacklevel=2)
+            super().__init__()
+
+    @staticmethod
+    def check_requirements():
+        warnings.warn('CSVTable.check_requirements()'
+                      ' is not required with Python 3'
+                      ' and will be removed in Docutils 0.22.',
+                      DeprecationWarning, stacklevel=2)
+
+    def process_header_option(self):
+        source = self.state_machine.get_source(self.lineno - 1)
+        table_head = []
+        max_header_cols = 0
+        if 'header' in self.options:   # separate table header in option
+            rows, max_header_cols = self.parse_csv_data_into_rows(
+                                        self.options['header'].split('\n'),
+                                        self.DocutilsDialect(self.options),
+                                        source)
+            table_head.extend(rows)
+        return table_head, max_header_cols
+
+    def run(self):
+        try:
+            if (not self.state.document.settings.file_insertion_enabled
+                and ('file' in self.options
+                     or 'url' in self.options)):
+                warning = self.reporter.warning('File and URL access '
+                    'deactivated; ignoring "%s" directive.' % self.name,
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                return [warning]
+            title, messages = self.make_title()
+            csv_data, source = self.get_csv_data()
+            table_head, max_header_cols = self.process_header_option()
+            rows, max_cols = self.parse_csv_data_into_rows(
+                csv_data, self.DocutilsDialect(self.options), source)
+            max_cols = max(max_cols, max_header_cols)
+            header_rows = self.options.get('header-rows', 0)
+            stub_columns = self.options.get('stub-columns', 0)
+            self.check_table_dimensions(rows, header_rows, stub_columns)
+            table_head.extend(rows[:header_rows])
+            table_body = rows[header_rows:]
+            col_widths = self.get_column_widths(max_cols)
+            self.extend_short_rows_with_empty_cells(max_cols,
+                                                    (table_head, table_body))
+        except SystemMessagePropagation as detail:
+            return [detail.args[0]]
+        except csv.Error as detail:
+            message = str(detail)
+            error = self.reporter.error('Error with CSV data'
+                ' in "%s" directive:\n%s' % (self.name, message),
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            return [error]
+        table = (col_widths, table_head, table_body)
+        table_node = self.state.build_table(table, self.content_offset,
+                                            stub_columns, widths=self.widths)
+        table_node['classes'] += self.options.get('class', [])
+        if 'align' in self.options:
+            table_node['align'] = self.options.get('align')
+        self.set_table_width(table_node)
+        self.add_name(table_node)
+        if title:
+            table_node.insert(0, title)
+        return [table_node] + messages
+
+    def get_csv_data(self):
+        """
+        Get CSV data from the directive content, from an external
+        file, or from a URL reference.
+        """
+        settings = self.state.document.settings
+        encoding = self.options.get('encoding', settings.input_encoding)
+        error_handler = settings.input_encoding_error_handler
+        if self.content:
+            # CSV data is from directive content.
+            if 'file' in self.options or 'url' in self.options:
+                error = self.reporter.error('"%s" directive may not both '
+                    'specify an external file and have content.' % self.name,
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(error)
+            source = self.content.source(0)
+            csv_data = self.content
+        elif 'file' in self.options:
+            # CSV data is from an external file.
+            if 'url' in self.options:
+                error = self.reporter.error('The "file" and "url" options '
+                    'may not be simultaneously specified '
+                    'for the "%s" directive.' % self.name,
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(error)
+            source = adapt_path(self.options['file'],
+                                self.state.document.current_source,
+                                settings.root_prefix)
+            try:
+                csv_file = FileInput(source_path=source,
+                                     encoding=encoding,
+                                     error_handler=error_handler)
+                csv_data = csv_file.read().splitlines()
+            except OSError as error:
+                severe = self.reporter.severe(
+                    'Problems with "%s" directive path:\n%s.'
+                    % (self.name, error),
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(severe)
+            else:
+                settings.record_dependencies.add(source)
+        elif 'url' in self.options:
+            source = self.options['url']
+            try:
+                with urlopen(source) as response:
+                    csv_text = response.read()
+            except (URLError, OSError, ValueError) as error:
+                severe = self.reporter.severe(
+                      'Problems with "%s" directive URL "%s":\n%s.'
+                      % (self.name, self.options['url'], error),
+                      nodes.literal_block(self.block_text, self.block_text),
+                      line=self.lineno)
+                raise SystemMessagePropagation(severe)
+            csv_file = StringInput(source=csv_text, source_path=source,
+                                   encoding=encoding,
+                                   error_handler=error_handler)
+            csv_data = csv_file.read().splitlines()
+        else:
+            error = self.reporter.warning(
+                'The "%s" directive requires content; none supplied.'
+                % self.name,
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            raise SystemMessagePropagation(error)
+        return csv_data, source
+
+    @staticmethod
+    def decode_from_csv(s):
+        warnings.warn('CSVTable.decode_from_csv()'
+                  ' is not required with Python 3'
+                  ' and will be removed in Docutils 0.21 or later.',
+                  DeprecationWarning, stacklevel=2)
+        return s
+
+    @staticmethod
+    def encode_for_csv(s):
+        warnings.warn('CSVTable.encode_from_csv()'
+                  ' is not required with Python 3'
+                  ' and will be removed in Docutils 0.21 or later.',
+                  DeprecationWarning, stacklevel=2)
+        return s
+
+    def parse_csv_data_into_rows(self, csv_data, dialect, source):
+        csv_reader = csv.reader((line + '\n' for line in csv_data),
+                                dialect=dialect)
+        rows = []
+        max_cols = 0
+        for row in csv_reader:
+            row_data = []
+            for cell in row:
+                cell_data = (0, 0, 0, statemachine.StringList(
+                    cell.splitlines(), source=source))
+                row_data.append(cell_data)
+            rows.append(row_data)
+            max_cols = max(max_cols, len(row))
+        return rows, max_cols
+
+
+class ListTable(Table):
+
+    """
+    Implement tables whose data is encoded as a uniform two-level bullet list.
+    For further ideas, see
+    https://docutils.sourceforge.io/docs/dev/rst/alternatives.html#list-driven-tables
+    """
+
+    option_spec = {'header-rows': directives.nonnegative_int,
+                   'stub-columns': directives.nonnegative_int,
+                   'width': directives.length_or_percentage_or_unitless,
+                   'widths': directives.value_or(('auto', ),
+                                                 directives.positive_int_list),
+                   'class': directives.class_option,
+                   'name': directives.unchanged,
+                   'align': align}
+
+    def run(self):
+        if not self.content:
+            error = self.reporter.error('The "%s" directive is empty; '
+                'content required.' % self.name,
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            return [error]
+        title, messages = self.make_title()
+        node = nodes.Element()          # anonymous container for parsing
+        self.state.nested_parse(self.content, self.content_offset, node)
+        try:
+            num_cols, col_widths = self.check_list_content(node)
+            table_data = [[item.children for item in row_list[0]]
+                          for row_list in node[0]]
+            header_rows = self.options.get('header-rows', 0)
+            stub_columns = self.options.get('stub-columns', 0)
+            self.check_table_dimensions(table_data, header_rows, stub_columns)
+        except SystemMessagePropagation as detail:
+            return [detail.args[0]]
+        table_node = self.build_table_from_list(table_data, col_widths,
+                                                header_rows, stub_columns)
+        if 'align' in self.options:
+            table_node['align'] = self.options.get('align')
+        table_node['classes'] += self.options.get('class', [])
+        self.set_table_width(table_node)
+        self.add_name(table_node)
+        if title:
+            table_node.insert(0, title)
+        return [table_node] + messages
+
+    def check_list_content(self, node):
+        if len(node) != 1 or not isinstance(node[0], nodes.bullet_list):
+            error = self.reporter.error(
+                'Error parsing content block for the "%s" directive: '
+                'exactly one bullet list expected.' % self.name,
+                nodes.literal_block(self.block_text, self.block_text),
+                line=self.lineno)
+            raise SystemMessagePropagation(error)
+        list_node = node[0]
+        num_cols = 0
+        # Check for a uniform two-level bullet list:
+        for item_index in range(len(list_node)):
+            item = list_node[item_index]
+            if len(item) != 1 or not isinstance(item[0], nodes.bullet_list):
+                error = self.reporter.error(
+                    'Error parsing content block for the "%s" directive: '
+                    'two-level bullet list expected, but row %s does not '
+                    'contain a second-level bullet list.'
+                    % (self.name, item_index + 1),
+                    nodes.literal_block(self.block_text, self.block_text),
+                    line=self.lineno)
+                raise SystemMessagePropagation(error)
+            elif item_index:
+                if len(item[0]) != num_cols:
+                    error = self.reporter.error(
+                        'Error parsing content block for the "%s" directive: '
+                        'uniform two-level bullet list expected, but row %s '
+                        'does not contain the same number of items as row 1 '
+                        '(%s vs %s).'
+                        % (self.name, item_index + 1, len(item[0]), num_cols),
+                        nodes.literal_block(self.block_text, self.block_text),
+                        line=self.lineno)
+                    raise SystemMessagePropagation(error)
+            else:
+                num_cols = len(item[0])
+        col_widths = self.get_column_widths(num_cols)
+        return num_cols, col_widths
+
+    def build_table_from_list(self, table_data,
+                              col_widths, header_rows, stub_columns):
+        table = nodes.table()
+        if self.widths == 'auto':
+            table['classes'] += ['colwidths-auto']
+        elif self.widths:  # explicitly set column widths
+            table['classes'] += ['colwidths-given']
+        tgroup = nodes.tgroup(cols=len(col_widths))
+        table += tgroup
+        for col_width in col_widths:
+            colspec = nodes.colspec()
+            if col_width is not None:
+                colspec.attributes['colwidth'] = col_width
+            if stub_columns:
+                colspec.attributes['stub'] = 1
+                stub_columns -= 1
+            tgroup += colspec
+        rows = []
+        for row in table_data:
+            row_node = nodes.row()
+            for cell in row:
+                entry = nodes.entry()
+                entry += cell
+                row_node += entry
+            rows.append(row_node)
+        if header_rows:
+            thead = nodes.thead()
+            thead.extend(rows[:header_rows])
+            tgroup += thead
+        tbody = nodes.tbody()
+        tbody.extend(rows[header_rows:])
+        tgroup += tbody
+        return table
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/README.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/README.txt
new file mode 100644
index 00000000..a51328fb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/README.txt
@@ -0,0 +1,17 @@
+============================================
+ ``docutils/parsers/rst/include`` Directory
+============================================
+
+This directory contains standard data files intended for inclusion in
+reStructuredText documents.  To access these files, use the "include"
+directive with the special syntax for standard "include" data files,
+angle brackets around the file name::
+
+    .. include:: <isonum.txt>
+
+See the documentation for the `"include" directive`__ and
+`reStructuredText Standard Definition Files`__ for
+details.
+
+__ https://docutils.sourceforge.io/docs/ref/rst/directives.html#include
+__ https://docutils.sourceforge.io/docs/ref/rst/definitions.html
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsa.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsa.txt
new file mode 100644
index 00000000..a13b1d66
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsa.txt
@@ -0,0 +1,162 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |angzarr|  unicode:: U+0237C .. RIGHT ANGLE WITH DOWNWARDS ZIGZAG ARROW
+.. |cirmid|   unicode:: U+02AEF .. VERTICAL LINE WITH CIRCLE ABOVE
+.. |cudarrl|  unicode:: U+02938 .. RIGHT-SIDE ARC CLOCKWISE ARROW
+.. |cudarrr|  unicode:: U+02935 .. ARROW POINTING RIGHTWARDS THEN CURVING DOWNWARDS
+.. |cularr|   unicode:: U+021B6 .. ANTICLOCKWISE TOP SEMICIRCLE ARROW
+.. |cularrp|  unicode:: U+0293D .. TOP ARC ANTICLOCKWISE ARROW WITH PLUS
+.. |curarr|   unicode:: U+021B7 .. CLOCKWISE TOP SEMICIRCLE ARROW
+.. |curarrm|  unicode:: U+0293C .. TOP ARC CLOCKWISE ARROW WITH MINUS
+.. |Darr|     unicode:: U+021A1 .. DOWNWARDS TWO HEADED ARROW
+.. |dArr|     unicode:: U+021D3 .. DOWNWARDS DOUBLE ARROW
+.. |darr2|    unicode:: U+021CA .. DOWNWARDS PAIRED ARROWS
+.. |ddarr|    unicode:: U+021CA .. DOWNWARDS PAIRED ARROWS
+.. |DDotrahd| unicode:: U+02911 .. RIGHTWARDS ARROW WITH DOTTED STEM
+.. |dfisht|   unicode:: U+0297F .. DOWN FISH TAIL
+.. |dHar|     unicode:: U+02965 .. DOWNWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT
+.. |dharl|    unicode:: U+021C3 .. DOWNWARDS HARPOON WITH BARB LEFTWARDS
+.. |dharr|    unicode:: U+021C2 .. DOWNWARDS HARPOON WITH BARB RIGHTWARDS
+.. |dlarr|    unicode:: U+02199 .. SOUTH WEST ARROW
+.. |drarr|    unicode:: U+02198 .. SOUTH EAST ARROW
+.. |duarr|    unicode:: U+021F5 .. DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW
+.. |duhar|    unicode:: U+0296F .. DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT
+.. |dzigrarr| unicode:: U+027FF .. LONG RIGHTWARDS SQUIGGLE ARROW
+.. |erarr|    unicode:: U+02971 .. EQUALS SIGN ABOVE RIGHTWARDS ARROW
+.. |hArr|     unicode:: U+021D4 .. LEFT RIGHT DOUBLE ARROW
+.. |harr|     unicode:: U+02194 .. LEFT RIGHT ARROW
+.. |harrcir|  unicode:: U+02948 .. LEFT RIGHT ARROW THROUGH SMALL CIRCLE
+.. |harrw|    unicode:: U+021AD .. LEFT RIGHT WAVE ARROW
+.. |hoarr|    unicode:: U+021FF .. LEFT RIGHT OPEN-HEADED ARROW
+.. |imof|     unicode:: U+022B7 .. IMAGE OF
+.. |lAarr|    unicode:: U+021DA .. LEFTWARDS TRIPLE ARROW
+.. |Larr|     unicode:: U+0219E .. LEFTWARDS TWO HEADED ARROW
+.. |larr2|    unicode:: U+021C7 .. LEFTWARDS PAIRED ARROWS
+.. |larrbfs|  unicode:: U+0291F .. LEFTWARDS ARROW FROM BAR TO BLACK DIAMOND
+.. |larrfs|   unicode:: U+0291D .. LEFTWARDS ARROW TO BLACK DIAMOND
+.. |larrhk|   unicode:: U+021A9 .. LEFTWARDS ARROW WITH HOOK
+.. |larrlp|   unicode:: U+021AB .. LEFTWARDS ARROW WITH LOOP
+.. |larrpl|   unicode:: U+02939 .. LEFT-SIDE ARC ANTICLOCKWISE ARROW
+.. |larrsim|  unicode:: U+02973 .. LEFTWARDS ARROW ABOVE TILDE OPERATOR
+.. |larrtl|   unicode:: U+021A2 .. LEFTWARDS ARROW WITH TAIL
+.. |lAtail|   unicode:: U+0291B .. LEFTWARDS DOUBLE ARROW-TAIL
+.. |latail|   unicode:: U+02919 .. LEFTWARDS ARROW-TAIL
+.. |lBarr|    unicode:: U+0290E .. LEFTWARDS TRIPLE DASH ARROW
+.. |lbarr|    unicode:: U+0290C .. LEFTWARDS DOUBLE DASH ARROW
+.. |ldca|     unicode:: U+02936 .. ARROW POINTING DOWNWARDS THEN CURVING LEFTWARDS
+.. |ldrdhar|  unicode:: U+02967 .. LEFTWARDS HARPOON WITH BARB DOWN ABOVE RIGHTWARDS HARPOON WITH BARB DOWN
+.. |ldrushar| unicode:: U+0294B .. LEFT BARB DOWN RIGHT BARB UP HARPOON
+.. |ldsh|     unicode:: U+021B2 .. DOWNWARDS ARROW WITH TIP LEFTWARDS
+.. |lfisht|   unicode:: U+0297C .. LEFT FISH TAIL
+.. |lHar|     unicode:: U+02962 .. LEFTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB DOWN
+.. |lhard|    unicode:: U+021BD .. LEFTWARDS HARPOON WITH BARB DOWNWARDS
+.. |lharu|    unicode:: U+021BC .. LEFTWARDS HARPOON WITH BARB UPWARDS
+.. |lharul|   unicode:: U+0296A .. LEFTWARDS HARPOON WITH BARB UP ABOVE LONG DASH
+.. |llarr|    unicode:: U+021C7 .. LEFTWARDS PAIRED ARROWS
+.. |llhard|   unicode:: U+0296B .. LEFTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH
+.. |loarr|    unicode:: U+021FD .. LEFTWARDS OPEN-HEADED ARROW
+.. |lrarr|    unicode:: U+021C6 .. LEFTWARDS ARROW OVER RIGHTWARDS ARROW
+.. |lrarr2|   unicode:: U+021C6 .. LEFTWARDS ARROW OVER RIGHTWARDS ARROW
+.. |lrhar|    unicode:: U+021CB .. LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
+.. |lrhar2|   unicode:: U+021CB .. LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
+.. |lrhard|   unicode:: U+0296D .. RIGHTWARDS HARPOON WITH BARB DOWN BELOW LONG DASH
+.. |lsh|      unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS
+.. |lurdshar| unicode:: U+0294A .. LEFT BARB UP RIGHT BARB DOWN HARPOON
+.. |luruhar|  unicode:: U+02966 .. LEFTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB UP
+.. |Map|      unicode:: U+02905 .. RIGHTWARDS TWO-HEADED ARROW FROM BAR
+.. |map|      unicode:: U+021A6 .. RIGHTWARDS ARROW FROM BAR
+.. |midcir|   unicode:: U+02AF0 .. VERTICAL LINE WITH CIRCLE BELOW
+.. |mumap|    unicode:: U+022B8 .. MULTIMAP
+.. |nearhk|   unicode:: U+02924 .. NORTH EAST ARROW WITH HOOK
+.. |neArr|    unicode:: U+021D7 .. NORTH EAST DOUBLE ARROW
+.. |nearr|    unicode:: U+02197 .. NORTH EAST ARROW
+.. |nesear|   unicode:: U+02928 .. NORTH EAST ARROW AND SOUTH EAST ARROW
+.. |nhArr|    unicode:: U+021CE .. LEFT RIGHT DOUBLE ARROW WITH STROKE
+.. |nharr|    unicode:: U+021AE .. LEFT RIGHT ARROW WITH STROKE
+.. |nlArr|    unicode:: U+021CD .. LEFTWARDS DOUBLE ARROW WITH STROKE
+.. |nlarr|    unicode:: U+0219A .. LEFTWARDS ARROW WITH STROKE
+.. |nrArr|    unicode:: U+021CF .. RIGHTWARDS DOUBLE ARROW WITH STROKE
+.. |nrarr|    unicode:: U+0219B .. RIGHTWARDS ARROW WITH STROKE
+.. |nrarrc|   unicode:: U+02933 U+00338 .. WAVE ARROW POINTING DIRECTLY RIGHT with slash
+.. |nrarrw|   unicode:: U+0219D U+00338 .. RIGHTWARDS WAVE ARROW with slash
+.. |nvHarr|   unicode:: U+02904 .. LEFT RIGHT DOUBLE ARROW WITH VERTICAL STROKE
+.. |nvlArr|   unicode:: U+02902 .. LEFTWARDS DOUBLE ARROW WITH VERTICAL STROKE
+.. |nvrArr|   unicode:: U+02903 .. RIGHTWARDS DOUBLE ARROW WITH VERTICAL STROKE
+.. |nwarhk|   unicode:: U+02923 .. NORTH WEST ARROW WITH HOOK
+.. |nwArr|    unicode:: U+021D6 .. NORTH WEST DOUBLE ARROW
+.. |nwarr|    unicode:: U+02196 .. NORTH WEST ARROW
+.. |nwnear|   unicode:: U+02927 .. NORTH WEST ARROW AND NORTH EAST ARROW
+.. |olarr|    unicode:: U+021BA .. ANTICLOCKWISE OPEN CIRCLE ARROW
+.. |orarr|    unicode:: U+021BB .. CLOCKWISE OPEN CIRCLE ARROW
+.. |origof|   unicode:: U+022B6 .. ORIGINAL OF
+.. |rAarr|    unicode:: U+021DB .. RIGHTWARDS TRIPLE ARROW
+.. |Rarr|     unicode:: U+021A0 .. RIGHTWARDS TWO HEADED ARROW
+.. |rarr2|    unicode:: U+021C9 .. RIGHTWARDS PAIRED ARROWS
+.. |rarrap|   unicode:: U+02975 .. RIGHTWARDS ARROW ABOVE ALMOST EQUAL TO
+.. |rarrbfs|  unicode:: U+02920 .. RIGHTWARDS ARROW FROM BAR TO BLACK DIAMOND
+.. |rarrc|    unicode:: U+02933 .. WAVE ARROW POINTING DIRECTLY RIGHT
+.. |rarrfs|   unicode:: U+0291E .. RIGHTWARDS ARROW TO BLACK DIAMOND
+.. |rarrhk|   unicode:: U+021AA .. RIGHTWARDS ARROW WITH HOOK
+.. |rarrlp|   unicode:: U+021AC .. RIGHTWARDS ARROW WITH LOOP
+.. |rarrpl|   unicode:: U+02945 .. RIGHTWARDS ARROW WITH PLUS BELOW
+.. |rarrsim|  unicode:: U+02974 .. RIGHTWARDS ARROW ABOVE TILDE OPERATOR
+.. |Rarrtl|   unicode:: U+02916 .. RIGHTWARDS TWO-HEADED ARROW WITH TAIL
+.. |rarrtl|   unicode:: U+021A3 .. RIGHTWARDS ARROW WITH TAIL
+.. |rarrw|    unicode:: U+0219D .. RIGHTWARDS WAVE ARROW
+.. |rAtail|   unicode:: U+0291C .. RIGHTWARDS DOUBLE ARROW-TAIL
+.. |ratail|   unicode:: U+0291A .. RIGHTWARDS ARROW-TAIL
+.. |RBarr|    unicode:: U+02910 .. RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW
+.. |rBarr|    unicode:: U+0290F .. RIGHTWARDS TRIPLE DASH ARROW
+.. |rbarr|    unicode:: U+0290D .. RIGHTWARDS DOUBLE DASH ARROW
+.. |rdca|     unicode:: U+02937 .. ARROW POINTING DOWNWARDS THEN CURVING RIGHTWARDS
+.. |rdldhar|  unicode:: U+02969 .. RIGHTWARDS HARPOON WITH BARB DOWN ABOVE LEFTWARDS HARPOON WITH BARB DOWN
+.. |rdsh|     unicode:: U+021B3 .. DOWNWARDS ARROW WITH TIP RIGHTWARDS
+.. |rfisht|   unicode:: U+0297D .. RIGHT FISH TAIL
+.. |rHar|     unicode:: U+02964 .. RIGHTWARDS HARPOON WITH BARB UP ABOVE RIGHTWARDS HARPOON WITH BARB DOWN
+.. |rhard|    unicode:: U+021C1 .. RIGHTWARDS HARPOON WITH BARB DOWNWARDS
+.. |rharu|    unicode:: U+021C0 .. RIGHTWARDS HARPOON WITH BARB UPWARDS
+.. |rharul|   unicode:: U+0296C .. RIGHTWARDS HARPOON WITH BARB UP ABOVE LONG DASH
+.. |rlarr|    unicode:: U+021C4 .. RIGHTWARDS ARROW OVER LEFTWARDS ARROW
+.. |rlarr2|   unicode:: U+021C4 .. RIGHTWARDS ARROW OVER LEFTWARDS ARROW
+.. |rlhar|    unicode:: U+021CC .. RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+.. |rlhar2|   unicode:: U+021CC .. RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+.. |roarr|    unicode:: U+021FE .. RIGHTWARDS OPEN-HEADED ARROW
+.. |rrarr|    unicode:: U+021C9 .. RIGHTWARDS PAIRED ARROWS
+.. |rsh|      unicode:: U+021B1 .. UPWARDS ARROW WITH TIP RIGHTWARDS
+.. |ruluhar|  unicode:: U+02968 .. RIGHTWARDS HARPOON WITH BARB UP ABOVE LEFTWARDS HARPOON WITH BARB UP
+.. |searhk|   unicode:: U+02925 .. SOUTH EAST ARROW WITH HOOK
+.. |seArr|    unicode:: U+021D8 .. SOUTH EAST DOUBLE ARROW
+.. |searr|    unicode:: U+02198 .. SOUTH EAST ARROW
+.. |seswar|   unicode:: U+02929 .. SOUTH EAST ARROW AND SOUTH WEST ARROW
+.. |simrarr|  unicode:: U+02972 .. TILDE OPERATOR ABOVE RIGHTWARDS ARROW
+.. |slarr|    unicode:: U+02190 .. LEFTWARDS ARROW
+.. |srarr|    unicode:: U+02192 .. RIGHTWARDS ARROW
+.. |swarhk|   unicode:: U+02926 .. SOUTH WEST ARROW WITH HOOK
+.. |swArr|    unicode:: U+021D9 .. SOUTH WEST DOUBLE ARROW
+.. |swarr|    unicode:: U+02199 .. SOUTH WEST ARROW
+.. |swnwar|   unicode:: U+0292A .. SOUTH WEST ARROW AND NORTH WEST ARROW
+.. |Uarr|     unicode:: U+0219F .. UPWARDS TWO HEADED ARROW
+.. |uArr|     unicode:: U+021D1 .. UPWARDS DOUBLE ARROW
+.. |uarr2|    unicode:: U+021C8 .. UPWARDS PAIRED ARROWS
+.. |Uarrocir| unicode:: U+02949 .. UPWARDS TWO-HEADED ARROW FROM SMALL CIRCLE
+.. |udarr|    unicode:: U+021C5 .. UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW
+.. |udhar|    unicode:: U+0296E .. UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT
+.. |ufisht|   unicode:: U+0297E .. UP FISH TAIL
+.. |uHar|     unicode:: U+02963 .. UPWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT
+.. |uharl|    unicode:: U+021BF .. UPWARDS HARPOON WITH BARB LEFTWARDS
+.. |uharr|    unicode:: U+021BE .. UPWARDS HARPOON WITH BARB RIGHTWARDS
+.. |uuarr|    unicode:: U+021C8 .. UPWARDS PAIRED ARROWS
+.. |vArr|     unicode:: U+021D5 .. UP DOWN DOUBLE ARROW
+.. |varr|     unicode:: U+02195 .. UP DOWN ARROW
+.. |xhArr|    unicode:: U+027FA .. LONG LEFT RIGHT DOUBLE ARROW
+.. |xharr|    unicode:: U+027F7 .. LONG LEFT RIGHT ARROW
+.. |xlArr|    unicode:: U+027F8 .. LONG LEFTWARDS DOUBLE ARROW
+.. |xlarr|    unicode:: U+027F5 .. LONG LEFTWARDS ARROW
+.. |xmap|     unicode:: U+027FC .. LONG RIGHTWARDS ARROW FROM BAR
+.. |xrArr|    unicode:: U+027F9 .. LONG RIGHTWARDS DOUBLE ARROW
+.. |xrarr|    unicode:: U+027F6 .. LONG RIGHTWARDS ARROW
+.. |zigrarr|  unicode:: U+021DD .. RIGHTWARDS SQUIGGLE ARROW
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsb.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsb.txt
new file mode 100644
index 00000000..d66fd4dd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsb.txt
@@ -0,0 +1,126 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |ac|       unicode:: U+0223E .. INVERTED LAZY S
+.. |acE|      unicode:: U+0223E U+00333 .. INVERTED LAZY S with double underline
+.. |amalg|    unicode:: U+02A3F .. AMALGAMATION OR COPRODUCT
+.. |barvee|   unicode:: U+022BD .. NOR
+.. |Barwed|   unicode:: U+02306 .. PERSPECTIVE
+.. |barwed|   unicode:: U+02305 .. PROJECTIVE
+.. |bsolb|    unicode:: U+029C5 .. SQUARED FALLING DIAGONAL SLASH
+.. |Cap|      unicode:: U+022D2 .. DOUBLE INTERSECTION
+.. |capand|   unicode:: U+02A44 .. INTERSECTION WITH LOGICAL AND
+.. |capbrcup| unicode:: U+02A49 .. INTERSECTION ABOVE BAR ABOVE UNION
+.. |capcap|   unicode:: U+02A4B .. INTERSECTION BESIDE AND JOINED WITH INTERSECTION
+.. |capcup|   unicode:: U+02A47 .. INTERSECTION ABOVE UNION
+.. |capdot|   unicode:: U+02A40 .. INTERSECTION WITH DOT
+.. |caps|     unicode:: U+02229 U+0FE00 .. INTERSECTION with serifs
+.. |ccaps|    unicode:: U+02A4D .. CLOSED INTERSECTION WITH SERIFS
+.. |ccups|    unicode:: U+02A4C .. CLOSED UNION WITH SERIFS
+.. |ccupssm|  unicode:: U+02A50 .. CLOSED UNION WITH SERIFS AND SMASH PRODUCT
+.. |coprod|   unicode:: U+02210 .. N-ARY COPRODUCT
+.. |Cup|      unicode:: U+022D3 .. DOUBLE UNION
+.. |cupbrcap| unicode:: U+02A48 .. UNION ABOVE BAR ABOVE INTERSECTION
+.. |cupcap|   unicode:: U+02A46 .. UNION ABOVE INTERSECTION
+.. |cupcup|   unicode:: U+02A4A .. UNION BESIDE AND JOINED WITH UNION
+.. |cupdot|   unicode:: U+0228D .. MULTISET MULTIPLICATION
+.. |cupor|    unicode:: U+02A45 .. UNION WITH LOGICAL OR
+.. |cups|     unicode:: U+0222A U+0FE00 .. UNION with serifs
+.. |cuvee|    unicode:: U+022CE .. CURLY LOGICAL OR
+.. |cuwed|    unicode:: U+022CF .. CURLY LOGICAL AND
+.. |Dagger|   unicode:: U+02021 .. DOUBLE DAGGER
+.. |dagger|   unicode:: U+02020 .. DAGGER
+.. |diam|     unicode:: U+022C4 .. DIAMOND OPERATOR
+.. |divonx|   unicode:: U+022C7 .. DIVISION TIMES
+.. |eplus|    unicode:: U+02A71 .. EQUALS SIGN ABOVE PLUS SIGN
+.. |hercon|   unicode:: U+022B9 .. HERMITIAN CONJUGATE MATRIX
+.. |intcal|   unicode:: U+022BA .. INTERCALATE
+.. |iprod|    unicode:: U+02A3C .. INTERIOR PRODUCT
+.. |loplus|   unicode:: U+02A2D .. PLUS SIGN IN LEFT HALF CIRCLE
+.. |lotimes|  unicode:: U+02A34 .. MULTIPLICATION SIGN IN LEFT HALF CIRCLE
+.. |lthree|   unicode:: U+022CB .. LEFT SEMIDIRECT PRODUCT
+.. |ltimes|   unicode:: U+022C9 .. LEFT NORMAL FACTOR SEMIDIRECT PRODUCT
+.. |midast|   unicode:: U+0002A .. ASTERISK
+.. |minusb|   unicode:: U+0229F .. SQUARED MINUS
+.. |minusd|   unicode:: U+02238 .. DOT MINUS
+.. |minusdu|  unicode:: U+02A2A .. MINUS SIGN WITH DOT BELOW
+.. |ncap|     unicode:: U+02A43 .. INTERSECTION WITH OVERBAR
+.. |ncup|     unicode:: U+02A42 .. UNION WITH OVERBAR
+.. |oast|     unicode:: U+0229B .. CIRCLED ASTERISK OPERATOR
+.. |ocir|     unicode:: U+0229A .. CIRCLED RING OPERATOR
+.. |odash|    unicode:: U+0229D .. CIRCLED DASH
+.. |odiv|     unicode:: U+02A38 .. CIRCLED DIVISION SIGN
+.. |odot|     unicode:: U+02299 .. CIRCLED DOT OPERATOR
+.. |odsold|   unicode:: U+029BC .. CIRCLED ANTICLOCKWISE-ROTATED DIVISION SIGN
+.. |ofcir|    unicode:: U+029BF .. CIRCLED BULLET
+.. |ogt|      unicode:: U+029C1 .. CIRCLED GREATER-THAN
+.. |ohbar|    unicode:: U+029B5 .. CIRCLE WITH HORIZONTAL BAR
+.. |olcir|    unicode:: U+029BE .. CIRCLED WHITE BULLET
+.. |olt|      unicode:: U+029C0 .. CIRCLED LESS-THAN
+.. |omid|     unicode:: U+029B6 .. CIRCLED VERTICAL BAR
+.. |ominus|   unicode:: U+02296 .. CIRCLED MINUS
+.. |opar|     unicode:: U+029B7 .. CIRCLED PARALLEL
+.. |operp|    unicode:: U+029B9 .. CIRCLED PERPENDICULAR
+.. |oplus|    unicode:: U+02295 .. CIRCLED PLUS
+.. |osol|     unicode:: U+02298 .. CIRCLED DIVISION SLASH
+.. |Otimes|   unicode:: U+02A37 .. MULTIPLICATION SIGN IN DOUBLE CIRCLE
+.. |otimes|   unicode:: U+02297 .. CIRCLED TIMES
+.. |otimesas| unicode:: U+02A36 .. CIRCLED MULTIPLICATION SIGN WITH CIRCUMFLEX ACCENT
+.. |ovbar|    unicode:: U+0233D .. APL FUNCTIONAL SYMBOL CIRCLE STILE
+.. |plusacir| unicode:: U+02A23 .. PLUS SIGN WITH CIRCUMFLEX ACCENT ABOVE
+.. |plusb|    unicode:: U+0229E .. SQUARED PLUS
+.. |pluscir|  unicode:: U+02A22 .. PLUS SIGN WITH SMALL CIRCLE ABOVE
+.. |plusdo|   unicode:: U+02214 .. DOT PLUS
+.. |plusdu|   unicode:: U+02A25 .. PLUS SIGN WITH DOT BELOW
+.. |pluse|    unicode:: U+02A72 .. PLUS SIGN ABOVE EQUALS SIGN
+.. |plussim|  unicode:: U+02A26 .. PLUS SIGN WITH TILDE BELOW
+.. |plustwo|  unicode:: U+02A27 .. PLUS SIGN WITH SUBSCRIPT TWO
+.. |prod|     unicode:: U+0220F .. N-ARY PRODUCT
+.. |race|     unicode:: U+029DA .. LEFT DOUBLE WIGGLY FENCE
+.. |roplus|   unicode:: U+02A2E .. PLUS SIGN IN RIGHT HALF CIRCLE
+.. |rotimes|  unicode:: U+02A35 .. MULTIPLICATION SIGN IN RIGHT HALF CIRCLE
+.. |rthree|   unicode:: U+022CC .. RIGHT SEMIDIRECT PRODUCT
+.. |rtimes|   unicode:: U+022CA .. RIGHT NORMAL FACTOR SEMIDIRECT PRODUCT
+.. |sdot|     unicode:: U+022C5 .. DOT OPERATOR
+.. |sdotb|    unicode:: U+022A1 .. SQUARED DOT OPERATOR
+.. |setmn|    unicode:: U+02216 .. SET MINUS
+.. |simplus|  unicode:: U+02A24 .. PLUS SIGN WITH TILDE ABOVE
+.. |smashp|   unicode:: U+02A33 .. SMASH PRODUCT
+.. |solb|     unicode:: U+029C4 .. SQUARED RISING DIAGONAL SLASH
+.. |sqcap|    unicode:: U+02293 .. SQUARE CAP
+.. |sqcaps|   unicode:: U+02293 U+0FE00 .. SQUARE CAP with serifs
+.. |sqcup|    unicode:: U+02294 .. SQUARE CUP
+.. |sqcups|   unicode:: U+02294 U+0FE00 .. SQUARE CUP with serifs
+.. |ssetmn|   unicode:: U+02216 .. SET MINUS
+.. |sstarf|   unicode:: U+022C6 .. STAR OPERATOR
+.. |subdot|   unicode:: U+02ABD .. SUBSET WITH DOT
+.. |sum|      unicode:: U+02211 .. N-ARY SUMMATION
+.. |supdot|   unicode:: U+02ABE .. SUPERSET WITH DOT
+.. |timesb|   unicode:: U+022A0 .. SQUARED TIMES
+.. |timesbar| unicode:: U+02A31 .. MULTIPLICATION SIGN WITH UNDERBAR
+.. |timesd|   unicode:: U+02A30 .. MULTIPLICATION SIGN WITH DOT ABOVE
+.. |top|      unicode:: U+022A4 .. DOWN TACK
+.. |tridot|   unicode:: U+025EC .. WHITE UP-POINTING TRIANGLE WITH DOT
+.. |triminus| unicode:: U+02A3A .. MINUS SIGN IN TRIANGLE
+.. |triplus|  unicode:: U+02A39 .. PLUS SIGN IN TRIANGLE
+.. |trisb|    unicode:: U+029CD .. TRIANGLE WITH SERIFS AT BOTTOM
+.. |tritime|  unicode:: U+02A3B .. MULTIPLICATION SIGN IN TRIANGLE
+.. |uplus|    unicode:: U+0228E .. MULTISET UNION
+.. |veebar|   unicode:: U+022BB .. XOR
+.. |wedbar|   unicode:: U+02A5F .. LOGICAL AND WITH UNDERBAR
+.. |wreath|   unicode:: U+02240 .. WREATH PRODUCT
+.. |xcap|     unicode:: U+022C2 .. N-ARY INTERSECTION
+.. |xcirc|    unicode:: U+025EF .. LARGE CIRCLE
+.. |xcup|     unicode:: U+022C3 .. N-ARY UNION
+.. |xdtri|    unicode:: U+025BD .. WHITE DOWN-POINTING TRIANGLE
+.. |xodot|    unicode:: U+02A00 .. N-ARY CIRCLED DOT OPERATOR
+.. |xoplus|   unicode:: U+02A01 .. N-ARY CIRCLED PLUS OPERATOR
+.. |xotime|   unicode:: U+02A02 .. N-ARY CIRCLED TIMES OPERATOR
+.. |xsqcup|   unicode:: U+02A06 .. N-ARY SQUARE UNION OPERATOR
+.. |xuplus|   unicode:: U+02A04 .. N-ARY UNION OPERATOR WITH PLUS
+.. |xutri|    unicode:: U+025B3 .. WHITE UP-POINTING TRIANGLE
+.. |xvee|     unicode:: U+022C1 .. N-ARY LOGICAL OR
+.. |xwedge|   unicode:: U+022C0 .. N-ARY LOGICAL AND
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsc.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsc.txt
new file mode 100644
index 00000000..bef4c3e7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsc.txt
@@ -0,0 +1,29 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |dlcorn|  unicode:: U+0231E .. BOTTOM LEFT CORNER
+.. |drcorn|  unicode:: U+0231F .. BOTTOM RIGHT CORNER
+.. |gtlPar|  unicode:: U+02995 .. DOUBLE LEFT ARC GREATER-THAN BRACKET
+.. |langd|   unicode:: U+02991 .. LEFT ANGLE BRACKET WITH DOT
+.. |lbrke|   unicode:: U+0298B .. LEFT SQUARE BRACKET WITH UNDERBAR
+.. |lbrksld| unicode:: U+0298F .. LEFT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+.. |lbrkslu| unicode:: U+0298D .. LEFT SQUARE BRACKET WITH TICK IN TOP CORNER
+.. |lceil|   unicode:: U+02308 .. LEFT CEILING
+.. |lfloor|  unicode:: U+0230A .. LEFT FLOOR
+.. |lmoust|  unicode:: U+023B0 .. UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION
+.. |lpargt|  unicode:: U+029A0 .. SPHERICAL ANGLE OPENING LEFT
+.. |lparlt|  unicode:: U+02993 .. LEFT ARC LESS-THAN BRACKET
+.. |ltrPar|  unicode:: U+02996 .. DOUBLE RIGHT ARC LESS-THAN BRACKET
+.. |rangd|   unicode:: U+02992 .. RIGHT ANGLE BRACKET WITH DOT
+.. |rbrke|   unicode:: U+0298C .. RIGHT SQUARE BRACKET WITH UNDERBAR
+.. |rbrksld| unicode:: U+0298E .. RIGHT SQUARE BRACKET WITH TICK IN BOTTOM CORNER
+.. |rbrkslu| unicode:: U+02990 .. RIGHT SQUARE BRACKET WITH TICK IN TOP CORNER
+.. |rceil|   unicode:: U+02309 .. RIGHT CEILING
+.. |rfloor|  unicode:: U+0230B .. RIGHT FLOOR
+.. |rmoust|  unicode:: U+023B1 .. UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION
+.. |rpargt|  unicode:: U+02994 .. RIGHT ARC GREATER-THAN BRACKET
+.. |ulcorn|  unicode:: U+0231C .. TOP LEFT CORNER
+.. |urcorn|  unicode:: U+0231D .. TOP RIGHT CORNER
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsn.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsn.txt
new file mode 100644
index 00000000..65389e8d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsn.txt
@@ -0,0 +1,96 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |gnap|     unicode:: U+02A8A .. GREATER-THAN AND NOT APPROXIMATE
+.. |gnE|      unicode:: U+02269 .. GREATER-THAN BUT NOT EQUAL TO
+.. |gne|      unicode:: U+02A88 .. GREATER-THAN AND SINGLE-LINE NOT EQUAL TO
+.. |gnsim|    unicode:: U+022E7 .. GREATER-THAN BUT NOT EQUIVALENT TO
+.. |gvnE|     unicode:: U+02269 U+0FE00 .. GREATER-THAN BUT NOT EQUAL TO - with vertical stroke
+.. |lnap|     unicode:: U+02A89 .. LESS-THAN AND NOT APPROXIMATE
+.. |lnE|      unicode:: U+02268 .. LESS-THAN BUT NOT EQUAL TO
+.. |lne|      unicode:: U+02A87 .. LESS-THAN AND SINGLE-LINE NOT EQUAL TO
+.. |lnsim|    unicode:: U+022E6 .. LESS-THAN BUT NOT EQUIVALENT TO
+.. |lvnE|     unicode:: U+02268 U+0FE00 .. LESS-THAN BUT NOT EQUAL TO - with vertical stroke
+.. |nap|      unicode:: U+02249 .. NOT ALMOST EQUAL TO
+.. |napE|     unicode:: U+02A70 U+00338 .. APPROXIMATELY EQUAL OR EQUAL TO with slash
+.. |napid|    unicode:: U+0224B U+00338 .. TRIPLE TILDE with slash
+.. |ncong|    unicode:: U+02247 .. NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO
+.. |ncongdot| unicode:: U+02A6D U+00338 .. CONGRUENT WITH DOT ABOVE with slash
+.. |nequiv|   unicode:: U+02262 .. NOT IDENTICAL TO
+.. |ngE|      unicode:: U+02267 U+00338 .. GREATER-THAN OVER EQUAL TO with slash
+.. |nge|      unicode:: U+02271 .. NEITHER GREATER-THAN NOR EQUAL TO
+.. |nges|     unicode:: U+02A7E U+00338 .. GREATER-THAN OR SLANTED EQUAL TO with slash
+.. |nGg|      unicode:: U+022D9 U+00338 .. VERY MUCH GREATER-THAN with slash
+.. |ngsim|    unicode:: U+02275 .. NEITHER GREATER-THAN NOR EQUIVALENT TO
+.. |nGt|      unicode:: U+0226B U+020D2 .. MUCH GREATER THAN with vertical line
+.. |ngt|      unicode:: U+0226F .. NOT GREATER-THAN
+.. |nGtv|     unicode:: U+0226B U+00338 .. MUCH GREATER THAN with slash
+.. |nlE|      unicode:: U+02266 U+00338 .. LESS-THAN OVER EQUAL TO with slash
+.. |nle|      unicode:: U+02270 .. NEITHER LESS-THAN NOR EQUAL TO
+.. |nles|     unicode:: U+02A7D U+00338 .. LESS-THAN OR SLANTED EQUAL TO with slash
+.. |nLl|      unicode:: U+022D8 U+00338 .. VERY MUCH LESS-THAN with slash
+.. |nlsim|    unicode:: U+02274 .. NEITHER LESS-THAN NOR EQUIVALENT TO
+.. |nLt|      unicode:: U+0226A U+020D2 .. MUCH LESS THAN with vertical line
+.. |nlt|      unicode:: U+0226E .. NOT LESS-THAN
+.. |nltri|    unicode:: U+022EA .. NOT NORMAL SUBGROUP OF
+.. |nltrie|   unicode:: U+022EC .. NOT NORMAL SUBGROUP OF OR EQUAL TO
+.. |nLtv|     unicode:: U+0226A U+00338 .. MUCH LESS THAN with slash
+.. |nmid|     unicode:: U+02224 .. DOES NOT DIVIDE
+.. |npar|     unicode:: U+02226 .. NOT PARALLEL TO
+.. |npr|      unicode:: U+02280 .. DOES NOT PRECEDE
+.. |nprcue|   unicode:: U+022E0 .. DOES NOT PRECEDE OR EQUAL
+.. |npre|     unicode:: U+02AAF U+00338 .. PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash
+.. |nrtri|    unicode:: U+022EB .. DOES NOT CONTAIN AS NORMAL SUBGROUP
+.. |nrtrie|   unicode:: U+022ED .. DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL
+.. |nsc|      unicode:: U+02281 .. DOES NOT SUCCEED
+.. |nsccue|   unicode:: U+022E1 .. DOES NOT SUCCEED OR EQUAL
+.. |nsce|     unicode:: U+02AB0 U+00338 .. SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash
+.. |nsim|     unicode:: U+02241 .. NOT TILDE
+.. |nsime|    unicode:: U+02244 .. NOT ASYMPTOTICALLY EQUAL TO
+.. |nsmid|    unicode:: U+02224 .. DOES NOT DIVIDE
+.. |nspar|    unicode:: U+02226 .. NOT PARALLEL TO
+.. |nsqsube|  unicode:: U+022E2 .. NOT SQUARE IMAGE OF OR EQUAL TO
+.. |nsqsupe|  unicode:: U+022E3 .. NOT SQUARE ORIGINAL OF OR EQUAL TO
+.. |nsub|     unicode:: U+02284 .. NOT A SUBSET OF
+.. |nsubE|    unicode:: U+02AC5 U+00338 .. SUBSET OF ABOVE EQUALS SIGN with slash
+.. |nsube|    unicode:: U+02288 .. NEITHER A SUBSET OF NOR EQUAL TO
+.. |nsup|     unicode:: U+02285 .. NOT A SUPERSET OF
+.. |nsupE|    unicode:: U+02AC6 U+00338 .. SUPERSET OF ABOVE EQUALS SIGN with slash
+.. |nsupe|    unicode:: U+02289 .. NEITHER A SUPERSET OF NOR EQUAL TO
+.. |ntgl|     unicode:: U+02279 .. NEITHER GREATER-THAN NOR LESS-THAN
+.. |ntlg|     unicode:: U+02278 .. NEITHER LESS-THAN NOR GREATER-THAN
+.. |nvap|     unicode:: U+0224D U+020D2 .. EQUIVALENT TO with vertical line
+.. |nVDash|   unicode:: U+022AF .. NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
+.. |nVdash|   unicode:: U+022AE .. DOES NOT FORCE
+.. |nvDash|   unicode:: U+022AD .. NOT TRUE
+.. |nvdash|   unicode:: U+022AC .. DOES NOT PROVE
+.. |nvge|     unicode:: U+02265 U+020D2 .. GREATER-THAN OR EQUAL TO with vertical line
+.. |nvgt|     unicode:: U+0003E U+020D2 .. GREATER-THAN SIGN with vertical line
+.. |nvle|     unicode:: U+02264 U+020D2 .. LESS-THAN OR EQUAL TO with vertical line
+.. |nvlt|     unicode:: U+0003C U+020D2 .. LESS-THAN SIGN with vertical line
+.. |nvltrie|  unicode:: U+022B4 U+020D2 .. NORMAL SUBGROUP OF OR EQUAL TO with vertical line
+.. |nvrtrie|  unicode:: U+022B5 U+020D2 .. CONTAINS AS NORMAL SUBGROUP OR EQUAL TO with vertical line
+.. |nvsim|    unicode:: U+0223C U+020D2 .. TILDE OPERATOR with vertical line
+.. |parsim|   unicode:: U+02AF3 .. PARALLEL WITH TILDE OPERATOR
+.. |prnap|    unicode:: U+02AB9 .. PRECEDES ABOVE NOT ALMOST EQUAL TO
+.. |prnE|     unicode:: U+02AB5 .. PRECEDES ABOVE NOT EQUAL TO
+.. |prnsim|   unicode:: U+022E8 .. PRECEDES BUT NOT EQUIVALENT TO
+.. |rnmid|    unicode:: U+02AEE .. DOES NOT DIVIDE WITH REVERSED NEGATION SLASH
+.. |scnap|    unicode:: U+02ABA .. SUCCEEDS ABOVE NOT ALMOST EQUAL TO
+.. |scnE|     unicode:: U+02AB6 .. SUCCEEDS ABOVE NOT EQUAL TO
+.. |scnsim|   unicode:: U+022E9 .. SUCCEEDS BUT NOT EQUIVALENT TO
+.. |simne|    unicode:: U+02246 .. APPROXIMATELY BUT NOT ACTUALLY EQUAL TO
+.. |solbar|   unicode:: U+0233F .. APL FUNCTIONAL SYMBOL SLASH BAR
+.. |subnE|    unicode:: U+02ACB .. SUBSET OF ABOVE NOT EQUAL TO
+.. |subne|    unicode:: U+0228A .. SUBSET OF WITH NOT EQUAL TO
+.. |supnE|    unicode:: U+02ACC .. SUPERSET OF ABOVE NOT EQUAL TO
+.. |supne|    unicode:: U+0228B .. SUPERSET OF WITH NOT EQUAL TO
+.. |vnsub|    unicode:: U+02282 U+020D2 .. SUBSET OF with vertical line
+.. |vnsup|    unicode:: U+02283 U+020D2 .. SUPERSET OF with vertical line
+.. |vsubnE|   unicode:: U+02ACB U+0FE00 .. SUBSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members
+.. |vsubne|   unicode:: U+0228A U+0FE00 .. SUBSET OF WITH NOT EQUAL TO - variant with stroke through bottom members
+.. |vsupnE|   unicode:: U+02ACC U+0FE00 .. SUPERSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members
+.. |vsupne|   unicode:: U+0228B U+0FE00 .. SUPERSET OF WITH NOT EQUAL TO - variant with stroke through bottom members
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamso.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamso.txt
new file mode 100644
index 00000000..f17e16bc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamso.txt
@@ -0,0 +1,62 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |ang|      unicode:: U+02220 .. ANGLE
+.. |ange|     unicode:: U+029A4 .. ANGLE WITH UNDERBAR
+.. |angmsd|   unicode:: U+02221 .. MEASURED ANGLE
+.. |angmsdaa| unicode:: U+029A8 .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND RIGHT
+.. |angmsdab| unicode:: U+029A9 .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING UP AND LEFT
+.. |angmsdac| unicode:: U+029AA .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND RIGHT
+.. |angmsdad| unicode:: U+029AB .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING DOWN AND LEFT
+.. |angmsdae| unicode:: U+029AC .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND UP
+.. |angmsdaf| unicode:: U+029AD .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND UP
+.. |angmsdag| unicode:: U+029AE .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING RIGHT AND DOWN
+.. |angmsdah| unicode:: U+029AF .. MEASURED ANGLE WITH OPEN ARM ENDING IN ARROW POINTING LEFT AND DOWN
+.. |angrtvb|  unicode:: U+022BE .. RIGHT ANGLE WITH ARC
+.. |angrtvbd| unicode:: U+0299D .. MEASURED RIGHT ANGLE WITH DOT
+.. |bbrk|     unicode:: U+023B5 .. BOTTOM SQUARE BRACKET
+.. |bbrktbrk| unicode:: U+023B6 .. BOTTOM SQUARE BRACKET OVER TOP SQUARE BRACKET
+.. |bemptyv|  unicode:: U+029B0 .. REVERSED EMPTY SET
+.. |beth|     unicode:: U+02136 .. BET SYMBOL
+.. |boxbox|   unicode:: U+029C9 .. TWO JOINED SQUARES
+.. |bprime|   unicode:: U+02035 .. REVERSED PRIME
+.. |bsemi|    unicode:: U+0204F .. REVERSED SEMICOLON
+.. |cemptyv|  unicode:: U+029B2 .. EMPTY SET WITH SMALL CIRCLE ABOVE
+.. |cirE|     unicode:: U+029C3 .. CIRCLE WITH TWO HORIZONTAL STROKES TO THE RIGHT
+.. |cirscir|  unicode:: U+029C2 .. CIRCLE WITH SMALL CIRCLE TO THE RIGHT
+.. |comp|     unicode:: U+02201 .. COMPLEMENT
+.. |daleth|   unicode:: U+02138 .. DALET SYMBOL
+.. |demptyv|  unicode:: U+029B1 .. EMPTY SET WITH OVERBAR
+.. |ell|      unicode:: U+02113 .. SCRIPT SMALL L
+.. |empty|    unicode:: U+02205 .. EMPTY SET
+.. |emptyv|   unicode:: U+02205 .. EMPTY SET
+.. |gimel|    unicode:: U+02137 .. GIMEL SYMBOL
+.. |iiota|    unicode:: U+02129 .. TURNED GREEK SMALL LETTER IOTA
+.. |image|    unicode:: U+02111 .. BLACK-LETTER CAPITAL I
+.. |imath|    unicode:: U+00131 .. LATIN SMALL LETTER DOTLESS I
+.. |inodot|   unicode:: U+00131 .. LATIN SMALL LETTER DOTLESS I
+.. |jmath|    unicode:: U+0006A .. LATIN SMALL LETTER J
+.. |jnodot|   unicode:: U+0006A .. LATIN SMALL LETTER J
+.. |laemptyv| unicode:: U+029B4 .. EMPTY SET WITH LEFT ARROW ABOVE
+.. |lltri|    unicode:: U+025FA .. LOWER LEFT TRIANGLE
+.. |lrtri|    unicode:: U+022BF .. RIGHT TRIANGLE
+.. |mho|      unicode:: U+02127 .. INVERTED OHM SIGN
+.. |nang|     unicode:: U+02220 U+020D2 .. ANGLE with vertical line
+.. |nexist|   unicode:: U+02204 .. THERE DOES NOT EXIST
+.. |oS|       unicode:: U+024C8 .. CIRCLED LATIN CAPITAL LETTER S
+.. |planck|   unicode:: U+0210F .. PLANCK CONSTANT OVER TWO PI
+.. |plankv|   unicode:: U+0210F .. PLANCK CONSTANT OVER TWO PI
+.. |raemptyv| unicode:: U+029B3 .. EMPTY SET WITH RIGHT ARROW ABOVE
+.. |range|    unicode:: U+029A5 .. REVERSED ANGLE WITH UNDERBAR
+.. |real|     unicode:: U+0211C .. BLACK-LETTER CAPITAL R
+.. |sbsol|    unicode:: U+0FE68 .. SMALL REVERSE SOLIDUS
+.. |tbrk|     unicode:: U+023B4 .. TOP SQUARE BRACKET
+.. |trpezium| unicode:: U+0FFFD .. REPLACEMENT CHARACTER
+.. |ultri|    unicode:: U+025F8 .. UPPER LEFT TRIANGLE
+.. |urtri|    unicode:: U+025F9 .. UPPER RIGHT TRIANGLE
+.. |vprime|   unicode:: U+02032 .. PRIME
+.. |vzigzag|  unicode:: U+0299A .. VERTICAL ZIGZAG LINE
+.. |weierp|   unicode:: U+02118 .. SCRIPT CAPITAL P
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsr.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsr.txt
new file mode 100644
index 00000000..7d3c1aac
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isoamsr.txt
@@ -0,0 +1,191 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |apE|      unicode:: U+02A70 .. APPROXIMATELY EQUAL OR EQUAL TO
+.. |ape|      unicode:: U+0224A .. ALMOST EQUAL OR EQUAL TO
+.. |apid|     unicode:: U+0224B .. TRIPLE TILDE
+.. |asymp|    unicode:: U+02248 .. ALMOST EQUAL TO
+.. |Barv|     unicode:: U+02AE7 .. SHORT DOWN TACK WITH OVERBAR
+.. |bcong|    unicode:: U+0224C .. ALL EQUAL TO
+.. |bepsi|    unicode:: U+003F6 .. GREEK REVERSED LUNATE EPSILON SYMBOL
+.. |bowtie|   unicode:: U+022C8 .. BOWTIE
+.. |bsim|     unicode:: U+0223D .. REVERSED TILDE
+.. |bsime|    unicode:: U+022CD .. REVERSED TILDE EQUALS
+.. |bsolhsub| unicode:: U+0005C U+02282 .. REVERSE SOLIDUS, SUBSET OF
+.. |bump|     unicode:: U+0224E .. GEOMETRICALLY EQUIVALENT TO
+.. |bumpE|    unicode:: U+02AAE .. EQUALS SIGN WITH BUMPY ABOVE
+.. |bumpe|    unicode:: U+0224F .. DIFFERENCE BETWEEN
+.. |cire|     unicode:: U+02257 .. RING EQUAL TO
+.. |Colon|    unicode:: U+02237 .. PROPORTION
+.. |Colone|   unicode:: U+02A74 .. DOUBLE COLON EQUAL
+.. |colone|   unicode:: U+02254 .. COLON EQUALS
+.. |congdot|  unicode:: U+02A6D .. CONGRUENT WITH DOT ABOVE
+.. |csub|     unicode:: U+02ACF .. CLOSED SUBSET
+.. |csube|    unicode:: U+02AD1 .. CLOSED SUBSET OR EQUAL TO
+.. |csup|     unicode:: U+02AD0 .. CLOSED SUPERSET
+.. |csupe|    unicode:: U+02AD2 .. CLOSED SUPERSET OR EQUAL TO
+.. |cuepr|    unicode:: U+022DE .. EQUAL TO OR PRECEDES
+.. |cuesc|    unicode:: U+022DF .. EQUAL TO OR SUCCEEDS
+.. |cupre|    unicode:: U+0227C .. PRECEDES OR EQUAL TO
+.. |Dashv|    unicode:: U+02AE4 .. VERTICAL BAR DOUBLE LEFT TURNSTILE
+.. |dashv|    unicode:: U+022A3 .. LEFT TACK
+.. |easter|   unicode:: U+02A6E .. EQUALS WITH ASTERISK
+.. |ecir|     unicode:: U+02256 .. RING IN EQUAL TO
+.. |ecolon|   unicode:: U+02255 .. EQUALS COLON
+.. |eDDot|    unicode:: U+02A77 .. EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW
+.. |eDot|     unicode:: U+02251 .. GEOMETRICALLY EQUAL TO
+.. |efDot|    unicode:: U+02252 .. APPROXIMATELY EQUAL TO OR THE IMAGE OF
+.. |eg|       unicode:: U+02A9A .. DOUBLE-LINE EQUAL TO OR GREATER-THAN
+.. |egs|      unicode:: U+02A96 .. SLANTED EQUAL TO OR GREATER-THAN
+.. |egsdot|   unicode:: U+02A98 .. SLANTED EQUAL TO OR GREATER-THAN WITH DOT INSIDE
+.. |el|       unicode:: U+02A99 .. DOUBLE-LINE EQUAL TO OR LESS-THAN
+.. |els|      unicode:: U+02A95 .. SLANTED EQUAL TO OR LESS-THAN
+.. |elsdot|   unicode:: U+02A97 .. SLANTED EQUAL TO OR LESS-THAN WITH DOT INSIDE
+.. |equest|   unicode:: U+0225F .. QUESTIONED EQUAL TO
+.. |equivDD|  unicode:: U+02A78 .. EQUIVALENT WITH FOUR DOTS ABOVE
+.. |erDot|    unicode:: U+02253 .. IMAGE OF OR APPROXIMATELY EQUAL TO
+.. |esdot|    unicode:: U+02250 .. APPROACHES THE LIMIT
+.. |Esim|     unicode:: U+02A73 .. EQUALS SIGN ABOVE TILDE OPERATOR
+.. |esim|     unicode:: U+02242 .. MINUS TILDE
+.. |fork|     unicode:: U+022D4 .. PITCHFORK
+.. |forkv|    unicode:: U+02AD9 .. ELEMENT OF OPENING DOWNWARDS
+.. |frown|    unicode:: U+02322 .. FROWN
+.. |gap|      unicode:: U+02A86 .. GREATER-THAN OR APPROXIMATE
+.. |gE|       unicode:: U+02267 .. GREATER-THAN OVER EQUAL TO
+.. |gEl|      unicode:: U+02A8C .. GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN
+.. |gel|      unicode:: U+022DB .. GREATER-THAN EQUAL TO OR LESS-THAN
+.. |ges|      unicode:: U+02A7E .. GREATER-THAN OR SLANTED EQUAL TO
+.. |gescc|    unicode:: U+02AA9 .. GREATER-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL
+.. |gesdot|   unicode:: U+02A80 .. GREATER-THAN OR SLANTED EQUAL TO WITH DOT INSIDE
+.. |gesdoto|  unicode:: U+02A82 .. GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE
+.. |gesdotol| unicode:: U+02A84 .. GREATER-THAN OR SLANTED EQUAL TO WITH DOT ABOVE LEFT
+.. |gesl|     unicode:: U+022DB U+0FE00 .. GREATER-THAN slanted EQUAL TO OR LESS-THAN
+.. |gesles|   unicode:: U+02A94 .. GREATER-THAN ABOVE SLANTED EQUAL ABOVE LESS-THAN ABOVE SLANTED EQUAL
+.. |Gg|       unicode:: U+022D9 .. VERY MUCH GREATER-THAN
+.. |gl|       unicode:: U+02277 .. GREATER-THAN OR LESS-THAN
+.. |gla|      unicode:: U+02AA5 .. GREATER-THAN BESIDE LESS-THAN
+.. |glE|      unicode:: U+02A92 .. GREATER-THAN ABOVE LESS-THAN ABOVE DOUBLE-LINE EQUAL
+.. |glj|      unicode:: U+02AA4 .. GREATER-THAN OVERLAPPING LESS-THAN
+.. |gsdot|    unicode:: U+022D7 .. GREATER-THAN WITH DOT
+.. |gsim|     unicode:: U+02273 .. GREATER-THAN OR EQUIVALENT TO
+.. |gsime|    unicode:: U+02A8E .. GREATER-THAN ABOVE SIMILAR OR EQUAL
+.. |gsiml|    unicode:: U+02A90 .. GREATER-THAN ABOVE SIMILAR ABOVE LESS-THAN
+.. |Gt|       unicode:: U+0226B .. MUCH GREATER-THAN
+.. |gtcc|     unicode:: U+02AA7 .. GREATER-THAN CLOSED BY CURVE
+.. |gtcir|    unicode:: U+02A7A .. GREATER-THAN WITH CIRCLE INSIDE
+.. |gtdot|    unicode:: U+022D7 .. GREATER-THAN WITH DOT
+.. |gtquest|  unicode:: U+02A7C .. GREATER-THAN WITH QUESTION MARK ABOVE
+.. |gtrarr|   unicode:: U+02978 .. GREATER-THAN ABOVE RIGHTWARDS ARROW
+.. |homtht|   unicode:: U+0223B .. HOMOTHETIC
+.. |lap|      unicode:: U+02A85 .. LESS-THAN OR APPROXIMATE
+.. |lat|      unicode:: U+02AAB .. LARGER THAN
+.. |late|     unicode:: U+02AAD .. LARGER THAN OR EQUAL TO
+.. |lates|    unicode:: U+02AAD U+0FE00 .. LARGER THAN OR slanted EQUAL
+.. |ldot|     unicode:: U+022D6 .. LESS-THAN WITH DOT
+.. |lE|       unicode:: U+02266 .. LESS-THAN OVER EQUAL TO
+.. |lEg|      unicode:: U+02A8B .. LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN
+.. |leg|      unicode:: U+022DA .. LESS-THAN EQUAL TO OR GREATER-THAN
+.. |les|      unicode:: U+02A7D .. LESS-THAN OR SLANTED EQUAL TO
+.. |lescc|    unicode:: U+02AA8 .. LESS-THAN CLOSED BY CURVE ABOVE SLANTED EQUAL
+.. |lesdot|   unicode:: U+02A7F .. LESS-THAN OR SLANTED EQUAL TO WITH DOT INSIDE
+.. |lesdoto|  unicode:: U+02A81 .. LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE
+.. |lesdotor| unicode:: U+02A83 .. LESS-THAN OR SLANTED EQUAL TO WITH DOT ABOVE RIGHT
+.. |lesg|     unicode:: U+022DA U+0FE00 .. LESS-THAN slanted EQUAL TO OR GREATER-THAN
+.. |lesges|   unicode:: U+02A93 .. LESS-THAN ABOVE SLANTED EQUAL ABOVE GREATER-THAN ABOVE SLANTED EQUAL
+.. |lg|       unicode:: U+02276 .. LESS-THAN OR GREATER-THAN
+.. |lgE|      unicode:: U+02A91 .. LESS-THAN ABOVE GREATER-THAN ABOVE DOUBLE-LINE EQUAL
+.. |Ll|       unicode:: U+022D8 .. VERY MUCH LESS-THAN
+.. |lsim|     unicode:: U+02272 .. LESS-THAN OR EQUIVALENT TO
+.. |lsime|    unicode:: U+02A8D .. LESS-THAN ABOVE SIMILAR OR EQUAL
+.. |lsimg|    unicode:: U+02A8F .. LESS-THAN ABOVE SIMILAR ABOVE GREATER-THAN
+.. |Lt|       unicode:: U+0226A .. MUCH LESS-THAN
+.. |ltcc|     unicode:: U+02AA6 .. LESS-THAN CLOSED BY CURVE
+.. |ltcir|    unicode:: U+02A79 .. LESS-THAN WITH CIRCLE INSIDE
+.. |ltdot|    unicode:: U+022D6 .. LESS-THAN WITH DOT
+.. |ltlarr|   unicode:: U+02976 .. LESS-THAN ABOVE LEFTWARDS ARROW
+.. |ltquest|  unicode:: U+02A7B .. LESS-THAN WITH QUESTION MARK ABOVE
+.. |ltrie|    unicode:: U+022B4 .. NORMAL SUBGROUP OF OR EQUAL TO
+.. |mcomma|   unicode:: U+02A29 .. MINUS SIGN WITH COMMA ABOVE
+.. |mDDot|    unicode:: U+0223A .. GEOMETRIC PROPORTION
+.. |mid|      unicode:: U+02223 .. DIVIDES
+.. |mlcp|     unicode:: U+02ADB .. TRANSVERSAL INTERSECTION
+.. |models|   unicode:: U+022A7 .. MODELS
+.. |mstpos|   unicode:: U+0223E .. INVERTED LAZY S
+.. |Pr|       unicode:: U+02ABB .. DOUBLE PRECEDES
+.. |pr|       unicode:: U+0227A .. PRECEDES
+.. |prap|     unicode:: U+02AB7 .. PRECEDES ABOVE ALMOST EQUAL TO
+.. |prcue|    unicode:: U+0227C .. PRECEDES OR EQUAL TO
+.. |prE|      unicode:: U+02AB3 .. PRECEDES ABOVE EQUALS SIGN
+.. |pre|      unicode:: U+02AAF .. PRECEDES ABOVE SINGLE-LINE EQUALS SIGN
+.. |prsim|    unicode:: U+0227E .. PRECEDES OR EQUIVALENT TO
+.. |prurel|   unicode:: U+022B0 .. PRECEDES UNDER RELATION
+.. |ratio|    unicode:: U+02236 .. RATIO
+.. |rtrie|    unicode:: U+022B5 .. CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
+.. |rtriltri| unicode:: U+029CE .. RIGHT TRIANGLE ABOVE LEFT TRIANGLE
+.. |samalg|   unicode:: U+02210 .. N-ARY COPRODUCT
+.. |Sc|       unicode:: U+02ABC .. DOUBLE SUCCEEDS
+.. |sc|       unicode:: U+0227B .. SUCCEEDS
+.. |scap|     unicode:: U+02AB8 .. SUCCEEDS ABOVE ALMOST EQUAL TO
+.. |sccue|    unicode:: U+0227D .. SUCCEEDS OR EQUAL TO
+.. |scE|      unicode:: U+02AB4 .. SUCCEEDS ABOVE EQUALS SIGN
+.. |sce|      unicode:: U+02AB0 .. SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN
+.. |scsim|    unicode:: U+0227F .. SUCCEEDS OR EQUIVALENT TO
+.. |sdote|    unicode:: U+02A66 .. EQUALS SIGN WITH DOT BELOW
+.. |sfrown|   unicode:: U+02322 .. FROWN
+.. |simg|     unicode:: U+02A9E .. SIMILAR OR GREATER-THAN
+.. |simgE|    unicode:: U+02AA0 .. SIMILAR ABOVE GREATER-THAN ABOVE EQUALS SIGN
+.. |siml|     unicode:: U+02A9D .. SIMILAR OR LESS-THAN
+.. |simlE|    unicode:: U+02A9F .. SIMILAR ABOVE LESS-THAN ABOVE EQUALS SIGN
+.. |smid|     unicode:: U+02223 .. DIVIDES
+.. |smile|    unicode:: U+02323 .. SMILE
+.. |smt|      unicode:: U+02AAA .. SMALLER THAN
+.. |smte|     unicode:: U+02AAC .. SMALLER THAN OR EQUAL TO
+.. |smtes|    unicode:: U+02AAC U+0FE00 .. SMALLER THAN OR slanted EQUAL
+.. |spar|     unicode:: U+02225 .. PARALLEL TO
+.. |sqsub|    unicode:: U+0228F .. SQUARE IMAGE OF
+.. |sqsube|   unicode:: U+02291 .. SQUARE IMAGE OF OR EQUAL TO
+.. |sqsup|    unicode:: U+02290 .. SQUARE ORIGINAL OF
+.. |sqsupe|   unicode:: U+02292 .. SQUARE ORIGINAL OF OR EQUAL TO
+.. |ssmile|   unicode:: U+02323 .. SMILE
+.. |Sub|      unicode:: U+022D0 .. DOUBLE SUBSET
+.. |subE|     unicode:: U+02AC5 .. SUBSET OF ABOVE EQUALS SIGN
+.. |subedot|  unicode:: U+02AC3 .. SUBSET OF OR EQUAL TO WITH DOT ABOVE
+.. |submult|  unicode:: U+02AC1 .. SUBSET WITH MULTIPLICATION SIGN BELOW
+.. |subplus|  unicode:: U+02ABF .. SUBSET WITH PLUS SIGN BELOW
+.. |subrarr|  unicode:: U+02979 .. SUBSET ABOVE RIGHTWARDS ARROW
+.. |subsim|   unicode:: U+02AC7 .. SUBSET OF ABOVE TILDE OPERATOR
+.. |subsub|   unicode:: U+02AD5 .. SUBSET ABOVE SUBSET
+.. |subsup|   unicode:: U+02AD3 .. SUBSET ABOVE SUPERSET
+.. |Sup|      unicode:: U+022D1 .. DOUBLE SUPERSET
+.. |supdsub|  unicode:: U+02AD8 .. SUPERSET BESIDE AND JOINED BY DASH WITH SUBSET
+.. |supE|     unicode:: U+02AC6 .. SUPERSET OF ABOVE EQUALS SIGN
+.. |supedot|  unicode:: U+02AC4 .. SUPERSET OF OR EQUAL TO WITH DOT ABOVE
+.. |suphsol|  unicode:: U+02283 U+0002F .. SUPERSET OF, SOLIDUS
+.. |suphsub|  unicode:: U+02AD7 .. SUPERSET BESIDE SUBSET
+.. |suplarr|  unicode:: U+0297B .. SUPERSET ABOVE LEFTWARDS ARROW
+.. |supmult|  unicode:: U+02AC2 .. SUPERSET WITH MULTIPLICATION SIGN BELOW
+.. |supplus|  unicode:: U+02AC0 .. SUPERSET WITH PLUS SIGN BELOW
+.. |supsim|   unicode:: U+02AC8 .. SUPERSET OF ABOVE TILDE OPERATOR
+.. |supsub|   unicode:: U+02AD4 .. SUPERSET ABOVE SUBSET
+.. |supsup|   unicode:: U+02AD6 .. SUPERSET ABOVE SUPERSET
+.. |thkap|    unicode:: U+02248 .. ALMOST EQUAL TO
+.. |thksim|   unicode:: U+0223C .. TILDE OPERATOR
+.. |topfork|  unicode:: U+02ADA .. PITCHFORK WITH TEE TOP
+.. |trie|     unicode:: U+0225C .. DELTA EQUAL TO
+.. |twixt|    unicode:: U+0226C .. BETWEEN
+.. |Vbar|     unicode:: U+02AEB .. DOUBLE UP TACK
+.. |vBar|     unicode:: U+02AE8 .. SHORT UP TACK WITH UNDERBAR
+.. |vBarv|    unicode:: U+02AE9 .. SHORT UP TACK ABOVE SHORT DOWN TACK
+.. |VDash|    unicode:: U+022AB .. DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE
+.. |Vdash|    unicode:: U+022A9 .. FORCES
+.. |vDash|    unicode:: U+022A8 .. TRUE
+.. |vdash|    unicode:: U+022A2 .. RIGHT TACK
+.. |Vdashl|   unicode:: U+02AE6 .. LONG DASH FROM LEFT MEMBER OF DOUBLE VERTICAL
+.. |veebar|   unicode:: U+022BB .. XOR
+.. |vltri|    unicode:: U+022B2 .. NORMAL SUBGROUP OF
+.. |vprop|    unicode:: U+0221D .. PROPORTIONAL TO
+.. |vrtri|    unicode:: U+022B3 .. CONTAINS AS NORMAL SUBGROUP
+.. |Vvdash|   unicode:: U+022AA .. TRIPLE VERTICAL BAR RIGHT TURNSTILE
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isobox.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isobox.txt
new file mode 100644
index 00000000..17d45bc6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isobox.txt
@@ -0,0 +1,46 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |boxDL| unicode:: U+02557 .. BOX DRAWINGS DOUBLE DOWN AND LEFT
+.. |boxDl| unicode:: U+02556 .. BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE
+.. |boxdL| unicode:: U+02555 .. BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE
+.. |boxdl| unicode:: U+02510 .. BOX DRAWINGS LIGHT DOWN AND LEFT
+.. |boxDR| unicode:: U+02554 .. BOX DRAWINGS DOUBLE DOWN AND RIGHT
+.. |boxDr| unicode:: U+02553 .. BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE
+.. |boxdR| unicode:: U+02552 .. BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE
+.. |boxdr| unicode:: U+0250C .. BOX DRAWINGS LIGHT DOWN AND RIGHT
+.. |boxH|  unicode:: U+02550 .. BOX DRAWINGS DOUBLE HORIZONTAL
+.. |boxh|  unicode:: U+02500 .. BOX DRAWINGS LIGHT HORIZONTAL
+.. |boxHD| unicode:: U+02566 .. BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL
+.. |boxHd| unicode:: U+02564 .. BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE
+.. |boxhD| unicode:: U+02565 .. BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE
+.. |boxhd| unicode:: U+0252C .. BOX DRAWINGS LIGHT DOWN AND HORIZONTAL
+.. |boxHU| unicode:: U+02569 .. BOX DRAWINGS DOUBLE UP AND HORIZONTAL
+.. |boxHu| unicode:: U+02567 .. BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE
+.. |boxhU| unicode:: U+02568 .. BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE
+.. |boxhu| unicode:: U+02534 .. BOX DRAWINGS LIGHT UP AND HORIZONTAL
+.. |boxUL| unicode:: U+0255D .. BOX DRAWINGS DOUBLE UP AND LEFT
+.. |boxUl| unicode:: U+0255C .. BOX DRAWINGS UP DOUBLE AND LEFT SINGLE
+.. |boxuL| unicode:: U+0255B .. BOX DRAWINGS UP SINGLE AND LEFT DOUBLE
+.. |boxul| unicode:: U+02518 .. BOX DRAWINGS LIGHT UP AND LEFT
+.. |boxUR| unicode:: U+0255A .. BOX DRAWINGS DOUBLE UP AND RIGHT
+.. |boxUr| unicode:: U+02559 .. BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE
+.. |boxuR| unicode:: U+02558 .. BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE
+.. |boxur| unicode:: U+02514 .. BOX DRAWINGS LIGHT UP AND RIGHT
+.. |boxV|  unicode:: U+02551 .. BOX DRAWINGS DOUBLE VERTICAL
+.. |boxv|  unicode:: U+02502 .. BOX DRAWINGS LIGHT VERTICAL
+.. |boxVH| unicode:: U+0256C .. BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL
+.. |boxVh| unicode:: U+0256B .. BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE
+.. |boxvH| unicode:: U+0256A .. BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE
+.. |boxvh| unicode:: U+0253C .. BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL
+.. |boxVL| unicode:: U+02563 .. BOX DRAWINGS DOUBLE VERTICAL AND LEFT
+.. |boxVl| unicode:: U+02562 .. BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE
+.. |boxvL| unicode:: U+02561 .. BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE
+.. |boxvl| unicode:: U+02524 .. BOX DRAWINGS LIGHT VERTICAL AND LEFT
+.. |boxVR| unicode:: U+02560 .. BOX DRAWINGS DOUBLE VERTICAL AND RIGHT
+.. |boxVr| unicode:: U+0255F .. BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE
+.. |boxvR| unicode:: U+0255E .. BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE
+.. |boxvr| unicode:: U+0251C .. BOX DRAWINGS LIGHT VERTICAL AND RIGHT
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isocyr1.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isocyr1.txt
new file mode 100644
index 00000000..5e0a18f5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isocyr1.txt
@@ -0,0 +1,73 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Acy|    unicode:: U+00410 .. CYRILLIC CAPITAL LETTER A
+.. |acy|    unicode:: U+00430 .. CYRILLIC SMALL LETTER A
+.. |Bcy|    unicode:: U+00411 .. CYRILLIC CAPITAL LETTER BE
+.. |bcy|    unicode:: U+00431 .. CYRILLIC SMALL LETTER BE
+.. |CHcy|   unicode:: U+00427 .. CYRILLIC CAPITAL LETTER CHE
+.. |chcy|   unicode:: U+00447 .. CYRILLIC SMALL LETTER CHE
+.. |Dcy|    unicode:: U+00414 .. CYRILLIC CAPITAL LETTER DE
+.. |dcy|    unicode:: U+00434 .. CYRILLIC SMALL LETTER DE
+.. |Ecy|    unicode:: U+0042D .. CYRILLIC CAPITAL LETTER E
+.. |ecy|    unicode:: U+0044D .. CYRILLIC SMALL LETTER E
+.. |Fcy|    unicode:: U+00424 .. CYRILLIC CAPITAL LETTER EF
+.. |fcy|    unicode:: U+00444 .. CYRILLIC SMALL LETTER EF
+.. |Gcy|    unicode:: U+00413 .. CYRILLIC CAPITAL LETTER GHE
+.. |gcy|    unicode:: U+00433 .. CYRILLIC SMALL LETTER GHE
+.. |HARDcy| unicode:: U+0042A .. CYRILLIC CAPITAL LETTER HARD SIGN
+.. |hardcy| unicode:: U+0044A .. CYRILLIC SMALL LETTER HARD SIGN
+.. |Icy|    unicode:: U+00418 .. CYRILLIC CAPITAL LETTER I
+.. |icy|    unicode:: U+00438 .. CYRILLIC SMALL LETTER I
+.. |IEcy|   unicode:: U+00415 .. CYRILLIC CAPITAL LETTER IE
+.. |iecy|   unicode:: U+00435 .. CYRILLIC SMALL LETTER IE
+.. |IOcy|   unicode:: U+00401 .. CYRILLIC CAPITAL LETTER IO
+.. |iocy|   unicode:: U+00451 .. CYRILLIC SMALL LETTER IO
+.. |Jcy|    unicode:: U+00419 .. CYRILLIC CAPITAL LETTER SHORT I
+.. |jcy|    unicode:: U+00439 .. CYRILLIC SMALL LETTER SHORT I
+.. |Kcy|    unicode:: U+0041A .. CYRILLIC CAPITAL LETTER KA
+.. |kcy|    unicode:: U+0043A .. CYRILLIC SMALL LETTER KA
+.. |KHcy|   unicode:: U+00425 .. CYRILLIC CAPITAL LETTER HA
+.. |khcy|   unicode:: U+00445 .. CYRILLIC SMALL LETTER HA
+.. |Lcy|    unicode:: U+0041B .. CYRILLIC CAPITAL LETTER EL
+.. |lcy|    unicode:: U+0043B .. CYRILLIC SMALL LETTER EL
+.. |Mcy|    unicode:: U+0041C .. CYRILLIC CAPITAL LETTER EM
+.. |mcy|    unicode:: U+0043C .. CYRILLIC SMALL LETTER EM
+.. |Ncy|    unicode:: U+0041D .. CYRILLIC CAPITAL LETTER EN
+.. |ncy|    unicode:: U+0043D .. CYRILLIC SMALL LETTER EN
+.. |numero| unicode:: U+02116 .. NUMERO SIGN
+.. |Ocy|    unicode:: U+0041E .. CYRILLIC CAPITAL LETTER O
+.. |ocy|    unicode:: U+0043E .. CYRILLIC SMALL LETTER O
+.. |Pcy|    unicode:: U+0041F .. CYRILLIC CAPITAL LETTER PE
+.. |pcy|    unicode:: U+0043F .. CYRILLIC SMALL LETTER PE
+.. |Rcy|    unicode:: U+00420 .. CYRILLIC CAPITAL LETTER ER
+.. |rcy|    unicode:: U+00440 .. CYRILLIC SMALL LETTER ER
+.. |Scy|    unicode:: U+00421 .. CYRILLIC CAPITAL LETTER ES
+.. |scy|    unicode:: U+00441 .. CYRILLIC SMALL LETTER ES
+.. |SHCHcy| unicode:: U+00429 .. CYRILLIC CAPITAL LETTER SHCHA
+.. |shchcy| unicode:: U+00449 .. CYRILLIC SMALL LETTER SHCHA
+.. |SHcy|   unicode:: U+00428 .. CYRILLIC CAPITAL LETTER SHA
+.. |shcy|   unicode:: U+00448 .. CYRILLIC SMALL LETTER SHA
+.. |SOFTcy| unicode:: U+0042C .. CYRILLIC CAPITAL LETTER SOFT SIGN
+.. |softcy| unicode:: U+0044C .. CYRILLIC SMALL LETTER SOFT SIGN
+.. |Tcy|    unicode:: U+00422 .. CYRILLIC CAPITAL LETTER TE
+.. |tcy|    unicode:: U+00442 .. CYRILLIC SMALL LETTER TE
+.. |TScy|   unicode:: U+00426 .. CYRILLIC CAPITAL LETTER TSE
+.. |tscy|   unicode:: U+00446 .. CYRILLIC SMALL LETTER TSE
+.. |Ucy|    unicode:: U+00423 .. CYRILLIC CAPITAL LETTER U
+.. |ucy|    unicode:: U+00443 .. CYRILLIC SMALL LETTER U
+.. |Vcy|    unicode:: U+00412 .. CYRILLIC CAPITAL LETTER VE
+.. |vcy|    unicode:: U+00432 .. CYRILLIC SMALL LETTER VE
+.. |YAcy|   unicode:: U+0042F .. CYRILLIC CAPITAL LETTER YA
+.. |yacy|   unicode:: U+0044F .. CYRILLIC SMALL LETTER YA
+.. |Ycy|    unicode:: U+0042B .. CYRILLIC CAPITAL LETTER YERU
+.. |ycy|    unicode:: U+0044B .. CYRILLIC SMALL LETTER YERU
+.. |YUcy|   unicode:: U+0042E .. CYRILLIC CAPITAL LETTER YU
+.. |yucy|   unicode:: U+0044E .. CYRILLIC SMALL LETTER YU
+.. |Zcy|    unicode:: U+00417 .. CYRILLIC CAPITAL LETTER ZE
+.. |zcy|    unicode:: U+00437 .. CYRILLIC SMALL LETTER ZE
+.. |ZHcy|   unicode:: U+00416 .. CYRILLIC CAPITAL LETTER ZHE
+.. |zhcy|   unicode:: U+00436 .. CYRILLIC SMALL LETTER ZHE
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isocyr2.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isocyr2.txt
new file mode 100644
index 00000000..a78190c0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isocyr2.txt
@@ -0,0 +1,32 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |DJcy|   unicode:: U+00402 .. CYRILLIC CAPITAL LETTER DJE
+.. |djcy|   unicode:: U+00452 .. CYRILLIC SMALL LETTER DJE
+.. |DScy|   unicode:: U+00405 .. CYRILLIC CAPITAL LETTER DZE
+.. |dscy|   unicode:: U+00455 .. CYRILLIC SMALL LETTER DZE
+.. |DZcy|   unicode:: U+0040F .. CYRILLIC CAPITAL LETTER DZHE
+.. |dzcy|   unicode:: U+0045F .. CYRILLIC SMALL LETTER DZHE
+.. |GJcy|   unicode:: U+00403 .. CYRILLIC CAPITAL LETTER GJE
+.. |gjcy|   unicode:: U+00453 .. CYRILLIC SMALL LETTER GJE
+.. |Iukcy|  unicode:: U+00406 .. CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I
+.. |iukcy|  unicode:: U+00456 .. CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I
+.. |Jsercy| unicode:: U+00408 .. CYRILLIC CAPITAL LETTER JE
+.. |jsercy| unicode:: U+00458 .. CYRILLIC SMALL LETTER JE
+.. |Jukcy|  unicode:: U+00404 .. CYRILLIC CAPITAL LETTER UKRAINIAN IE
+.. |jukcy|  unicode:: U+00454 .. CYRILLIC SMALL LETTER UKRAINIAN IE
+.. |KJcy|   unicode:: U+0040C .. CYRILLIC CAPITAL LETTER KJE
+.. |kjcy|   unicode:: U+0045C .. CYRILLIC SMALL LETTER KJE
+.. |LJcy|   unicode:: U+00409 .. CYRILLIC CAPITAL LETTER LJE
+.. |ljcy|   unicode:: U+00459 .. CYRILLIC SMALL LETTER LJE
+.. |NJcy|   unicode:: U+0040A .. CYRILLIC CAPITAL LETTER NJE
+.. |njcy|   unicode:: U+0045A .. CYRILLIC SMALL LETTER NJE
+.. |TSHcy|  unicode:: U+0040B .. CYRILLIC CAPITAL LETTER TSHE
+.. |tshcy|  unicode:: U+0045B .. CYRILLIC SMALL LETTER TSHE
+.. |Ubrcy|  unicode:: U+0040E .. CYRILLIC CAPITAL LETTER SHORT U
+.. |ubrcy|  unicode:: U+0045E .. CYRILLIC SMALL LETTER SHORT U
+.. |YIcy|   unicode:: U+00407 .. CYRILLIC CAPITAL LETTER YI
+.. |yicy|   unicode:: U+00457 .. CYRILLIC SMALL LETTER YI
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isodia.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isodia.txt
new file mode 100644
index 00000000..cfe403ab
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isodia.txt
@@ -0,0 +1,20 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |acute| unicode:: U+000B4 .. ACUTE ACCENT
+.. |breve| unicode:: U+002D8 .. BREVE
+.. |caron| unicode:: U+002C7 .. CARON
+.. |cedil| unicode:: U+000B8 .. CEDILLA
+.. |circ|  unicode:: U+002C6 .. MODIFIER LETTER CIRCUMFLEX ACCENT
+.. |dblac| unicode:: U+002DD .. DOUBLE ACUTE ACCENT
+.. |die|   unicode:: U+000A8 .. DIAERESIS
+.. |dot|   unicode:: U+002D9 .. DOT ABOVE
+.. |grave| unicode:: U+00060 .. GRAVE ACCENT
+.. |macr|  unicode:: U+000AF .. MACRON
+.. |ogon|  unicode:: U+002DB .. OGONEK
+.. |ring|  unicode:: U+002DA .. RING ABOVE
+.. |tilde| unicode:: U+002DC .. SMALL TILDE
+.. |uml|   unicode:: U+000A8 .. DIAERESIS
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk1.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk1.txt
new file mode 100644
index 00000000..22a414bb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk1.txt
@@ -0,0 +1,55 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Agr|  unicode:: U+00391 .. GREEK CAPITAL LETTER ALPHA
+.. |agr|  unicode:: U+003B1 .. GREEK SMALL LETTER ALPHA
+.. |Bgr|  unicode:: U+00392 .. GREEK CAPITAL LETTER BETA
+.. |bgr|  unicode:: U+003B2 .. GREEK SMALL LETTER BETA
+.. |Dgr|  unicode:: U+00394 .. GREEK CAPITAL LETTER DELTA
+.. |dgr|  unicode:: U+003B4 .. GREEK SMALL LETTER DELTA
+.. |EEgr| unicode:: U+00397 .. GREEK CAPITAL LETTER ETA
+.. |eegr| unicode:: U+003B7 .. GREEK SMALL LETTER ETA
+.. |Egr|  unicode:: U+00395 .. GREEK CAPITAL LETTER EPSILON
+.. |egr|  unicode:: U+003B5 .. GREEK SMALL LETTER EPSILON
+.. |Ggr|  unicode:: U+00393 .. GREEK CAPITAL LETTER GAMMA
+.. |ggr|  unicode:: U+003B3 .. GREEK SMALL LETTER GAMMA
+.. |Igr|  unicode:: U+00399 .. GREEK CAPITAL LETTER IOTA
+.. |igr|  unicode:: U+003B9 .. GREEK SMALL LETTER IOTA
+.. |Kgr|  unicode:: U+0039A .. GREEK CAPITAL LETTER KAPPA
+.. |kgr|  unicode:: U+003BA .. GREEK SMALL LETTER KAPPA
+.. |KHgr| unicode:: U+003A7 .. GREEK CAPITAL LETTER CHI
+.. |khgr| unicode:: U+003C7 .. GREEK SMALL LETTER CHI
+.. |Lgr|  unicode:: U+0039B .. GREEK CAPITAL LETTER LAMDA
+.. |lgr|  unicode:: U+003BB .. GREEK SMALL LETTER LAMDA
+.. |Mgr|  unicode:: U+0039C .. GREEK CAPITAL LETTER MU
+.. |mgr|  unicode:: U+003BC .. GREEK SMALL LETTER MU
+.. |Ngr|  unicode:: U+0039D .. GREEK CAPITAL LETTER NU
+.. |ngr|  unicode:: U+003BD .. GREEK SMALL LETTER NU
+.. |Ogr|  unicode:: U+0039F .. GREEK CAPITAL LETTER OMICRON
+.. |ogr|  unicode:: U+003BF .. GREEK SMALL LETTER OMICRON
+.. |OHgr| unicode:: U+003A9 .. GREEK CAPITAL LETTER OMEGA
+.. |ohgr| unicode:: U+003C9 .. GREEK SMALL LETTER OMEGA
+.. |Pgr|  unicode:: U+003A0 .. GREEK CAPITAL LETTER PI
+.. |pgr|  unicode:: U+003C0 .. GREEK SMALL LETTER PI
+.. |PHgr| unicode:: U+003A6 .. GREEK CAPITAL LETTER PHI
+.. |phgr| unicode:: U+003C6 .. GREEK SMALL LETTER PHI
+.. |PSgr| unicode:: U+003A8 .. GREEK CAPITAL LETTER PSI
+.. |psgr| unicode:: U+003C8 .. GREEK SMALL LETTER PSI
+.. |Rgr|  unicode:: U+003A1 .. GREEK CAPITAL LETTER RHO
+.. |rgr|  unicode:: U+003C1 .. GREEK SMALL LETTER RHO
+.. |sfgr| unicode:: U+003C2 .. GREEK SMALL LETTER FINAL SIGMA
+.. |Sgr|  unicode:: U+003A3 .. GREEK CAPITAL LETTER SIGMA
+.. |sgr|  unicode:: U+003C3 .. GREEK SMALL LETTER SIGMA
+.. |Tgr|  unicode:: U+003A4 .. GREEK CAPITAL LETTER TAU
+.. |tgr|  unicode:: U+003C4 .. GREEK SMALL LETTER TAU
+.. |THgr| unicode:: U+00398 .. GREEK CAPITAL LETTER THETA
+.. |thgr| unicode:: U+003B8 .. GREEK SMALL LETTER THETA
+.. |Ugr|  unicode:: U+003A5 .. GREEK CAPITAL LETTER UPSILON
+.. |ugr|  unicode:: U+003C5 .. GREEK SMALL LETTER UPSILON
+.. |Xgr|  unicode:: U+0039E .. GREEK CAPITAL LETTER XI
+.. |xgr|  unicode:: U+003BE .. GREEK SMALL LETTER XI
+.. |Zgr|  unicode:: U+00396 .. GREEK CAPITAL LETTER ZETA
+.. |zgr|  unicode:: U+003B6 .. GREEK SMALL LETTER ZETA
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk2.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk2.txt
new file mode 100644
index 00000000..4b4090ec
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk2.txt
@@ -0,0 +1,26 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Aacgr|  unicode:: U+00386 .. GREEK CAPITAL LETTER ALPHA WITH TONOS
+.. |aacgr|  unicode:: U+003AC .. GREEK SMALL LETTER ALPHA WITH TONOS
+.. |Eacgr|  unicode:: U+00388 .. GREEK CAPITAL LETTER EPSILON WITH TONOS
+.. |eacgr|  unicode:: U+003AD .. GREEK SMALL LETTER EPSILON WITH TONOS
+.. |EEacgr| unicode:: U+00389 .. GREEK CAPITAL LETTER ETA WITH TONOS
+.. |eeacgr| unicode:: U+003AE .. GREEK SMALL LETTER ETA WITH TONOS
+.. |Iacgr|  unicode:: U+0038A .. GREEK CAPITAL LETTER IOTA WITH TONOS
+.. |iacgr|  unicode:: U+003AF .. GREEK SMALL LETTER IOTA WITH TONOS
+.. |idiagr| unicode:: U+00390 .. GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
+.. |Idigr|  unicode:: U+003AA .. GREEK CAPITAL LETTER IOTA WITH DIALYTIKA
+.. |idigr|  unicode:: U+003CA .. GREEK SMALL LETTER IOTA WITH DIALYTIKA
+.. |Oacgr|  unicode:: U+0038C .. GREEK CAPITAL LETTER OMICRON WITH TONOS
+.. |oacgr|  unicode:: U+003CC .. GREEK SMALL LETTER OMICRON WITH TONOS
+.. |OHacgr| unicode:: U+0038F .. GREEK CAPITAL LETTER OMEGA WITH TONOS
+.. |ohacgr| unicode:: U+003CE .. GREEK SMALL LETTER OMEGA WITH TONOS
+.. |Uacgr|  unicode:: U+0038E .. GREEK CAPITAL LETTER UPSILON WITH TONOS
+.. |uacgr|  unicode:: U+003CD .. GREEK SMALL LETTER UPSILON WITH TONOS
+.. |udiagr| unicode:: U+003B0 .. GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
+.. |Udigr|  unicode:: U+003AB .. GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA
+.. |udigr|  unicode:: U+003CB .. GREEK SMALL LETTER UPSILON WITH DIALYTIKA
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk3.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk3.txt
new file mode 100644
index 00000000..54d212f2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk3.txt
@@ -0,0 +1,52 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |alpha|  unicode:: U+003B1 .. GREEK SMALL LETTER ALPHA
+.. |beta|   unicode:: U+003B2 .. GREEK SMALL LETTER BETA
+.. |chi|    unicode:: U+003C7 .. GREEK SMALL LETTER CHI
+.. |Delta|  unicode:: U+00394 .. GREEK CAPITAL LETTER DELTA
+.. |delta|  unicode:: U+003B4 .. GREEK SMALL LETTER DELTA
+.. |epsi|   unicode:: U+003F5 .. GREEK LUNATE EPSILON SYMBOL
+.. |epsis|  unicode:: U+003F5 .. GREEK LUNATE EPSILON SYMBOL
+.. |epsiv|  unicode:: U+003B5 .. GREEK SMALL LETTER EPSILON
+.. |eta|    unicode:: U+003B7 .. GREEK SMALL LETTER ETA
+.. |Gamma|  unicode:: U+00393 .. GREEK CAPITAL LETTER GAMMA
+.. |gamma|  unicode:: U+003B3 .. GREEK SMALL LETTER GAMMA
+.. |Gammad| unicode:: U+003DC .. GREEK LETTER DIGAMMA
+.. |gammad| unicode:: U+003DD .. GREEK SMALL LETTER DIGAMMA
+.. |iota|   unicode:: U+003B9 .. GREEK SMALL LETTER IOTA
+.. |kappa|  unicode:: U+003BA .. GREEK SMALL LETTER KAPPA
+.. |kappav| unicode:: U+003F0 .. GREEK KAPPA SYMBOL
+.. |Lambda| unicode:: U+0039B .. GREEK CAPITAL LETTER LAMDA
+.. |lambda| unicode:: U+003BB .. GREEK SMALL LETTER LAMDA
+.. |mu|     unicode:: U+003BC .. GREEK SMALL LETTER MU
+.. |nu|     unicode:: U+003BD .. GREEK SMALL LETTER NU
+.. |Omega|  unicode:: U+003A9 .. GREEK CAPITAL LETTER OMEGA
+.. |omega|  unicode:: U+003C9 .. GREEK SMALL LETTER OMEGA
+.. |Phi|    unicode:: U+003A6 .. GREEK CAPITAL LETTER PHI
+.. |phi|    unicode:: U+003D5 .. GREEK PHI SYMBOL
+.. |phis|   unicode:: U+003D5 .. GREEK PHI SYMBOL
+.. |phiv|   unicode:: U+003C6 .. GREEK SMALL LETTER PHI
+.. |Pi|     unicode:: U+003A0 .. GREEK CAPITAL LETTER PI
+.. |pi|     unicode:: U+003C0 .. GREEK SMALL LETTER PI
+.. |piv|    unicode:: U+003D6 .. GREEK PI SYMBOL
+.. |Psi|    unicode:: U+003A8 .. GREEK CAPITAL LETTER PSI
+.. |psi|    unicode:: U+003C8 .. GREEK SMALL LETTER PSI
+.. |rho|    unicode:: U+003C1 .. GREEK SMALL LETTER RHO
+.. |rhov|   unicode:: U+003F1 .. GREEK RHO SYMBOL
+.. |Sigma|  unicode:: U+003A3 .. GREEK CAPITAL LETTER SIGMA
+.. |sigma|  unicode:: U+003C3 .. GREEK SMALL LETTER SIGMA
+.. |sigmav| unicode:: U+003C2 .. GREEK SMALL LETTER FINAL SIGMA
+.. |tau|    unicode:: U+003C4 .. GREEK SMALL LETTER TAU
+.. |Theta|  unicode:: U+00398 .. GREEK CAPITAL LETTER THETA
+.. |theta|  unicode:: U+003B8 .. GREEK SMALL LETTER THETA
+.. |thetas| unicode:: U+003B8 .. GREEK SMALL LETTER THETA
+.. |thetav| unicode:: U+003D1 .. GREEK THETA SYMBOL
+.. |Upsi|   unicode:: U+003D2 .. GREEK UPSILON WITH HOOK SYMBOL
+.. |upsi|   unicode:: U+003C5 .. GREEK SMALL LETTER UPSILON
+.. |Xi|     unicode:: U+0039E .. GREEK CAPITAL LETTER XI
+.. |xi|     unicode:: U+003BE .. GREEK SMALL LETTER XI
+.. |zeta|   unicode:: U+003B6 .. GREEK SMALL LETTER ZETA
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk4-wide.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk4-wide.txt
new file mode 100644
index 00000000..c0e0238d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk4-wide.txt
@@ -0,0 +1,49 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |b.alpha|  unicode:: U+1D6C2 .. MATHEMATICAL BOLD SMALL ALPHA
+.. |b.beta|   unicode:: U+1D6C3 .. MATHEMATICAL BOLD SMALL BETA
+.. |b.chi|    unicode:: U+1D6D8 .. MATHEMATICAL BOLD SMALL CHI
+.. |b.Delta|  unicode:: U+1D6AB .. MATHEMATICAL BOLD CAPITAL DELTA
+.. |b.delta|  unicode:: U+1D6C5 .. MATHEMATICAL BOLD SMALL DELTA
+.. |b.epsi|   unicode:: U+1D6C6 .. MATHEMATICAL BOLD SMALL EPSILON
+.. |b.epsiv|  unicode:: U+1D6DC .. MATHEMATICAL BOLD EPSILON SYMBOL
+.. |b.eta|    unicode:: U+1D6C8 .. MATHEMATICAL BOLD SMALL ETA
+.. |b.Gamma|  unicode:: U+1D6AA .. MATHEMATICAL BOLD CAPITAL GAMMA
+.. |b.gamma|  unicode:: U+1D6C4 .. MATHEMATICAL BOLD SMALL GAMMA
+.. |b.Gammad| unicode:: U+003DC .. GREEK LETTER DIGAMMA
+.. |b.gammad| unicode:: U+003DD .. GREEK SMALL LETTER DIGAMMA
+.. |b.iota|   unicode:: U+1D6CA .. MATHEMATICAL BOLD SMALL IOTA
+.. |b.kappa|  unicode:: U+1D6CB .. MATHEMATICAL BOLD SMALL KAPPA
+.. |b.kappav| unicode:: U+1D6DE .. MATHEMATICAL BOLD KAPPA SYMBOL
+.. |b.Lambda| unicode:: U+1D6B2 .. MATHEMATICAL BOLD CAPITAL LAMDA
+.. |b.lambda| unicode:: U+1D6CC .. MATHEMATICAL BOLD SMALL LAMDA
+.. |b.mu|     unicode:: U+1D6CD .. MATHEMATICAL BOLD SMALL MU
+.. |b.nu|     unicode:: U+1D6CE .. MATHEMATICAL BOLD SMALL NU
+.. |b.Omega|  unicode:: U+1D6C0 .. MATHEMATICAL BOLD CAPITAL OMEGA
+.. |b.omega|  unicode:: U+1D6DA .. MATHEMATICAL BOLD SMALL OMEGA
+.. |b.Phi|    unicode:: U+1D6BD .. MATHEMATICAL BOLD CAPITAL PHI
+.. |b.phi|    unicode:: U+1D6D7 .. MATHEMATICAL BOLD SMALL PHI
+.. |b.phiv|   unicode:: U+1D6DF .. MATHEMATICAL BOLD PHI SYMBOL
+.. |b.Pi|     unicode:: U+1D6B7 .. MATHEMATICAL BOLD CAPITAL PI
+.. |b.pi|     unicode:: U+1D6D1 .. MATHEMATICAL BOLD SMALL PI
+.. |b.piv|    unicode:: U+1D6E1 .. MATHEMATICAL BOLD PI SYMBOL
+.. |b.Psi|    unicode:: U+1D6BF .. MATHEMATICAL BOLD CAPITAL PSI
+.. |b.psi|    unicode:: U+1D6D9 .. MATHEMATICAL BOLD SMALL PSI
+.. |b.rho|    unicode:: U+1D6D2 .. MATHEMATICAL BOLD SMALL RHO
+.. |b.rhov|   unicode:: U+1D6E0 .. MATHEMATICAL BOLD RHO SYMBOL
+.. |b.Sigma|  unicode:: U+1D6BA .. MATHEMATICAL BOLD CAPITAL SIGMA
+.. |b.sigma|  unicode:: U+1D6D4 .. MATHEMATICAL BOLD SMALL SIGMA
+.. |b.sigmav| unicode:: U+1D6D3 .. MATHEMATICAL BOLD SMALL FINAL SIGMA
+.. |b.tau|    unicode:: U+1D6D5 .. MATHEMATICAL BOLD SMALL TAU
+.. |b.Theta|  unicode:: U+1D6AF .. MATHEMATICAL BOLD CAPITAL THETA
+.. |b.thetas| unicode:: U+1D6C9 .. MATHEMATICAL BOLD SMALL THETA
+.. |b.thetav| unicode:: U+1D6DD .. MATHEMATICAL BOLD THETA SYMBOL
+.. |b.Upsi|   unicode:: U+1D6BC .. MATHEMATICAL BOLD CAPITAL UPSILON
+.. |b.upsi|   unicode:: U+1D6D6 .. MATHEMATICAL BOLD SMALL UPSILON
+.. |b.Xi|     unicode:: U+1D6B5 .. MATHEMATICAL BOLD CAPITAL XI
+.. |b.xi|     unicode:: U+1D6CF .. MATHEMATICAL BOLD SMALL XI
+.. |b.zeta|   unicode:: U+1D6C7 .. MATHEMATICAL BOLD SMALL ZETA
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk4.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk4.txt
new file mode 100644
index 00000000..836b6bd7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isogrk4.txt
@@ -0,0 +1,8 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |b.Gammad| unicode:: U+003DC .. GREEK LETTER DIGAMMA
+.. |b.gammad| unicode:: U+003DD .. GREEK SMALL LETTER DIGAMMA
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isolat1.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isolat1.txt
new file mode 100644
index 00000000..4e4202b7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isolat1.txt
@@ -0,0 +1,68 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Aacute| unicode:: U+000C1 .. LATIN CAPITAL LETTER A WITH ACUTE
+.. |aacute| unicode:: U+000E1 .. LATIN SMALL LETTER A WITH ACUTE
+.. |Acirc|  unicode:: U+000C2 .. LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+.. |acirc|  unicode:: U+000E2 .. LATIN SMALL LETTER A WITH CIRCUMFLEX
+.. |AElig|  unicode:: U+000C6 .. LATIN CAPITAL LETTER AE
+.. |aelig|  unicode:: U+000E6 .. LATIN SMALL LETTER AE
+.. |Agrave| unicode:: U+000C0 .. LATIN CAPITAL LETTER A WITH GRAVE
+.. |agrave| unicode:: U+000E0 .. LATIN SMALL LETTER A WITH GRAVE
+.. |Aring|  unicode:: U+000C5 .. LATIN CAPITAL LETTER A WITH RING ABOVE
+.. |aring|  unicode:: U+000E5 .. LATIN SMALL LETTER A WITH RING ABOVE
+.. |Atilde| unicode:: U+000C3 .. LATIN CAPITAL LETTER A WITH TILDE
+.. |atilde| unicode:: U+000E3 .. LATIN SMALL LETTER A WITH TILDE
+.. |Auml|   unicode:: U+000C4 .. LATIN CAPITAL LETTER A WITH DIAERESIS
+.. |auml|   unicode:: U+000E4 .. LATIN SMALL LETTER A WITH DIAERESIS
+.. |Ccedil| unicode:: U+000C7 .. LATIN CAPITAL LETTER C WITH CEDILLA
+.. |ccedil| unicode:: U+000E7 .. LATIN SMALL LETTER C WITH CEDILLA
+.. |Eacute| unicode:: U+000C9 .. LATIN CAPITAL LETTER E WITH ACUTE
+.. |eacute| unicode:: U+000E9 .. LATIN SMALL LETTER E WITH ACUTE
+.. |Ecirc|  unicode:: U+000CA .. LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+.. |ecirc|  unicode:: U+000EA .. LATIN SMALL LETTER E WITH CIRCUMFLEX
+.. |Egrave| unicode:: U+000C8 .. LATIN CAPITAL LETTER E WITH GRAVE
+.. |egrave| unicode:: U+000E8 .. LATIN SMALL LETTER E WITH GRAVE
+.. |ETH|    unicode:: U+000D0 .. LATIN CAPITAL LETTER ETH
+.. |eth|    unicode:: U+000F0 .. LATIN SMALL LETTER ETH
+.. |Euml|   unicode:: U+000CB .. LATIN CAPITAL LETTER E WITH DIAERESIS
+.. |euml|   unicode:: U+000EB .. LATIN SMALL LETTER E WITH DIAERESIS
+.. |Iacute| unicode:: U+000CD .. LATIN CAPITAL LETTER I WITH ACUTE
+.. |iacute| unicode:: U+000ED .. LATIN SMALL LETTER I WITH ACUTE
+.. |Icirc|  unicode:: U+000CE .. LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+.. |icirc|  unicode:: U+000EE .. LATIN SMALL LETTER I WITH CIRCUMFLEX
+.. |Igrave| unicode:: U+000CC .. LATIN CAPITAL LETTER I WITH GRAVE
+.. |igrave| unicode:: U+000EC .. LATIN SMALL LETTER I WITH GRAVE
+.. |Iuml|   unicode:: U+000CF .. LATIN CAPITAL LETTER I WITH DIAERESIS
+.. |iuml|   unicode:: U+000EF .. LATIN SMALL LETTER I WITH DIAERESIS
+.. |Ntilde| unicode:: U+000D1 .. LATIN CAPITAL LETTER N WITH TILDE
+.. |ntilde| unicode:: U+000F1 .. LATIN SMALL LETTER N WITH TILDE
+.. |Oacute| unicode:: U+000D3 .. LATIN CAPITAL LETTER O WITH ACUTE
+.. |oacute| unicode:: U+000F3 .. LATIN SMALL LETTER O WITH ACUTE
+.. |Ocirc|  unicode:: U+000D4 .. LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+.. |ocirc|  unicode:: U+000F4 .. LATIN SMALL LETTER O WITH CIRCUMFLEX
+.. |Ograve| unicode:: U+000D2 .. LATIN CAPITAL LETTER O WITH GRAVE
+.. |ograve| unicode:: U+000F2 .. LATIN SMALL LETTER O WITH GRAVE
+.. |Oslash| unicode:: U+000D8 .. LATIN CAPITAL LETTER O WITH STROKE
+.. |oslash| unicode:: U+000F8 .. LATIN SMALL LETTER O WITH STROKE
+.. |Otilde| unicode:: U+000D5 .. LATIN CAPITAL LETTER O WITH TILDE
+.. |otilde| unicode:: U+000F5 .. LATIN SMALL LETTER O WITH TILDE
+.. |Ouml|   unicode:: U+000D6 .. LATIN CAPITAL LETTER O WITH DIAERESIS
+.. |ouml|   unicode:: U+000F6 .. LATIN SMALL LETTER O WITH DIAERESIS
+.. |szlig|  unicode:: U+000DF .. LATIN SMALL LETTER SHARP S
+.. |THORN|  unicode:: U+000DE .. LATIN CAPITAL LETTER THORN
+.. |thorn|  unicode:: U+000FE .. LATIN SMALL LETTER THORN
+.. |Uacute| unicode:: U+000DA .. LATIN CAPITAL LETTER U WITH ACUTE
+.. |uacute| unicode:: U+000FA .. LATIN SMALL LETTER U WITH ACUTE
+.. |Ucirc|  unicode:: U+000DB .. LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+.. |ucirc|  unicode:: U+000FB .. LATIN SMALL LETTER U WITH CIRCUMFLEX
+.. |Ugrave| unicode:: U+000D9 .. LATIN CAPITAL LETTER U WITH GRAVE
+.. |ugrave| unicode:: U+000F9 .. LATIN SMALL LETTER U WITH GRAVE
+.. |Uuml|   unicode:: U+000DC .. LATIN CAPITAL LETTER U WITH DIAERESIS
+.. |uuml|   unicode:: U+000FC .. LATIN SMALL LETTER U WITH DIAERESIS
+.. |Yacute| unicode:: U+000DD .. LATIN CAPITAL LETTER Y WITH ACUTE
+.. |yacute| unicode:: U+000FD .. LATIN SMALL LETTER Y WITH ACUTE
+.. |yuml|   unicode:: U+000FF .. LATIN SMALL LETTER Y WITH DIAERESIS
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isolat2.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isolat2.txt
new file mode 100644
index 00000000..808ef937
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isolat2.txt
@@ -0,0 +1,128 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Abreve| unicode:: U+00102 .. LATIN CAPITAL LETTER A WITH BREVE
+.. |abreve| unicode:: U+00103 .. LATIN SMALL LETTER A WITH BREVE
+.. |Amacr|  unicode:: U+00100 .. LATIN CAPITAL LETTER A WITH MACRON
+.. |amacr|  unicode:: U+00101 .. LATIN SMALL LETTER A WITH MACRON
+.. |Aogon|  unicode:: U+00104 .. LATIN CAPITAL LETTER A WITH OGONEK
+.. |aogon|  unicode:: U+00105 .. LATIN SMALL LETTER A WITH OGONEK
+.. |Cacute| unicode:: U+00106 .. LATIN CAPITAL LETTER C WITH ACUTE
+.. |cacute| unicode:: U+00107 .. LATIN SMALL LETTER C WITH ACUTE
+.. |Ccaron| unicode:: U+0010C .. LATIN CAPITAL LETTER C WITH CARON
+.. |ccaron| unicode:: U+0010D .. LATIN SMALL LETTER C WITH CARON
+.. |Ccirc|  unicode:: U+00108 .. LATIN CAPITAL LETTER C WITH CIRCUMFLEX
+.. |ccirc|  unicode:: U+00109 .. LATIN SMALL LETTER C WITH CIRCUMFLEX
+.. |Cdot|   unicode:: U+0010A .. LATIN CAPITAL LETTER C WITH DOT ABOVE
+.. |cdot|   unicode:: U+0010B .. LATIN SMALL LETTER C WITH DOT ABOVE
+.. |Dcaron| unicode:: U+0010E .. LATIN CAPITAL LETTER D WITH CARON
+.. |dcaron| unicode:: U+0010F .. LATIN SMALL LETTER D WITH CARON
+.. |Dstrok| unicode:: U+00110 .. LATIN CAPITAL LETTER D WITH STROKE
+.. |dstrok| unicode:: U+00111 .. LATIN SMALL LETTER D WITH STROKE
+.. |Ecaron| unicode:: U+0011A .. LATIN CAPITAL LETTER E WITH CARON
+.. |ecaron| unicode:: U+0011B .. LATIN SMALL LETTER E WITH CARON
+.. |Edot|   unicode:: U+00116 .. LATIN CAPITAL LETTER E WITH DOT ABOVE
+.. |edot|   unicode:: U+00117 .. LATIN SMALL LETTER E WITH DOT ABOVE
+.. |Emacr|  unicode:: U+00112 .. LATIN CAPITAL LETTER E WITH MACRON
+.. |emacr|  unicode:: U+00113 .. LATIN SMALL LETTER E WITH MACRON
+.. |ENG|    unicode:: U+0014A .. LATIN CAPITAL LETTER ENG
+.. |eng|    unicode:: U+0014B .. LATIN SMALL LETTER ENG
+.. |Eogon|  unicode:: U+00118 .. LATIN CAPITAL LETTER E WITH OGONEK
+.. |eogon|  unicode:: U+00119 .. LATIN SMALL LETTER E WITH OGONEK
+.. |gacute| unicode:: U+001F5 .. LATIN SMALL LETTER G WITH ACUTE
+.. |Gbreve| unicode:: U+0011E .. LATIN CAPITAL LETTER G WITH BREVE
+.. |gbreve| unicode:: U+0011F .. LATIN SMALL LETTER G WITH BREVE
+.. |Gcedil| unicode:: U+00122 .. LATIN CAPITAL LETTER G WITH CEDILLA
+.. |gcedil| unicode:: U+00123 .. LATIN SMALL LETTER G WITH CEDILLA
+.. |Gcirc|  unicode:: U+0011C .. LATIN CAPITAL LETTER G WITH CIRCUMFLEX
+.. |gcirc|  unicode:: U+0011D .. LATIN SMALL LETTER G WITH CIRCUMFLEX
+.. |Gdot|   unicode:: U+00120 .. LATIN CAPITAL LETTER G WITH DOT ABOVE
+.. |gdot|   unicode:: U+00121 .. LATIN SMALL LETTER G WITH DOT ABOVE
+.. |Hcirc|  unicode:: U+00124 .. LATIN CAPITAL LETTER H WITH CIRCUMFLEX
+.. |hcirc|  unicode:: U+00125 .. LATIN SMALL LETTER H WITH CIRCUMFLEX
+.. |Hstrok| unicode:: U+00126 .. LATIN CAPITAL LETTER H WITH STROKE
+.. |hstrok| unicode:: U+00127 .. LATIN SMALL LETTER H WITH STROKE
+.. |Idot|   unicode:: U+00130 .. LATIN CAPITAL LETTER I WITH DOT ABOVE
+.. |IJlig|  unicode:: U+00132 .. LATIN CAPITAL LIGATURE IJ
+.. |ijlig|  unicode:: U+00133 .. LATIN SMALL LIGATURE IJ
+.. |Imacr|  unicode:: U+0012A .. LATIN CAPITAL LETTER I WITH MACRON
+.. |imacr|  unicode:: U+0012B .. LATIN SMALL LETTER I WITH MACRON
+.. |inodot| unicode:: U+00131 .. LATIN SMALL LETTER DOTLESS I
+.. |Iogon|  unicode:: U+0012E .. LATIN CAPITAL LETTER I WITH OGONEK
+.. |iogon|  unicode:: U+0012F .. LATIN SMALL LETTER I WITH OGONEK
+.. |Itilde| unicode:: U+00128 .. LATIN CAPITAL LETTER I WITH TILDE
+.. |itilde| unicode:: U+00129 .. LATIN SMALL LETTER I WITH TILDE
+.. |Jcirc|  unicode:: U+00134 .. LATIN CAPITAL LETTER J WITH CIRCUMFLEX
+.. |jcirc|  unicode:: U+00135 .. LATIN SMALL LETTER J WITH CIRCUMFLEX
+.. |Kcedil| unicode:: U+00136 .. LATIN CAPITAL LETTER K WITH CEDILLA
+.. |kcedil| unicode:: U+00137 .. LATIN SMALL LETTER K WITH CEDILLA
+.. |kgreen| unicode:: U+00138 .. LATIN SMALL LETTER KRA
+.. |Lacute| unicode:: U+00139 .. LATIN CAPITAL LETTER L WITH ACUTE
+.. |lacute| unicode:: U+0013A .. LATIN SMALL LETTER L WITH ACUTE
+.. |Lcaron| unicode:: U+0013D .. LATIN CAPITAL LETTER L WITH CARON
+.. |lcaron| unicode:: U+0013E .. LATIN SMALL LETTER L WITH CARON
+.. |Lcedil| unicode:: U+0013B .. LATIN CAPITAL LETTER L WITH CEDILLA
+.. |lcedil| unicode:: U+0013C .. LATIN SMALL LETTER L WITH CEDILLA
+.. |Lmidot| unicode:: U+0013F .. LATIN CAPITAL LETTER L WITH MIDDLE DOT
+.. |lmidot| unicode:: U+00140 .. LATIN SMALL LETTER L WITH MIDDLE DOT
+.. |Lstrok| unicode:: U+00141 .. LATIN CAPITAL LETTER L WITH STROKE
+.. |lstrok| unicode:: U+00142 .. LATIN SMALL LETTER L WITH STROKE
+.. |Nacute| unicode:: U+00143 .. LATIN CAPITAL LETTER N WITH ACUTE
+.. |nacute| unicode:: U+00144 .. LATIN SMALL LETTER N WITH ACUTE
+.. |napos|  unicode:: U+00149 .. LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
+.. |Ncaron| unicode:: U+00147 .. LATIN CAPITAL LETTER N WITH CARON
+.. |ncaron| unicode:: U+00148 .. LATIN SMALL LETTER N WITH CARON
+.. |Ncedil| unicode:: U+00145 .. LATIN CAPITAL LETTER N WITH CEDILLA
+.. |ncedil| unicode:: U+00146 .. LATIN SMALL LETTER N WITH CEDILLA
+.. |Odblac| unicode:: U+00150 .. LATIN CAPITAL LETTER O WITH DOUBLE ACUTE
+.. |odblac| unicode:: U+00151 .. LATIN SMALL LETTER O WITH DOUBLE ACUTE
+.. |OElig|  unicode:: U+00152 .. LATIN CAPITAL LIGATURE OE
+.. |oelig|  unicode:: U+00153 .. LATIN SMALL LIGATURE OE
+.. |Omacr|  unicode:: U+0014C .. LATIN CAPITAL LETTER O WITH MACRON
+.. |omacr|  unicode:: U+0014D .. LATIN SMALL LETTER O WITH MACRON
+.. |Racute| unicode:: U+00154 .. LATIN CAPITAL LETTER R WITH ACUTE
+.. |racute| unicode:: U+00155 .. LATIN SMALL LETTER R WITH ACUTE
+.. |Rcaron| unicode:: U+00158 .. LATIN CAPITAL LETTER R WITH CARON
+.. |rcaron| unicode:: U+00159 .. LATIN SMALL LETTER R WITH CARON
+.. |Rcedil| unicode:: U+00156 .. LATIN CAPITAL LETTER R WITH CEDILLA
+.. |rcedil| unicode:: U+00157 .. LATIN SMALL LETTER R WITH CEDILLA
+.. |Sacute| unicode:: U+0015A .. LATIN CAPITAL LETTER S WITH ACUTE
+.. |sacute| unicode:: U+0015B .. LATIN SMALL LETTER S WITH ACUTE
+.. |Scaron| unicode:: U+00160 .. LATIN CAPITAL LETTER S WITH CARON
+.. |scaron| unicode:: U+00161 .. LATIN SMALL LETTER S WITH CARON
+.. |Scedil| unicode:: U+0015E .. LATIN CAPITAL LETTER S WITH CEDILLA
+.. |scedil| unicode:: U+0015F .. LATIN SMALL LETTER S WITH CEDILLA
+.. |Scirc|  unicode:: U+0015C .. LATIN CAPITAL LETTER S WITH CIRCUMFLEX
+.. |scirc|  unicode:: U+0015D .. LATIN SMALL LETTER S WITH CIRCUMFLEX
+.. |Tcaron| unicode:: U+00164 .. LATIN CAPITAL LETTER T WITH CARON
+.. |tcaron| unicode:: U+00165 .. LATIN SMALL LETTER T WITH CARON
+.. |Tcedil| unicode:: U+00162 .. LATIN CAPITAL LETTER T WITH CEDILLA
+.. |tcedil| unicode:: U+00163 .. LATIN SMALL LETTER T WITH CEDILLA
+.. |Tstrok| unicode:: U+00166 .. LATIN CAPITAL LETTER T WITH STROKE
+.. |tstrok| unicode:: U+00167 .. LATIN SMALL LETTER T WITH STROKE
+.. |Ubreve| unicode:: U+0016C .. LATIN CAPITAL LETTER U WITH BREVE
+.. |ubreve| unicode:: U+0016D .. LATIN SMALL LETTER U WITH BREVE
+.. |Udblac| unicode:: U+00170 .. LATIN CAPITAL LETTER U WITH DOUBLE ACUTE
+.. |udblac| unicode:: U+00171 .. LATIN SMALL LETTER U WITH DOUBLE ACUTE
+.. |Umacr|  unicode:: U+0016A .. LATIN CAPITAL LETTER U WITH MACRON
+.. |umacr|  unicode:: U+0016B .. LATIN SMALL LETTER U WITH MACRON
+.. |Uogon|  unicode:: U+00172 .. LATIN CAPITAL LETTER U WITH OGONEK
+.. |uogon|  unicode:: U+00173 .. LATIN SMALL LETTER U WITH OGONEK
+.. |Uring|  unicode:: U+0016E .. LATIN CAPITAL LETTER U WITH RING ABOVE
+.. |uring|  unicode:: U+0016F .. LATIN SMALL LETTER U WITH RING ABOVE
+.. |Utilde| unicode:: U+00168 .. LATIN CAPITAL LETTER U WITH TILDE
+.. |utilde| unicode:: U+00169 .. LATIN SMALL LETTER U WITH TILDE
+.. |Wcirc|  unicode:: U+00174 .. LATIN CAPITAL LETTER W WITH CIRCUMFLEX
+.. |wcirc|  unicode:: U+00175 .. LATIN SMALL LETTER W WITH CIRCUMFLEX
+.. |Ycirc|  unicode:: U+00176 .. LATIN CAPITAL LETTER Y WITH CIRCUMFLEX
+.. |ycirc|  unicode:: U+00177 .. LATIN SMALL LETTER Y WITH CIRCUMFLEX
+.. |Yuml|   unicode:: U+00178 .. LATIN CAPITAL LETTER Y WITH DIAERESIS
+.. |Zacute| unicode:: U+00179 .. LATIN CAPITAL LETTER Z WITH ACUTE
+.. |zacute| unicode:: U+0017A .. LATIN SMALL LETTER Z WITH ACUTE
+.. |Zcaron| unicode:: U+0017D .. LATIN CAPITAL LETTER Z WITH CARON
+.. |zcaron| unicode:: U+0017E .. LATIN SMALL LETTER Z WITH CARON
+.. |Zdot|   unicode:: U+0017B .. LATIN CAPITAL LETTER Z WITH DOT ABOVE
+.. |zdot|   unicode:: U+0017C .. LATIN SMALL LETTER Z WITH DOT ABOVE
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomfrk-wide.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomfrk-wide.txt
new file mode 100644
index 00000000..73768bcc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomfrk-wide.txt
@@ -0,0 +1,58 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Afr| unicode:: U+1D504 .. MATHEMATICAL FRAKTUR CAPITAL A
+.. |afr| unicode:: U+1D51E .. MATHEMATICAL FRAKTUR SMALL A
+.. |Bfr| unicode:: U+1D505 .. MATHEMATICAL FRAKTUR CAPITAL B
+.. |bfr| unicode:: U+1D51F .. MATHEMATICAL FRAKTUR SMALL B
+.. |Cfr| unicode:: U+0212D .. BLACK-LETTER CAPITAL C
+.. |cfr| unicode:: U+1D520 .. MATHEMATICAL FRAKTUR SMALL C
+.. |Dfr| unicode:: U+1D507 .. MATHEMATICAL FRAKTUR CAPITAL D
+.. |dfr| unicode:: U+1D521 .. MATHEMATICAL FRAKTUR SMALL D
+.. |Efr| unicode:: U+1D508 .. MATHEMATICAL FRAKTUR CAPITAL E
+.. |efr| unicode:: U+1D522 .. MATHEMATICAL FRAKTUR SMALL E
+.. |Ffr| unicode:: U+1D509 .. MATHEMATICAL FRAKTUR CAPITAL F
+.. |ffr| unicode:: U+1D523 .. MATHEMATICAL FRAKTUR SMALL F
+.. |Gfr| unicode:: U+1D50A .. MATHEMATICAL FRAKTUR CAPITAL G
+.. |gfr| unicode:: U+1D524 .. MATHEMATICAL FRAKTUR SMALL G
+.. |Hfr| unicode:: U+0210C .. BLACK-LETTER CAPITAL H
+.. |hfr| unicode:: U+1D525 .. MATHEMATICAL FRAKTUR SMALL H
+.. |Ifr| unicode:: U+02111 .. BLACK-LETTER CAPITAL I
+.. |ifr| unicode:: U+1D526 .. MATHEMATICAL FRAKTUR SMALL I
+.. |Jfr| unicode:: U+1D50D .. MATHEMATICAL FRAKTUR CAPITAL J
+.. |jfr| unicode:: U+1D527 .. MATHEMATICAL FRAKTUR SMALL J
+.. |Kfr| unicode:: U+1D50E .. MATHEMATICAL FRAKTUR CAPITAL K
+.. |kfr| unicode:: U+1D528 .. MATHEMATICAL FRAKTUR SMALL K
+.. |Lfr| unicode:: U+1D50F .. MATHEMATICAL FRAKTUR CAPITAL L
+.. |lfr| unicode:: U+1D529 .. MATHEMATICAL FRAKTUR SMALL L
+.. |Mfr| unicode:: U+1D510 .. MATHEMATICAL FRAKTUR CAPITAL M
+.. |mfr| unicode:: U+1D52A .. MATHEMATICAL FRAKTUR SMALL M
+.. |Nfr| unicode:: U+1D511 .. MATHEMATICAL FRAKTUR CAPITAL N
+.. |nfr| unicode:: U+1D52B .. MATHEMATICAL FRAKTUR SMALL N
+.. |Ofr| unicode:: U+1D512 .. MATHEMATICAL FRAKTUR CAPITAL O
+.. |ofr| unicode:: U+1D52C .. MATHEMATICAL FRAKTUR SMALL O
+.. |Pfr| unicode:: U+1D513 .. MATHEMATICAL FRAKTUR CAPITAL P
+.. |pfr| unicode:: U+1D52D .. MATHEMATICAL FRAKTUR SMALL P
+.. |Qfr| unicode:: U+1D514 .. MATHEMATICAL FRAKTUR CAPITAL Q
+.. |qfr| unicode:: U+1D52E .. MATHEMATICAL FRAKTUR SMALL Q
+.. |Rfr| unicode:: U+0211C .. BLACK-LETTER CAPITAL R
+.. |rfr| unicode:: U+1D52F .. MATHEMATICAL FRAKTUR SMALL R
+.. |Sfr| unicode:: U+1D516 .. MATHEMATICAL FRAKTUR CAPITAL S
+.. |sfr| unicode:: U+1D530 .. MATHEMATICAL FRAKTUR SMALL S
+.. |Tfr| unicode:: U+1D517 .. MATHEMATICAL FRAKTUR CAPITAL T
+.. |tfr| unicode:: U+1D531 .. MATHEMATICAL FRAKTUR SMALL T
+.. |Ufr| unicode:: U+1D518 .. MATHEMATICAL FRAKTUR CAPITAL U
+.. |ufr| unicode:: U+1D532 .. MATHEMATICAL FRAKTUR SMALL U
+.. |Vfr| unicode:: U+1D519 .. MATHEMATICAL FRAKTUR CAPITAL V
+.. |vfr| unicode:: U+1D533 .. MATHEMATICAL FRAKTUR SMALL V
+.. |Wfr| unicode:: U+1D51A .. MATHEMATICAL FRAKTUR CAPITAL W
+.. |wfr| unicode:: U+1D534 .. MATHEMATICAL FRAKTUR SMALL W
+.. |Xfr| unicode:: U+1D51B .. MATHEMATICAL FRAKTUR CAPITAL X
+.. |xfr| unicode:: U+1D535 .. MATHEMATICAL FRAKTUR SMALL X
+.. |Yfr| unicode:: U+1D51C .. MATHEMATICAL FRAKTUR CAPITAL Y
+.. |yfr| unicode:: U+1D536 .. MATHEMATICAL FRAKTUR SMALL Y
+.. |Zfr| unicode:: U+02128 .. BLACK-LETTER CAPITAL Z
+.. |zfr| unicode:: U+1D537 .. MATHEMATICAL FRAKTUR SMALL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomfrk.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomfrk.txt
new file mode 100644
index 00000000..81dd4b6e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomfrk.txt
@@ -0,0 +1,11 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Cfr| unicode:: U+0212D .. BLACK-LETTER CAPITAL C
+.. |Hfr| unicode:: U+0210C .. BLACK-LETTER CAPITAL H
+.. |Ifr| unicode:: U+02111 .. BLACK-LETTER CAPITAL I
+.. |Rfr| unicode:: U+0211C .. BLACK-LETTER CAPITAL R
+.. |Zfr| unicode:: U+02128 .. BLACK-LETTER CAPITAL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomopf-wide.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomopf-wide.txt
new file mode 100644
index 00000000..2c16866e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomopf-wide.txt
@@ -0,0 +1,32 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Aopf| unicode:: U+1D538 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL A
+.. |Bopf| unicode:: U+1D539 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL B
+.. |Copf| unicode:: U+02102 .. DOUBLE-STRUCK CAPITAL C
+.. |Dopf| unicode:: U+1D53B .. MATHEMATICAL DOUBLE-STRUCK CAPITAL D
+.. |Eopf| unicode:: U+1D53C .. MATHEMATICAL DOUBLE-STRUCK CAPITAL E
+.. |Fopf| unicode:: U+1D53D .. MATHEMATICAL DOUBLE-STRUCK CAPITAL F
+.. |Gopf| unicode:: U+1D53E .. MATHEMATICAL DOUBLE-STRUCK CAPITAL G
+.. |Hopf| unicode:: U+0210D .. DOUBLE-STRUCK CAPITAL H
+.. |Iopf| unicode:: U+1D540 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL I
+.. |Jopf| unicode:: U+1D541 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL J
+.. |Kopf| unicode:: U+1D542 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL K
+.. |Lopf| unicode:: U+1D543 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL L
+.. |Mopf| unicode:: U+1D544 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL M
+.. |Nopf| unicode:: U+02115 .. DOUBLE-STRUCK CAPITAL N
+.. |Oopf| unicode:: U+1D546 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL O
+.. |Popf| unicode:: U+02119 .. DOUBLE-STRUCK CAPITAL P
+.. |Qopf| unicode:: U+0211A .. DOUBLE-STRUCK CAPITAL Q
+.. |Ropf| unicode:: U+0211D .. DOUBLE-STRUCK CAPITAL R
+.. |Sopf| unicode:: U+1D54A .. MATHEMATICAL DOUBLE-STRUCK CAPITAL S
+.. |Topf| unicode:: U+1D54B .. MATHEMATICAL DOUBLE-STRUCK CAPITAL T
+.. |Uopf| unicode:: U+1D54C .. MATHEMATICAL DOUBLE-STRUCK CAPITAL U
+.. |Vopf| unicode:: U+1D54D .. MATHEMATICAL DOUBLE-STRUCK CAPITAL V
+.. |Wopf| unicode:: U+1D54E .. MATHEMATICAL DOUBLE-STRUCK CAPITAL W
+.. |Xopf| unicode:: U+1D54F .. MATHEMATICAL DOUBLE-STRUCK CAPITAL X
+.. |Yopf| unicode:: U+1D550 .. MATHEMATICAL DOUBLE-STRUCK CAPITAL Y
+.. |Zopf| unicode:: U+02124 .. DOUBLE-STRUCK CAPITAL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomopf.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomopf.txt
new file mode 100644
index 00000000..03c6a0d2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomopf.txt
@@ -0,0 +1,13 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Copf| unicode:: U+02102 .. DOUBLE-STRUCK CAPITAL C
+.. |Hopf| unicode:: U+0210D .. DOUBLE-STRUCK CAPITAL H
+.. |Nopf| unicode:: U+02115 .. DOUBLE-STRUCK CAPITAL N
+.. |Popf| unicode:: U+02119 .. DOUBLE-STRUCK CAPITAL P
+.. |Qopf| unicode:: U+0211A .. DOUBLE-STRUCK CAPITAL Q
+.. |Ropf| unicode:: U+0211D .. DOUBLE-STRUCK CAPITAL R
+.. |Zopf| unicode:: U+02124 .. DOUBLE-STRUCK CAPITAL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomscr-wide.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomscr-wide.txt
new file mode 100644
index 00000000..acfe7a00
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomscr-wide.txt
@@ -0,0 +1,58 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Ascr| unicode:: U+1D49C .. MATHEMATICAL SCRIPT CAPITAL A
+.. |ascr| unicode:: U+1D4B6 .. MATHEMATICAL SCRIPT SMALL A
+.. |Bscr| unicode:: U+0212C .. SCRIPT CAPITAL B
+.. |bscr| unicode:: U+1D4B7 .. MATHEMATICAL SCRIPT SMALL B
+.. |Cscr| unicode:: U+1D49E .. MATHEMATICAL SCRIPT CAPITAL C
+.. |cscr| unicode:: U+1D4B8 .. MATHEMATICAL SCRIPT SMALL C
+.. |Dscr| unicode:: U+1D49F .. MATHEMATICAL SCRIPT CAPITAL D
+.. |dscr| unicode:: U+1D4B9 .. MATHEMATICAL SCRIPT SMALL D
+.. |Escr| unicode:: U+02130 .. SCRIPT CAPITAL E
+.. |escr| unicode:: U+0212F .. SCRIPT SMALL E
+.. |Fscr| unicode:: U+02131 .. SCRIPT CAPITAL F
+.. |fscr| unicode:: U+1D4BB .. MATHEMATICAL SCRIPT SMALL F
+.. |Gscr| unicode:: U+1D4A2 .. MATHEMATICAL SCRIPT CAPITAL G
+.. |gscr| unicode:: U+0210A .. SCRIPT SMALL G
+.. |Hscr| unicode:: U+0210B .. SCRIPT CAPITAL H
+.. |hscr| unicode:: U+1D4BD .. MATHEMATICAL SCRIPT SMALL H
+.. |Iscr| unicode:: U+02110 .. SCRIPT CAPITAL I
+.. |iscr| unicode:: U+1D4BE .. MATHEMATICAL SCRIPT SMALL I
+.. |Jscr| unicode:: U+1D4A5 .. MATHEMATICAL SCRIPT CAPITAL J
+.. |jscr| unicode:: U+1D4BF .. MATHEMATICAL SCRIPT SMALL J
+.. |Kscr| unicode:: U+1D4A6 .. MATHEMATICAL SCRIPT CAPITAL K
+.. |kscr| unicode:: U+1D4C0 .. MATHEMATICAL SCRIPT SMALL K
+.. |Lscr| unicode:: U+02112 .. SCRIPT CAPITAL L
+.. |lscr| unicode:: U+1D4C1 .. MATHEMATICAL SCRIPT SMALL L
+.. |Mscr| unicode:: U+02133 .. SCRIPT CAPITAL M
+.. |mscr| unicode:: U+1D4C2 .. MATHEMATICAL SCRIPT SMALL M
+.. |Nscr| unicode:: U+1D4A9 .. MATHEMATICAL SCRIPT CAPITAL N
+.. |nscr| unicode:: U+1D4C3 .. MATHEMATICAL SCRIPT SMALL N
+.. |Oscr| unicode:: U+1D4AA .. MATHEMATICAL SCRIPT CAPITAL O
+.. |oscr| unicode:: U+02134 .. SCRIPT SMALL O
+.. |Pscr| unicode:: U+1D4AB .. MATHEMATICAL SCRIPT CAPITAL P
+.. |pscr| unicode:: U+1D4C5 .. MATHEMATICAL SCRIPT SMALL P
+.. |Qscr| unicode:: U+1D4AC .. MATHEMATICAL SCRIPT CAPITAL Q
+.. |qscr| unicode:: U+1D4C6 .. MATHEMATICAL SCRIPT SMALL Q
+.. |Rscr| unicode:: U+0211B .. SCRIPT CAPITAL R
+.. |rscr| unicode:: U+1D4C7 .. MATHEMATICAL SCRIPT SMALL R
+.. |Sscr| unicode:: U+1D4AE .. MATHEMATICAL SCRIPT CAPITAL S
+.. |sscr| unicode:: U+1D4C8 .. MATHEMATICAL SCRIPT SMALL S
+.. |Tscr| unicode:: U+1D4AF .. MATHEMATICAL SCRIPT CAPITAL T
+.. |tscr| unicode:: U+1D4C9 .. MATHEMATICAL SCRIPT SMALL T
+.. |Uscr| unicode:: U+1D4B0 .. MATHEMATICAL SCRIPT CAPITAL U
+.. |uscr| unicode:: U+1D4CA .. MATHEMATICAL SCRIPT SMALL U
+.. |Vscr| unicode:: U+1D4B1 .. MATHEMATICAL SCRIPT CAPITAL V
+.. |vscr| unicode:: U+1D4CB .. MATHEMATICAL SCRIPT SMALL V
+.. |Wscr| unicode:: U+1D4B2 .. MATHEMATICAL SCRIPT CAPITAL W
+.. |wscr| unicode:: U+1D4CC .. MATHEMATICAL SCRIPT SMALL W
+.. |Xscr| unicode:: U+1D4B3 .. MATHEMATICAL SCRIPT CAPITAL X
+.. |xscr| unicode:: U+1D4CD .. MATHEMATICAL SCRIPT SMALL X
+.. |Yscr| unicode:: U+1D4B4 .. MATHEMATICAL SCRIPT CAPITAL Y
+.. |yscr| unicode:: U+1D4CE .. MATHEMATICAL SCRIPT SMALL Y
+.. |Zscr| unicode:: U+1D4B5 .. MATHEMATICAL SCRIPT CAPITAL Z
+.. |zscr| unicode:: U+1D4CF .. MATHEMATICAL SCRIPT SMALL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomscr.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomscr.txt
new file mode 100644
index 00000000..951577e8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isomscr.txt
@@ -0,0 +1,17 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Bscr| unicode:: U+0212C .. SCRIPT CAPITAL B
+.. |Escr| unicode:: U+02130 .. SCRIPT CAPITAL E
+.. |escr| unicode:: U+0212F .. SCRIPT SMALL E
+.. |Fscr| unicode:: U+02131 .. SCRIPT CAPITAL F
+.. |gscr| unicode:: U+0210A .. SCRIPT SMALL G
+.. |Hscr| unicode:: U+0210B .. SCRIPT CAPITAL H
+.. |Iscr| unicode:: U+02110 .. SCRIPT CAPITAL I
+.. |Lscr| unicode:: U+02112 .. SCRIPT CAPITAL L
+.. |Mscr| unicode:: U+02133 .. SCRIPT CAPITAL M
+.. |oscr| unicode:: U+02134 .. SCRIPT SMALL O
+.. |Rscr| unicode:: U+0211B .. SCRIPT CAPITAL R
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isonum.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isonum.txt
new file mode 100644
index 00000000..0d280c98
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isonum.txt
@@ -0,0 +1,82 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |amp|    unicode:: U+00026 .. AMPERSAND
+.. |apos|   unicode:: U+00027 .. APOSTROPHE
+.. |ast|    unicode:: U+0002A .. ASTERISK
+.. |brvbar| unicode:: U+000A6 .. BROKEN BAR
+.. |bsol|   unicode:: U+0005C .. REVERSE SOLIDUS
+.. |cent|   unicode:: U+000A2 .. CENT SIGN
+.. |colon|  unicode:: U+0003A .. COLON
+.. |comma|  unicode:: U+0002C .. COMMA
+.. |commat| unicode:: U+00040 .. COMMERCIAL AT
+.. |copy|   unicode:: U+000A9 .. COPYRIGHT SIGN
+.. |curren| unicode:: U+000A4 .. CURRENCY SIGN
+.. |darr|   unicode:: U+02193 .. DOWNWARDS ARROW
+.. |deg|    unicode:: U+000B0 .. DEGREE SIGN
+.. |divide| unicode:: U+000F7 .. DIVISION SIGN
+.. |dollar| unicode:: U+00024 .. DOLLAR SIGN
+.. |equals| unicode:: U+0003D .. EQUALS SIGN
+.. |excl|   unicode:: U+00021 .. EXCLAMATION MARK
+.. |frac12| unicode:: U+000BD .. VULGAR FRACTION ONE HALF
+.. |frac14| unicode:: U+000BC .. VULGAR FRACTION ONE QUARTER
+.. |frac18| unicode:: U+0215B .. VULGAR FRACTION ONE EIGHTH
+.. |frac34| unicode:: U+000BE .. VULGAR FRACTION THREE QUARTERS
+.. |frac38| unicode:: U+0215C .. VULGAR FRACTION THREE EIGHTHS
+.. |frac58| unicode:: U+0215D .. VULGAR FRACTION FIVE EIGHTHS
+.. |frac78| unicode:: U+0215E .. VULGAR FRACTION SEVEN EIGHTHS
+.. |gt|     unicode:: U+0003E .. GREATER-THAN SIGN
+.. |half|   unicode:: U+000BD .. VULGAR FRACTION ONE HALF
+.. |horbar| unicode:: U+02015 .. HORIZONTAL BAR
+.. |hyphen| unicode:: U+02010 .. HYPHEN
+.. |iexcl|  unicode:: U+000A1 .. INVERTED EXCLAMATION MARK
+.. |iquest| unicode:: U+000BF .. INVERTED QUESTION MARK
+.. |laquo|  unicode:: U+000AB .. LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+.. |larr|   unicode:: U+02190 .. LEFTWARDS ARROW
+.. |lcub|   unicode:: U+0007B .. LEFT CURLY BRACKET
+.. |ldquo|  unicode:: U+0201C .. LEFT DOUBLE QUOTATION MARK
+.. |lowbar| unicode:: U+0005F .. LOW LINE
+.. |lpar|   unicode:: U+00028 .. LEFT PARENTHESIS
+.. |lsqb|   unicode:: U+0005B .. LEFT SQUARE BRACKET
+.. |lsquo|  unicode:: U+02018 .. LEFT SINGLE QUOTATION MARK
+.. |lt|     unicode:: U+0003C .. LESS-THAN SIGN
+.. |micro|  unicode:: U+000B5 .. MICRO SIGN
+.. |middot| unicode:: U+000B7 .. MIDDLE DOT
+.. |nbsp|   unicode:: U+000A0 .. NO-BREAK SPACE
+.. |not|    unicode:: U+000AC .. NOT SIGN
+.. |num|    unicode:: U+00023 .. NUMBER SIGN
+.. |ohm|    unicode:: U+02126 .. OHM SIGN
+.. |ordf|   unicode:: U+000AA .. FEMININE ORDINAL INDICATOR
+.. |ordm|   unicode:: U+000BA .. MASCULINE ORDINAL INDICATOR
+.. |para|   unicode:: U+000B6 .. PILCROW SIGN
+.. |percnt| unicode:: U+00025 .. PERCENT SIGN
+.. |period| unicode:: U+0002E .. FULL STOP
+.. |plus|   unicode:: U+0002B .. PLUS SIGN
+.. |plusmn| unicode:: U+000B1 .. PLUS-MINUS SIGN
+.. |pound|  unicode:: U+000A3 .. POUND SIGN
+.. |quest|  unicode:: U+0003F .. QUESTION MARK
+.. |quot|   unicode:: U+00022 .. QUOTATION MARK
+.. |raquo|  unicode:: U+000BB .. RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+.. |rarr|   unicode:: U+02192 .. RIGHTWARDS ARROW
+.. |rcub|   unicode:: U+0007D .. RIGHT CURLY BRACKET
+.. |rdquo|  unicode:: U+0201D .. RIGHT DOUBLE QUOTATION MARK
+.. |reg|    unicode:: U+000AE .. REGISTERED SIGN
+.. |rpar|   unicode:: U+00029 .. RIGHT PARENTHESIS
+.. |rsqb|   unicode:: U+0005D .. RIGHT SQUARE BRACKET
+.. |rsquo|  unicode:: U+02019 .. RIGHT SINGLE QUOTATION MARK
+.. |sect|   unicode:: U+000A7 .. SECTION SIGN
+.. |semi|   unicode:: U+0003B .. SEMICOLON
+.. |shy|    unicode:: U+000AD .. SOFT HYPHEN
+.. |sol|    unicode:: U+0002F .. SOLIDUS
+.. |sung|   unicode:: U+0266A .. EIGHTH NOTE
+.. |sup1|   unicode:: U+000B9 .. SUPERSCRIPT ONE
+.. |sup2|   unicode:: U+000B2 .. SUPERSCRIPT TWO
+.. |sup3|   unicode:: U+000B3 .. SUPERSCRIPT THREE
+.. |times|  unicode:: U+000D7 .. MULTIPLICATION SIGN
+.. |trade|  unicode:: U+02122 .. TRADE MARK SIGN
+.. |uarr|   unicode:: U+02191 .. UPWARDS ARROW
+.. |verbar| unicode:: U+0007C .. VERTICAL LINE
+.. |yen|    unicode:: U+000A5 .. YEN SIGN
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isopub.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isopub.txt
new file mode 100644
index 00000000..78e12513
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isopub.txt
@@ -0,0 +1,90 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |blank|  unicode:: U+02423 .. OPEN BOX
+.. |blk12|  unicode:: U+02592 .. MEDIUM SHADE
+.. |blk14|  unicode:: U+02591 .. LIGHT SHADE
+.. |blk34|  unicode:: U+02593 .. DARK SHADE
+.. |block|  unicode:: U+02588 .. FULL BLOCK
+.. |bull|   unicode:: U+02022 .. BULLET
+.. |caret|  unicode:: U+02041 .. CARET INSERTION POINT
+.. |check|  unicode:: U+02713 .. CHECK MARK
+.. |cir|    unicode:: U+025CB .. WHITE CIRCLE
+.. |clubs|  unicode:: U+02663 .. BLACK CLUB SUIT
+.. |copysr| unicode:: U+02117 .. SOUND RECORDING COPYRIGHT
+.. |cross|  unicode:: U+02717 .. BALLOT X
+.. |Dagger| unicode:: U+02021 .. DOUBLE DAGGER
+.. |dagger| unicode:: U+02020 .. DAGGER
+.. |dash|   unicode:: U+02010 .. HYPHEN
+.. |diams|  unicode:: U+02666 .. BLACK DIAMOND SUIT
+.. |dlcrop| unicode:: U+0230D .. BOTTOM LEFT CROP
+.. |drcrop| unicode:: U+0230C .. BOTTOM RIGHT CROP
+.. |dtri|   unicode:: U+025BF .. WHITE DOWN-POINTING SMALL TRIANGLE
+.. |dtrif|  unicode:: U+025BE .. BLACK DOWN-POINTING SMALL TRIANGLE
+.. |emsp|   unicode:: U+02003 .. EM SPACE
+.. |emsp13| unicode:: U+02004 .. THREE-PER-EM SPACE
+.. |emsp14| unicode:: U+02005 .. FOUR-PER-EM SPACE
+.. |ensp|   unicode:: U+02002 .. EN SPACE
+.. |female| unicode:: U+02640 .. FEMALE SIGN
+.. |ffilig| unicode:: U+0FB03 .. LATIN SMALL LIGATURE FFI
+.. |fflig|  unicode:: U+0FB00 .. LATIN SMALL LIGATURE FF
+.. |ffllig| unicode:: U+0FB04 .. LATIN SMALL LIGATURE FFL
+.. |filig|  unicode:: U+0FB01 .. LATIN SMALL LIGATURE FI
+.. |flat|   unicode:: U+0266D .. MUSIC FLAT SIGN
+.. |fllig|  unicode:: U+0FB02 .. LATIN SMALL LIGATURE FL
+.. |frac13| unicode:: U+02153 .. VULGAR FRACTION ONE THIRD
+.. |frac15| unicode:: U+02155 .. VULGAR FRACTION ONE FIFTH
+.. |frac16| unicode:: U+02159 .. VULGAR FRACTION ONE SIXTH
+.. |frac23| unicode:: U+02154 .. VULGAR FRACTION TWO THIRDS
+.. |frac25| unicode:: U+02156 .. VULGAR FRACTION TWO FIFTHS
+.. |frac35| unicode:: U+02157 .. VULGAR FRACTION THREE FIFTHS
+.. |frac45| unicode:: U+02158 .. VULGAR FRACTION FOUR FIFTHS
+.. |frac56| unicode:: U+0215A .. VULGAR FRACTION FIVE SIXTHS
+.. |hairsp| unicode:: U+0200A .. HAIR SPACE
+.. |hearts| unicode:: U+02665 .. BLACK HEART SUIT
+.. |hellip| unicode:: U+02026 .. HORIZONTAL ELLIPSIS
+.. |hybull| unicode:: U+02043 .. HYPHEN BULLET
+.. |incare| unicode:: U+02105 .. CARE OF
+.. |ldquor| unicode:: U+0201E .. DOUBLE LOW-9 QUOTATION MARK
+.. |lhblk|  unicode:: U+02584 .. LOWER HALF BLOCK
+.. |loz|    unicode:: U+025CA .. LOZENGE
+.. |lozf|   unicode:: U+029EB .. BLACK LOZENGE
+.. |lsquor| unicode:: U+0201A .. SINGLE LOW-9 QUOTATION MARK
+.. |ltri|   unicode:: U+025C3 .. WHITE LEFT-POINTING SMALL TRIANGLE
+.. |ltrif|  unicode:: U+025C2 .. BLACK LEFT-POINTING SMALL TRIANGLE
+.. |male|   unicode:: U+02642 .. MALE SIGN
+.. |malt|   unicode:: U+02720 .. MALTESE CROSS
+.. |marker| unicode:: U+025AE .. BLACK VERTICAL RECTANGLE
+.. |mdash|  unicode:: U+02014 .. EM DASH
+.. |mldr|   unicode:: U+02026 .. HORIZONTAL ELLIPSIS
+.. |natur|  unicode:: U+0266E .. MUSIC NATURAL SIGN
+.. |ndash|  unicode:: U+02013 .. EN DASH
+.. |nldr|   unicode:: U+02025 .. TWO DOT LEADER
+.. |numsp|  unicode:: U+02007 .. FIGURE SPACE
+.. |phone|  unicode:: U+0260E .. BLACK TELEPHONE
+.. |puncsp| unicode:: U+02008 .. PUNCTUATION SPACE
+.. |rdquor| unicode:: U+0201D .. RIGHT DOUBLE QUOTATION MARK
+.. |rect|   unicode:: U+025AD .. WHITE RECTANGLE
+.. |rsquor| unicode:: U+02019 .. RIGHT SINGLE QUOTATION MARK
+.. |rtri|   unicode:: U+025B9 .. WHITE RIGHT-POINTING SMALL TRIANGLE
+.. |rtrif|  unicode:: U+025B8 .. BLACK RIGHT-POINTING SMALL TRIANGLE
+.. |rx|     unicode:: U+0211E .. PRESCRIPTION TAKE
+.. |sext|   unicode:: U+02736 .. SIX POINTED BLACK STAR
+.. |sharp|  unicode:: U+0266F .. MUSIC SHARP SIGN
+.. |spades| unicode:: U+02660 .. BLACK SPADE SUIT
+.. |squ|    unicode:: U+025A1 .. WHITE SQUARE
+.. |squf|   unicode:: U+025AA .. BLACK SMALL SQUARE
+.. |star|   unicode:: U+02606 .. WHITE STAR
+.. |starf|  unicode:: U+02605 .. BLACK STAR
+.. |target| unicode:: U+02316 .. POSITION INDICATOR
+.. |telrec| unicode:: U+02315 .. TELEPHONE RECORDER
+.. |thinsp| unicode:: U+02009 .. THIN SPACE
+.. |uhblk|  unicode:: U+02580 .. UPPER HALF BLOCK
+.. |ulcrop| unicode:: U+0230F .. TOP LEFT CROP
+.. |urcrop| unicode:: U+0230E .. TOP RIGHT CROP
+.. |utri|   unicode:: U+025B5 .. WHITE UP-POINTING SMALL TRIANGLE
+.. |utrif|  unicode:: U+025B4 .. BLACK UP-POINTING SMALL TRIANGLE
+.. |vellip| unicode:: U+022EE .. VERTICAL ELLIPSIS
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isotech.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isotech.txt
new file mode 100644
index 00000000..9b01eaad
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/isotech.txt
@@ -0,0 +1,168 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |acd|      unicode:: U+0223F .. SINE WAVE
+.. |aleph|    unicode:: U+02135 .. ALEF SYMBOL
+.. |And|      unicode:: U+02A53 .. DOUBLE LOGICAL AND
+.. |and|      unicode:: U+02227 .. LOGICAL AND
+.. |andand|   unicode:: U+02A55 .. TWO INTERSECTING LOGICAL AND
+.. |andd|     unicode:: U+02A5C .. LOGICAL AND WITH HORIZONTAL DASH
+.. |andslope| unicode:: U+02A58 .. SLOPING LARGE AND
+.. |andv|     unicode:: U+02A5A .. LOGICAL AND WITH MIDDLE STEM
+.. |ang90|    unicode:: U+0221F .. RIGHT ANGLE
+.. |angrt|    unicode:: U+0221F .. RIGHT ANGLE
+.. |angsph|   unicode:: U+02222 .. SPHERICAL ANGLE
+.. |angst|    unicode:: U+0212B .. ANGSTROM SIGN
+.. |ap|       unicode:: U+02248 .. ALMOST EQUAL TO
+.. |apacir|   unicode:: U+02A6F .. ALMOST EQUAL TO WITH CIRCUMFLEX ACCENT
+.. |awconint| unicode:: U+02233 .. ANTICLOCKWISE CONTOUR INTEGRAL
+.. |awint|    unicode:: U+02A11 .. ANTICLOCKWISE INTEGRATION
+.. |becaus|   unicode:: U+02235 .. BECAUSE
+.. |bernou|   unicode:: U+0212C .. SCRIPT CAPITAL B
+.. |bne|      unicode:: U+0003D U+020E5 .. EQUALS SIGN with reverse slash
+.. |bnequiv|  unicode:: U+02261 U+020E5 .. IDENTICAL TO with reverse slash
+.. |bNot|     unicode:: U+02AED .. REVERSED DOUBLE STROKE NOT SIGN
+.. |bnot|     unicode:: U+02310 .. REVERSED NOT SIGN
+.. |bottom|   unicode:: U+022A5 .. UP TACK
+.. |cap|      unicode:: U+02229 .. INTERSECTION
+.. |Cconint|  unicode:: U+02230 .. VOLUME INTEGRAL
+.. |cirfnint| unicode:: U+02A10 .. CIRCULATION FUNCTION
+.. |compfn|   unicode:: U+02218 .. RING OPERATOR
+.. |cong|     unicode:: U+02245 .. APPROXIMATELY EQUAL TO
+.. |Conint|   unicode:: U+0222F .. SURFACE INTEGRAL
+.. |conint|   unicode:: U+0222E .. CONTOUR INTEGRAL
+.. |ctdot|    unicode:: U+022EF .. MIDLINE HORIZONTAL ELLIPSIS
+.. |cup|      unicode:: U+0222A .. UNION
+.. |cwconint| unicode:: U+02232 .. CLOCKWISE CONTOUR INTEGRAL
+.. |cwint|    unicode:: U+02231 .. CLOCKWISE INTEGRAL
+.. |cylcty|   unicode:: U+0232D .. CYLINDRICITY
+.. |disin|    unicode:: U+022F2 .. ELEMENT OF WITH LONG HORIZONTAL STROKE
+.. |Dot|      unicode:: U+000A8 .. DIAERESIS
+.. |DotDot|   unicode:: U+020DC .. COMBINING FOUR DOTS ABOVE
+.. |dsol|     unicode:: U+029F6 .. SOLIDUS WITH OVERBAR
+.. |dtdot|    unicode:: U+022F1 .. DOWN RIGHT DIAGONAL ELLIPSIS
+.. |dwangle|  unicode:: U+029A6 .. OBLIQUE ANGLE OPENING UP
+.. |elinters| unicode:: U+0FFFD .. REPLACEMENT CHARACTER
+.. |epar|     unicode:: U+022D5 .. EQUAL AND PARALLEL TO
+.. |eparsl|   unicode:: U+029E3 .. EQUALS SIGN AND SLANTED PARALLEL
+.. |equiv|    unicode:: U+02261 .. IDENTICAL TO
+.. |eqvparsl| unicode:: U+029E5 .. IDENTICAL TO AND SLANTED PARALLEL
+.. |exist|    unicode:: U+02203 .. THERE EXISTS
+.. |fltns|    unicode:: U+025B1 .. WHITE PARALLELOGRAM
+.. |fnof|     unicode:: U+00192 .. LATIN SMALL LETTER F WITH HOOK
+.. |forall|   unicode:: U+02200 .. FOR ALL
+.. |fpartint| unicode:: U+02A0D .. FINITE PART INTEGRAL
+.. |ge|       unicode:: U+02265 .. GREATER-THAN OR EQUAL TO
+.. |hamilt|   unicode:: U+0210B .. SCRIPT CAPITAL H
+.. |iff|      unicode:: U+021D4 .. LEFT RIGHT DOUBLE ARROW
+.. |iinfin|   unicode:: U+029DC .. INCOMPLETE INFINITY
+.. |imped|    unicode:: U+001B5 .. LATIN CAPITAL LETTER Z WITH STROKE
+.. |infin|    unicode:: U+0221E .. INFINITY
+.. |infintie| unicode:: U+029DD .. TIE OVER INFINITY
+.. |Int|      unicode:: U+0222C .. DOUBLE INTEGRAL
+.. |int|      unicode:: U+0222B .. INTEGRAL
+.. |intlarhk| unicode:: U+02A17 .. INTEGRAL WITH LEFTWARDS ARROW WITH HOOK
+.. |isin|     unicode:: U+02208 .. ELEMENT OF
+.. |isindot|  unicode:: U+022F5 .. ELEMENT OF WITH DOT ABOVE
+.. |isinE|    unicode:: U+022F9 .. ELEMENT OF WITH TWO HORIZONTAL STROKES
+.. |isins|    unicode:: U+022F4 .. SMALL ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
+.. |isinsv|   unicode:: U+022F3 .. ELEMENT OF WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
+.. |isinv|    unicode:: U+02208 .. ELEMENT OF
+.. |lagran|   unicode:: U+02112 .. SCRIPT CAPITAL L
+.. |Lang|     unicode:: U+0300A .. LEFT DOUBLE ANGLE BRACKET
+.. |lang|     unicode:: U+02329 .. LEFT-POINTING ANGLE BRACKET
+.. |lArr|     unicode:: U+021D0 .. LEFTWARDS DOUBLE ARROW
+.. |lbbrk|    unicode:: U+03014 .. LEFT TORTOISE SHELL BRACKET
+.. |le|       unicode:: U+02264 .. LESS-THAN OR EQUAL TO
+.. |loang|    unicode:: U+03018 .. LEFT WHITE TORTOISE SHELL BRACKET
+.. |lobrk|    unicode:: U+0301A .. LEFT WHITE SQUARE BRACKET
+.. |lopar|    unicode:: U+02985 .. LEFT WHITE PARENTHESIS
+.. |lowast|   unicode:: U+02217 .. ASTERISK OPERATOR
+.. |minus|    unicode:: U+02212 .. MINUS SIGN
+.. |mnplus|   unicode:: U+02213 .. MINUS-OR-PLUS SIGN
+.. |nabla|    unicode:: U+02207 .. NABLA
+.. |ne|       unicode:: U+02260 .. NOT EQUAL TO
+.. |nedot|    unicode:: U+02250 U+00338 .. APPROACHES THE LIMIT with slash
+.. |nhpar|    unicode:: U+02AF2 .. PARALLEL WITH HORIZONTAL STROKE
+.. |ni|       unicode:: U+0220B .. CONTAINS AS MEMBER
+.. |nis|      unicode:: U+022FC .. SMALL CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
+.. |nisd|     unicode:: U+022FA .. CONTAINS WITH LONG HORIZONTAL STROKE
+.. |niv|      unicode:: U+0220B .. CONTAINS AS MEMBER
+.. |Not|      unicode:: U+02AEC .. DOUBLE STROKE NOT SIGN
+.. |notin|    unicode:: U+02209 .. NOT AN ELEMENT OF
+.. |notindot| unicode:: U+022F5 U+00338 .. ELEMENT OF WITH DOT ABOVE with slash
+.. |notinE|   unicode:: U+022F9 U+00338 .. ELEMENT OF WITH TWO HORIZONTAL STROKES with slash
+.. |notinva|  unicode:: U+02209 .. NOT AN ELEMENT OF
+.. |notinvb|  unicode:: U+022F7 .. SMALL ELEMENT OF WITH OVERBAR
+.. |notinvc|  unicode:: U+022F6 .. ELEMENT OF WITH OVERBAR
+.. |notni|    unicode:: U+0220C .. DOES NOT CONTAIN AS MEMBER
+.. |notniva|  unicode:: U+0220C .. DOES NOT CONTAIN AS MEMBER
+.. |notnivb|  unicode:: U+022FE .. SMALL CONTAINS WITH OVERBAR
+.. |notnivc|  unicode:: U+022FD .. CONTAINS WITH OVERBAR
+.. |nparsl|   unicode:: U+02AFD U+020E5 .. DOUBLE SOLIDUS OPERATOR with reverse slash
+.. |npart|    unicode:: U+02202 U+00338 .. PARTIAL DIFFERENTIAL with slash
+.. |npolint|  unicode:: U+02A14 .. LINE INTEGRATION NOT INCLUDING THE POLE
+.. |nvinfin|  unicode:: U+029DE .. INFINITY NEGATED WITH VERTICAL BAR
+.. |olcross|  unicode:: U+029BB .. CIRCLE WITH SUPERIMPOSED X
+.. |Or|       unicode:: U+02A54 .. DOUBLE LOGICAL OR
+.. |or|       unicode:: U+02228 .. LOGICAL OR
+.. |ord|      unicode:: U+02A5D .. LOGICAL OR WITH HORIZONTAL DASH
+.. |order|    unicode:: U+02134 .. SCRIPT SMALL O
+.. |oror|     unicode:: U+02A56 .. TWO INTERSECTING LOGICAL OR
+.. |orslope|  unicode:: U+02A57 .. SLOPING LARGE OR
+.. |orv|      unicode:: U+02A5B .. LOGICAL OR WITH MIDDLE STEM
+.. |par|      unicode:: U+02225 .. PARALLEL TO
+.. |parsl|    unicode:: U+02AFD .. DOUBLE SOLIDUS OPERATOR
+.. |part|     unicode:: U+02202 .. PARTIAL DIFFERENTIAL
+.. |permil|   unicode:: U+02030 .. PER MILLE SIGN
+.. |perp|     unicode:: U+022A5 .. UP TACK
+.. |pertenk|  unicode:: U+02031 .. PER TEN THOUSAND SIGN
+.. |phmmat|   unicode:: U+02133 .. SCRIPT CAPITAL M
+.. |pointint| unicode:: U+02A15 .. INTEGRAL AROUND A POINT OPERATOR
+.. |Prime|    unicode:: U+02033 .. DOUBLE PRIME
+.. |prime|    unicode:: U+02032 .. PRIME
+.. |profalar| unicode:: U+0232E .. ALL AROUND-PROFILE
+.. |profline| unicode:: U+02312 .. ARC
+.. |profsurf| unicode:: U+02313 .. SEGMENT
+.. |prop|     unicode:: U+0221D .. PROPORTIONAL TO
+.. |qint|     unicode:: U+02A0C .. QUADRUPLE INTEGRAL OPERATOR
+.. |qprime|   unicode:: U+02057 .. QUADRUPLE PRIME
+.. |quatint|  unicode:: U+02A16 .. QUATERNION INTEGRAL OPERATOR
+.. |radic|    unicode:: U+0221A .. SQUARE ROOT
+.. |Rang|     unicode:: U+0300B .. RIGHT DOUBLE ANGLE BRACKET
+.. |rang|     unicode:: U+0232A .. RIGHT-POINTING ANGLE BRACKET
+.. |rArr|     unicode:: U+021D2 .. RIGHTWARDS DOUBLE ARROW
+.. |rbbrk|    unicode:: U+03015 .. RIGHT TORTOISE SHELL BRACKET
+.. |roang|    unicode:: U+03019 .. RIGHT WHITE TORTOISE SHELL BRACKET
+.. |robrk|    unicode:: U+0301B .. RIGHT WHITE SQUARE BRACKET
+.. |ropar|    unicode:: U+02986 .. RIGHT WHITE PARENTHESIS
+.. |rppolint| unicode:: U+02A12 .. LINE INTEGRATION WITH RECTANGULAR PATH AROUND POLE
+.. |scpolint| unicode:: U+02A13 .. LINE INTEGRATION WITH SEMICIRCULAR PATH AROUND POLE
+.. |sim|      unicode:: U+0223C .. TILDE OPERATOR
+.. |simdot|   unicode:: U+02A6A .. TILDE OPERATOR WITH DOT ABOVE
+.. |sime|     unicode:: U+02243 .. ASYMPTOTICALLY EQUAL TO
+.. |smeparsl| unicode:: U+029E4 .. EQUALS SIGN AND SLANTED PARALLEL WITH TILDE ABOVE
+.. |square|   unicode:: U+025A1 .. WHITE SQUARE
+.. |squarf|   unicode:: U+025AA .. BLACK SMALL SQUARE
+.. |strns|    unicode:: U+000AF .. MACRON
+.. |sub|      unicode:: U+02282 .. SUBSET OF
+.. |sube|     unicode:: U+02286 .. SUBSET OF OR EQUAL TO
+.. |sup|      unicode:: U+02283 .. SUPERSET OF
+.. |supe|     unicode:: U+02287 .. SUPERSET OF OR EQUAL TO
+.. |tdot|     unicode:: U+020DB .. COMBINING THREE DOTS ABOVE
+.. |there4|   unicode:: U+02234 .. THEREFORE
+.. |tint|     unicode:: U+0222D .. TRIPLE INTEGRAL
+.. |top|      unicode:: U+022A4 .. DOWN TACK
+.. |topbot|   unicode:: U+02336 .. APL FUNCTIONAL SYMBOL I-BEAM
+.. |topcir|   unicode:: U+02AF1 .. DOWN TACK WITH CIRCLE BELOW
+.. |tprime|   unicode:: U+02034 .. TRIPLE PRIME
+.. |utdot|    unicode:: U+022F0 .. UP RIGHT DIAGONAL ELLIPSIS
+.. |uwangle|  unicode:: U+029A7 .. OBLIQUE ANGLE OPENING DOWN
+.. |vangrt|   unicode:: U+0299C .. RIGHT ANGLE VARIANT WITH SQUARE
+.. |veeeq|    unicode:: U+0225A .. EQUIANGULAR TO
+.. |Verbar|   unicode:: U+02016 .. DOUBLE VERTICAL LINE
+.. |wedgeq|   unicode:: U+02259 .. ESTIMATES
+.. |xnis|     unicode:: U+022FB .. CONTAINS WITH VERTICAL BAR AT END OF HORIZONTAL STROKE
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlalias.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlalias.txt
new file mode 100644
index 00000000..49c23ca7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlalias.txt
@@ -0,0 +1,554 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |angle|                           unicode:: U+02220 .. ANGLE
+.. |ApplyFunction|                   unicode:: U+02061 .. FUNCTION APPLICATION
+.. |approx|                          unicode:: U+02248 .. ALMOST EQUAL TO
+.. |approxeq|                        unicode:: U+0224A .. ALMOST EQUAL OR EQUAL TO
+.. |Assign|                          unicode:: U+02254 .. COLON EQUALS
+.. |backcong|                        unicode:: U+0224C .. ALL EQUAL TO
+.. |backepsilon|                     unicode:: U+003F6 .. GREEK REVERSED LUNATE EPSILON SYMBOL
+.. |backprime|                       unicode:: U+02035 .. REVERSED PRIME
+.. |backsim|                         unicode:: U+0223D .. REVERSED TILDE
+.. |backsimeq|                       unicode:: U+022CD .. REVERSED TILDE EQUALS
+.. |Backslash|                       unicode:: U+02216 .. SET MINUS
+.. |barwedge|                        unicode:: U+02305 .. PROJECTIVE
+.. |Because|                         unicode:: U+02235 .. BECAUSE
+.. |because|                         unicode:: U+02235 .. BECAUSE
+.. |Bernoullis|                      unicode:: U+0212C .. SCRIPT CAPITAL B
+.. |between|                         unicode:: U+0226C .. BETWEEN
+.. |bigcap|                          unicode:: U+022C2 .. N-ARY INTERSECTION
+.. |bigcirc|                         unicode:: U+025EF .. LARGE CIRCLE
+.. |bigcup|                          unicode:: U+022C3 .. N-ARY UNION
+.. |bigodot|                         unicode:: U+02A00 .. N-ARY CIRCLED DOT OPERATOR
+.. |bigoplus|                        unicode:: U+02A01 .. N-ARY CIRCLED PLUS OPERATOR
+.. |bigotimes|                       unicode:: U+02A02 .. N-ARY CIRCLED TIMES OPERATOR
+.. |bigsqcup|                        unicode:: U+02A06 .. N-ARY SQUARE UNION OPERATOR
+.. |bigstar|                         unicode:: U+02605 .. BLACK STAR
+.. |bigtriangledown|                 unicode:: U+025BD .. WHITE DOWN-POINTING TRIANGLE
+.. |bigtriangleup|                   unicode:: U+025B3 .. WHITE UP-POINTING TRIANGLE
+.. |biguplus|                        unicode:: U+02A04 .. N-ARY UNION OPERATOR WITH PLUS
+.. |bigvee|                          unicode:: U+022C1 .. N-ARY LOGICAL OR
+.. |bigwedge|                        unicode:: U+022C0 .. N-ARY LOGICAL AND
+.. |bkarow|                          unicode:: U+0290D .. RIGHTWARDS DOUBLE DASH ARROW
+.. |blacklozenge|                    unicode:: U+029EB .. BLACK LOZENGE
+.. |blacksquare|                     unicode:: U+025AA .. BLACK SMALL SQUARE
+.. |blacktriangle|                   unicode:: U+025B4 .. BLACK UP-POINTING SMALL TRIANGLE
+.. |blacktriangledown|               unicode:: U+025BE .. BLACK DOWN-POINTING SMALL TRIANGLE
+.. |blacktriangleleft|               unicode:: U+025C2 .. BLACK LEFT-POINTING SMALL TRIANGLE
+.. |blacktriangleright|              unicode:: U+025B8 .. BLACK RIGHT-POINTING SMALL TRIANGLE
+.. |bot|                             unicode:: U+022A5 .. UP TACK
+.. |boxminus|                        unicode:: U+0229F .. SQUARED MINUS
+.. |boxplus|                         unicode:: U+0229E .. SQUARED PLUS
+.. |boxtimes|                        unicode:: U+022A0 .. SQUARED TIMES
+.. |Breve|                           unicode:: U+002D8 .. BREVE
+.. |bullet|                          unicode:: U+02022 .. BULLET
+.. |Bumpeq|                          unicode:: U+0224E .. GEOMETRICALLY EQUIVALENT TO
+.. |bumpeq|                          unicode:: U+0224F .. DIFFERENCE BETWEEN
+.. |CapitalDifferentialD|            unicode:: U+02145 .. DOUBLE-STRUCK ITALIC CAPITAL D
+.. |Cayleys|                         unicode:: U+0212D .. BLACK-LETTER CAPITAL C
+.. |Cedilla|                         unicode:: U+000B8 .. CEDILLA
+.. |CenterDot|                       unicode:: U+000B7 .. MIDDLE DOT
+.. |centerdot|                       unicode:: U+000B7 .. MIDDLE DOT
+.. |checkmark|                       unicode:: U+02713 .. CHECK MARK
+.. |circeq|                          unicode:: U+02257 .. RING EQUAL TO
+.. |circlearrowleft|                 unicode:: U+021BA .. ANTICLOCKWISE OPEN CIRCLE ARROW
+.. |circlearrowright|                unicode:: U+021BB .. CLOCKWISE OPEN CIRCLE ARROW
+.. |circledast|                      unicode:: U+0229B .. CIRCLED ASTERISK OPERATOR
+.. |circledcirc|                     unicode:: U+0229A .. CIRCLED RING OPERATOR
+.. |circleddash|                     unicode:: U+0229D .. CIRCLED DASH
+.. |CircleDot|                       unicode:: U+02299 .. CIRCLED DOT OPERATOR
+.. |circledR|                        unicode:: U+000AE .. REGISTERED SIGN
+.. |circledS|                        unicode:: U+024C8 .. CIRCLED LATIN CAPITAL LETTER S
+.. |CircleMinus|                     unicode:: U+02296 .. CIRCLED MINUS
+.. |CirclePlus|                      unicode:: U+02295 .. CIRCLED PLUS
+.. |CircleTimes|                     unicode:: U+02297 .. CIRCLED TIMES
+.. |ClockwiseContourIntegral|        unicode:: U+02232 .. CLOCKWISE CONTOUR INTEGRAL
+.. |CloseCurlyDoubleQuote|           unicode:: U+0201D .. RIGHT DOUBLE QUOTATION MARK
+.. |CloseCurlyQuote|                 unicode:: U+02019 .. RIGHT SINGLE QUOTATION MARK
+.. |clubsuit|                        unicode:: U+02663 .. BLACK CLUB SUIT
+.. |coloneq|                         unicode:: U+02254 .. COLON EQUALS
+.. |complement|                      unicode:: U+02201 .. COMPLEMENT
+.. |complexes|                       unicode:: U+02102 .. DOUBLE-STRUCK CAPITAL C
+.. |Congruent|                       unicode:: U+02261 .. IDENTICAL TO
+.. |ContourIntegral|                 unicode:: U+0222E .. CONTOUR INTEGRAL
+.. |Coproduct|                       unicode:: U+02210 .. N-ARY COPRODUCT
+.. |CounterClockwiseContourIntegral| unicode:: U+02233 .. ANTICLOCKWISE CONTOUR INTEGRAL
+.. |CupCap|                          unicode:: U+0224D .. EQUIVALENT TO
+.. |curlyeqprec|                     unicode:: U+022DE .. EQUAL TO OR PRECEDES
+.. |curlyeqsucc|                     unicode:: U+022DF .. EQUAL TO OR SUCCEEDS
+.. |curlyvee|                        unicode:: U+022CE .. CURLY LOGICAL OR
+.. |curlywedge|                      unicode:: U+022CF .. CURLY LOGICAL AND
+.. |curvearrowleft|                  unicode:: U+021B6 .. ANTICLOCKWISE TOP SEMICIRCLE ARROW
+.. |curvearrowright|                 unicode:: U+021B7 .. CLOCKWISE TOP SEMICIRCLE ARROW
+.. |dbkarow|                         unicode:: U+0290F .. RIGHTWARDS TRIPLE DASH ARROW
+.. |ddagger|                         unicode:: U+02021 .. DOUBLE DAGGER
+.. |ddotseq|                         unicode:: U+02A77 .. EQUALS SIGN WITH TWO DOTS ABOVE AND TWO DOTS BELOW
+.. |Del|                             unicode:: U+02207 .. NABLA
+.. |DiacriticalAcute|                unicode:: U+000B4 .. ACUTE ACCENT
+.. |DiacriticalDot|                  unicode:: U+002D9 .. DOT ABOVE
+.. |DiacriticalDoubleAcute|          unicode:: U+002DD .. DOUBLE ACUTE ACCENT
+.. |DiacriticalGrave|                unicode:: U+00060 .. GRAVE ACCENT
+.. |DiacriticalTilde|                unicode:: U+002DC .. SMALL TILDE
+.. |Diamond|                         unicode:: U+022C4 .. DIAMOND OPERATOR
+.. |diamond|                         unicode:: U+022C4 .. DIAMOND OPERATOR
+.. |diamondsuit|                     unicode:: U+02666 .. BLACK DIAMOND SUIT
+.. |DifferentialD|                   unicode:: U+02146 .. DOUBLE-STRUCK ITALIC SMALL D
+.. |digamma|                         unicode:: U+003DD .. GREEK SMALL LETTER DIGAMMA
+.. |div|                             unicode:: U+000F7 .. DIVISION SIGN
+.. |divideontimes|                   unicode:: U+022C7 .. DIVISION TIMES
+.. |doteq|                           unicode:: U+02250 .. APPROACHES THE LIMIT
+.. |doteqdot|                        unicode:: U+02251 .. GEOMETRICALLY EQUAL TO
+.. |DotEqual|                        unicode:: U+02250 .. APPROACHES THE LIMIT
+.. |dotminus|                        unicode:: U+02238 .. DOT MINUS
+.. |dotplus|                         unicode:: U+02214 .. DOT PLUS
+.. |dotsquare|                       unicode:: U+022A1 .. SQUARED DOT OPERATOR
+.. |doublebarwedge|                  unicode:: U+02306 .. PERSPECTIVE
+.. |DoubleContourIntegral|           unicode:: U+0222F .. SURFACE INTEGRAL
+.. |DoubleDot|                       unicode:: U+000A8 .. DIAERESIS
+.. |DoubleDownArrow|                 unicode:: U+021D3 .. DOWNWARDS DOUBLE ARROW
+.. |DoubleLeftArrow|                 unicode:: U+021D0 .. LEFTWARDS DOUBLE ARROW
+.. |DoubleLeftRightArrow|            unicode:: U+021D4 .. LEFT RIGHT DOUBLE ARROW
+.. |DoubleLeftTee|                   unicode:: U+02AE4 .. VERTICAL BAR DOUBLE LEFT TURNSTILE
+.. |DoubleLongLeftArrow|             unicode:: U+027F8 .. LONG LEFTWARDS DOUBLE ARROW
+.. |DoubleLongLeftRightArrow|        unicode:: U+027FA .. LONG LEFT RIGHT DOUBLE ARROW
+.. |DoubleLongRightArrow|            unicode:: U+027F9 .. LONG RIGHTWARDS DOUBLE ARROW
+.. |DoubleRightArrow|                unicode:: U+021D2 .. RIGHTWARDS DOUBLE ARROW
+.. |DoubleRightTee|                  unicode:: U+022A8 .. TRUE
+.. |DoubleUpArrow|                   unicode:: U+021D1 .. UPWARDS DOUBLE ARROW
+.. |DoubleUpDownArrow|               unicode:: U+021D5 .. UP DOWN DOUBLE ARROW
+.. |DoubleVerticalBar|               unicode:: U+02225 .. PARALLEL TO
+.. |DownArrow|                       unicode:: U+02193 .. DOWNWARDS ARROW
+.. |Downarrow|                       unicode:: U+021D3 .. DOWNWARDS DOUBLE ARROW
+.. |downarrow|                       unicode:: U+02193 .. DOWNWARDS ARROW
+.. |DownArrowUpArrow|                unicode:: U+021F5 .. DOWNWARDS ARROW LEFTWARDS OF UPWARDS ARROW
+.. |downdownarrows|                  unicode:: U+021CA .. DOWNWARDS PAIRED ARROWS
+.. |downharpoonleft|                 unicode:: U+021C3 .. DOWNWARDS HARPOON WITH BARB LEFTWARDS
+.. |downharpoonright|                unicode:: U+021C2 .. DOWNWARDS HARPOON WITH BARB RIGHTWARDS
+.. |DownLeftVector|                  unicode:: U+021BD .. LEFTWARDS HARPOON WITH BARB DOWNWARDS
+.. |DownRightVector|                 unicode:: U+021C1 .. RIGHTWARDS HARPOON WITH BARB DOWNWARDS
+.. |DownTee|                         unicode:: U+022A4 .. DOWN TACK
+.. |DownTeeArrow|                    unicode:: U+021A7 .. DOWNWARDS ARROW FROM BAR
+.. |drbkarow|                        unicode:: U+02910 .. RIGHTWARDS TWO-HEADED TRIPLE DASH ARROW
+.. |Element|                         unicode:: U+02208 .. ELEMENT OF
+.. |emptyset|                        unicode:: U+02205 .. EMPTY SET
+.. |eqcirc|                          unicode:: U+02256 .. RING IN EQUAL TO
+.. |eqcolon|                         unicode:: U+02255 .. EQUALS COLON
+.. |eqsim|                           unicode:: U+02242 .. MINUS TILDE
+.. |eqslantgtr|                      unicode:: U+02A96 .. SLANTED EQUAL TO OR GREATER-THAN
+.. |eqslantless|                     unicode:: U+02A95 .. SLANTED EQUAL TO OR LESS-THAN
+.. |EqualTilde|                      unicode:: U+02242 .. MINUS TILDE
+.. |Equilibrium|                     unicode:: U+021CC .. RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+.. |Exists|                          unicode:: U+02203 .. THERE EXISTS
+.. |expectation|                     unicode:: U+02130 .. SCRIPT CAPITAL E
+.. |ExponentialE|                    unicode:: U+02147 .. DOUBLE-STRUCK ITALIC SMALL E
+.. |exponentiale|                    unicode:: U+02147 .. DOUBLE-STRUCK ITALIC SMALL E
+.. |fallingdotseq|                   unicode:: U+02252 .. APPROXIMATELY EQUAL TO OR THE IMAGE OF
+.. |ForAll|                          unicode:: U+02200 .. FOR ALL
+.. |Fouriertrf|                      unicode:: U+02131 .. SCRIPT CAPITAL F
+.. |geq|                             unicode:: U+02265 .. GREATER-THAN OR EQUAL TO
+.. |geqq|                            unicode:: U+02267 .. GREATER-THAN OVER EQUAL TO
+.. |geqslant|                        unicode:: U+02A7E .. GREATER-THAN OR SLANTED EQUAL TO
+.. |gg|                              unicode:: U+0226B .. MUCH GREATER-THAN
+.. |ggg|                             unicode:: U+022D9 .. VERY MUCH GREATER-THAN
+.. |gnapprox|                        unicode:: U+02A8A .. GREATER-THAN AND NOT APPROXIMATE
+.. |gneq|                            unicode:: U+02A88 .. GREATER-THAN AND SINGLE-LINE NOT EQUAL TO
+.. |gneqq|                           unicode:: U+02269 .. GREATER-THAN BUT NOT EQUAL TO
+.. |GreaterEqual|                    unicode:: U+02265 .. GREATER-THAN OR EQUAL TO
+.. |GreaterEqualLess|                unicode:: U+022DB .. GREATER-THAN EQUAL TO OR LESS-THAN
+.. |GreaterFullEqual|                unicode:: U+02267 .. GREATER-THAN OVER EQUAL TO
+.. |GreaterLess|                     unicode:: U+02277 .. GREATER-THAN OR LESS-THAN
+.. |GreaterSlantEqual|               unicode:: U+02A7E .. GREATER-THAN OR SLANTED EQUAL TO
+.. |GreaterTilde|                    unicode:: U+02273 .. GREATER-THAN OR EQUIVALENT TO
+.. |gtrapprox|                       unicode:: U+02A86 .. GREATER-THAN OR APPROXIMATE
+.. |gtrdot|                          unicode:: U+022D7 .. GREATER-THAN WITH DOT
+.. |gtreqless|                       unicode:: U+022DB .. GREATER-THAN EQUAL TO OR LESS-THAN
+.. |gtreqqless|                      unicode:: U+02A8C .. GREATER-THAN ABOVE DOUBLE-LINE EQUAL ABOVE LESS-THAN
+.. |gtrless|                         unicode:: U+02277 .. GREATER-THAN OR LESS-THAN
+.. |gtrsim|                          unicode:: U+02273 .. GREATER-THAN OR EQUIVALENT TO
+.. |gvertneqq|                       unicode:: U+02269 U+0FE00 .. GREATER-THAN BUT NOT EQUAL TO - with vertical stroke
+.. |Hacek|                           unicode:: U+002C7 .. CARON
+.. |hbar|                            unicode:: U+0210F .. PLANCK CONSTANT OVER TWO PI
+.. |heartsuit|                       unicode:: U+02665 .. BLACK HEART SUIT
+.. |HilbertSpace|                    unicode:: U+0210B .. SCRIPT CAPITAL H
+.. |hksearow|                        unicode:: U+02925 .. SOUTH EAST ARROW WITH HOOK
+.. |hkswarow|                        unicode:: U+02926 .. SOUTH WEST ARROW WITH HOOK
+.. |hookleftarrow|                   unicode:: U+021A9 .. LEFTWARDS ARROW WITH HOOK
+.. |hookrightarrow|                  unicode:: U+021AA .. RIGHTWARDS ARROW WITH HOOK
+.. |hslash|                          unicode:: U+0210F .. PLANCK CONSTANT OVER TWO PI
+.. |HumpDownHump|                    unicode:: U+0224E .. GEOMETRICALLY EQUIVALENT TO
+.. |HumpEqual|                       unicode:: U+0224F .. DIFFERENCE BETWEEN
+.. |iiiint|                          unicode:: U+02A0C .. QUADRUPLE INTEGRAL OPERATOR
+.. |iiint|                           unicode:: U+0222D .. TRIPLE INTEGRAL
+.. |Im|                              unicode:: U+02111 .. BLACK-LETTER CAPITAL I
+.. |ImaginaryI|                      unicode:: U+02148 .. DOUBLE-STRUCK ITALIC SMALL I
+.. |imagline|                        unicode:: U+02110 .. SCRIPT CAPITAL I
+.. |imagpart|                        unicode:: U+02111 .. BLACK-LETTER CAPITAL I
+.. |Implies|                         unicode:: U+021D2 .. RIGHTWARDS DOUBLE ARROW
+.. |in|                              unicode:: U+02208 .. ELEMENT OF
+.. |integers|                        unicode:: U+02124 .. DOUBLE-STRUCK CAPITAL Z
+.. |Integral|                        unicode:: U+0222B .. INTEGRAL
+.. |intercal|                        unicode:: U+022BA .. INTERCALATE
+.. |Intersection|                    unicode:: U+022C2 .. N-ARY INTERSECTION
+.. |intprod|                         unicode:: U+02A3C .. INTERIOR PRODUCT
+.. |InvisibleComma|                  unicode:: U+02063 .. INVISIBLE SEPARATOR
+.. |InvisibleTimes|                  unicode:: U+02062 .. INVISIBLE TIMES
+.. |langle|                          unicode:: U+02329 .. LEFT-POINTING ANGLE BRACKET
+.. |Laplacetrf|                      unicode:: U+02112 .. SCRIPT CAPITAL L
+.. |lbrace|                          unicode:: U+0007B .. LEFT CURLY BRACKET
+.. |lbrack|                          unicode:: U+0005B .. LEFT SQUARE BRACKET
+.. |LeftAngleBracket|                unicode:: U+02329 .. LEFT-POINTING ANGLE BRACKET
+.. |LeftArrow|                       unicode:: U+02190 .. LEFTWARDS ARROW
+.. |Leftarrow|                       unicode:: U+021D0 .. LEFTWARDS DOUBLE ARROW
+.. |leftarrow|                       unicode:: U+02190 .. LEFTWARDS ARROW
+.. |LeftArrowBar|                    unicode:: U+021E4 .. LEFTWARDS ARROW TO BAR
+.. |LeftArrowRightArrow|             unicode:: U+021C6 .. LEFTWARDS ARROW OVER RIGHTWARDS ARROW
+.. |leftarrowtail|                   unicode:: U+021A2 .. LEFTWARDS ARROW WITH TAIL
+.. |LeftCeiling|                     unicode:: U+02308 .. LEFT CEILING
+.. |LeftDoubleBracket|               unicode:: U+0301A .. LEFT WHITE SQUARE BRACKET
+.. |LeftDownVector|                  unicode:: U+021C3 .. DOWNWARDS HARPOON WITH BARB LEFTWARDS
+.. |LeftFloor|                       unicode:: U+0230A .. LEFT FLOOR
+.. |leftharpoondown|                 unicode:: U+021BD .. LEFTWARDS HARPOON WITH BARB DOWNWARDS
+.. |leftharpoonup|                   unicode:: U+021BC .. LEFTWARDS HARPOON WITH BARB UPWARDS
+.. |leftleftarrows|                  unicode:: U+021C7 .. LEFTWARDS PAIRED ARROWS
+.. |LeftRightArrow|                  unicode:: U+02194 .. LEFT RIGHT ARROW
+.. |Leftrightarrow|                  unicode:: U+021D4 .. LEFT RIGHT DOUBLE ARROW
+.. |leftrightarrow|                  unicode:: U+02194 .. LEFT RIGHT ARROW
+.. |leftrightarrows|                 unicode:: U+021C6 .. LEFTWARDS ARROW OVER RIGHTWARDS ARROW
+.. |leftrightharpoons|               unicode:: U+021CB .. LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
+.. |leftrightsquigarrow|             unicode:: U+021AD .. LEFT RIGHT WAVE ARROW
+.. |LeftTee|                         unicode:: U+022A3 .. LEFT TACK
+.. |LeftTeeArrow|                    unicode:: U+021A4 .. LEFTWARDS ARROW FROM BAR
+.. |leftthreetimes|                  unicode:: U+022CB .. LEFT SEMIDIRECT PRODUCT
+.. |LeftTriangle|                    unicode:: U+022B2 .. NORMAL SUBGROUP OF
+.. |LeftTriangleEqual|               unicode:: U+022B4 .. NORMAL SUBGROUP OF OR EQUAL TO
+.. |LeftUpVector|                    unicode:: U+021BF .. UPWARDS HARPOON WITH BARB LEFTWARDS
+.. |LeftVector|                      unicode:: U+021BC .. LEFTWARDS HARPOON WITH BARB UPWARDS
+.. |leq|                             unicode:: U+02264 .. LESS-THAN OR EQUAL TO
+.. |leqq|                            unicode:: U+02266 .. LESS-THAN OVER EQUAL TO
+.. |leqslant|                        unicode:: U+02A7D .. LESS-THAN OR SLANTED EQUAL TO
+.. |lessapprox|                      unicode:: U+02A85 .. LESS-THAN OR APPROXIMATE
+.. |lessdot|                         unicode:: U+022D6 .. LESS-THAN WITH DOT
+.. |lesseqgtr|                       unicode:: U+022DA .. LESS-THAN EQUAL TO OR GREATER-THAN
+.. |lesseqqgtr|                      unicode:: U+02A8B .. LESS-THAN ABOVE DOUBLE-LINE EQUAL ABOVE GREATER-THAN
+.. |LessEqualGreater|                unicode:: U+022DA .. LESS-THAN EQUAL TO OR GREATER-THAN
+.. |LessFullEqual|                   unicode:: U+02266 .. LESS-THAN OVER EQUAL TO
+.. |LessGreater|                     unicode:: U+02276 .. LESS-THAN OR GREATER-THAN
+.. |lessgtr|                         unicode:: U+02276 .. LESS-THAN OR GREATER-THAN
+.. |lesssim|                         unicode:: U+02272 .. LESS-THAN OR EQUIVALENT TO
+.. |LessSlantEqual|                  unicode:: U+02A7D .. LESS-THAN OR SLANTED EQUAL TO
+.. |LessTilde|                       unicode:: U+02272 .. LESS-THAN OR EQUIVALENT TO
+.. |ll|                              unicode:: U+0226A .. MUCH LESS-THAN
+.. |llcorner|                        unicode:: U+0231E .. BOTTOM LEFT CORNER
+.. |Lleftarrow|                      unicode:: U+021DA .. LEFTWARDS TRIPLE ARROW
+.. |lmoustache|                      unicode:: U+023B0 .. UPPER LEFT OR LOWER RIGHT CURLY BRACKET SECTION
+.. |lnapprox|                        unicode:: U+02A89 .. LESS-THAN AND NOT APPROXIMATE
+.. |lneq|                            unicode:: U+02A87 .. LESS-THAN AND SINGLE-LINE NOT EQUAL TO
+.. |lneqq|                           unicode:: U+02268 .. LESS-THAN BUT NOT EQUAL TO
+.. |LongLeftArrow|                   unicode:: U+027F5 .. LONG LEFTWARDS ARROW
+.. |Longleftarrow|                   unicode:: U+027F8 .. LONG LEFTWARDS DOUBLE ARROW
+.. |longleftarrow|                   unicode:: U+027F5 .. LONG LEFTWARDS ARROW
+.. |LongLeftRightArrow|              unicode:: U+027F7 .. LONG LEFT RIGHT ARROW
+.. |Longleftrightarrow|              unicode:: U+027FA .. LONG LEFT RIGHT DOUBLE ARROW
+.. |longleftrightarrow|              unicode:: U+027F7 .. LONG LEFT RIGHT ARROW
+.. |longmapsto|                      unicode:: U+027FC .. LONG RIGHTWARDS ARROW FROM BAR
+.. |LongRightArrow|                  unicode:: U+027F6 .. LONG RIGHTWARDS ARROW
+.. |Longrightarrow|                  unicode:: U+027F9 .. LONG RIGHTWARDS DOUBLE ARROW
+.. |longrightarrow|                  unicode:: U+027F6 .. LONG RIGHTWARDS ARROW
+.. |looparrowleft|                   unicode:: U+021AB .. LEFTWARDS ARROW WITH LOOP
+.. |looparrowright|                  unicode:: U+021AC .. RIGHTWARDS ARROW WITH LOOP
+.. |LowerLeftArrow|                  unicode:: U+02199 .. SOUTH WEST ARROW
+.. |LowerRightArrow|                 unicode:: U+02198 .. SOUTH EAST ARROW
+.. |lozenge|                         unicode:: U+025CA .. LOZENGE
+.. |lrcorner|                        unicode:: U+0231F .. BOTTOM RIGHT CORNER
+.. |Lsh|                             unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS
+.. |lvertneqq|                       unicode:: U+02268 U+0FE00 .. LESS-THAN BUT NOT EQUAL TO - with vertical stroke
+.. |maltese|                         unicode:: U+02720 .. MALTESE CROSS
+.. |mapsto|                          unicode:: U+021A6 .. RIGHTWARDS ARROW FROM BAR
+.. |measuredangle|                   unicode:: U+02221 .. MEASURED ANGLE
+.. |Mellintrf|                       unicode:: U+02133 .. SCRIPT CAPITAL M
+.. |MinusPlus|                       unicode:: U+02213 .. MINUS-OR-PLUS SIGN
+.. |mp|                              unicode:: U+02213 .. MINUS-OR-PLUS SIGN
+.. |multimap|                        unicode:: U+022B8 .. MULTIMAP
+.. |napprox|                         unicode:: U+02249 .. NOT ALMOST EQUAL TO
+.. |natural|                         unicode:: U+0266E .. MUSIC NATURAL SIGN
+.. |naturals|                        unicode:: U+02115 .. DOUBLE-STRUCK CAPITAL N
+.. |nearrow|                         unicode:: U+02197 .. NORTH EAST ARROW
+.. |NegativeMediumSpace|             unicode:: U+0200B .. ZERO WIDTH SPACE
+.. |NegativeThickSpace|              unicode:: U+0200B .. ZERO WIDTH SPACE
+.. |NegativeThinSpace|               unicode:: U+0200B .. ZERO WIDTH SPACE
+.. |NegativeVeryThinSpace|           unicode:: U+0200B .. ZERO WIDTH SPACE
+.. |NestedGreaterGreater|            unicode:: U+0226B .. MUCH GREATER-THAN
+.. |NestedLessLess|                  unicode:: U+0226A .. MUCH LESS-THAN
+.. |nexists|                         unicode:: U+02204 .. THERE DOES NOT EXIST
+.. |ngeq|                            unicode:: U+02271 .. NEITHER GREATER-THAN NOR EQUAL TO
+.. |ngeqq|                           unicode:: U+02267 U+00338 .. GREATER-THAN OVER EQUAL TO with slash
+.. |ngeqslant|                       unicode:: U+02A7E U+00338 .. GREATER-THAN OR SLANTED EQUAL TO with slash
+.. |ngtr|                            unicode:: U+0226F .. NOT GREATER-THAN
+.. |nLeftarrow|                      unicode:: U+021CD .. LEFTWARDS DOUBLE ARROW WITH STROKE
+.. |nleftarrow|                      unicode:: U+0219A .. LEFTWARDS ARROW WITH STROKE
+.. |nLeftrightarrow|                 unicode:: U+021CE .. LEFT RIGHT DOUBLE ARROW WITH STROKE
+.. |nleftrightarrow|                 unicode:: U+021AE .. LEFT RIGHT ARROW WITH STROKE
+.. |nleq|                            unicode:: U+02270 .. NEITHER LESS-THAN NOR EQUAL TO
+.. |nleqq|                           unicode:: U+02266 U+00338 .. LESS-THAN OVER EQUAL TO with slash
+.. |nleqslant|                       unicode:: U+02A7D U+00338 .. LESS-THAN OR SLANTED EQUAL TO with slash
+.. |nless|                           unicode:: U+0226E .. NOT LESS-THAN
+.. |NonBreakingSpace|                unicode:: U+000A0 .. NO-BREAK SPACE
+.. |NotCongruent|                    unicode:: U+02262 .. NOT IDENTICAL TO
+.. |NotDoubleVerticalBar|            unicode:: U+02226 .. NOT PARALLEL TO
+.. |NotElement|                      unicode:: U+02209 .. NOT AN ELEMENT OF
+.. |NotEqual|                        unicode:: U+02260 .. NOT EQUAL TO
+.. |NotEqualTilde|                   unicode:: U+02242 U+00338 .. MINUS TILDE with slash
+.. |NotExists|                       unicode:: U+02204 .. THERE DOES NOT EXIST
+.. |NotGreater|                      unicode:: U+0226F .. NOT GREATER-THAN
+.. |NotGreaterEqual|                 unicode:: U+02271 .. NEITHER GREATER-THAN NOR EQUAL TO
+.. |NotGreaterFullEqual|             unicode:: U+02266 U+00338 .. LESS-THAN OVER EQUAL TO with slash
+.. |NotGreaterGreater|               unicode:: U+0226B U+00338 .. MUCH GREATER THAN with slash
+.. |NotGreaterLess|                  unicode:: U+02279 .. NEITHER GREATER-THAN NOR LESS-THAN
+.. |NotGreaterSlantEqual|            unicode:: U+02A7E U+00338 .. GREATER-THAN OR SLANTED EQUAL TO with slash
+.. |NotGreaterTilde|                 unicode:: U+02275 .. NEITHER GREATER-THAN NOR EQUIVALENT TO
+.. |NotHumpDownHump|                 unicode:: U+0224E U+00338 .. GEOMETRICALLY EQUIVALENT TO with slash
+.. |NotLeftTriangle|                 unicode:: U+022EA .. NOT NORMAL SUBGROUP OF
+.. |NotLeftTriangleEqual|            unicode:: U+022EC .. NOT NORMAL SUBGROUP OF OR EQUAL TO
+.. |NotLess|                         unicode:: U+0226E .. NOT LESS-THAN
+.. |NotLessEqual|                    unicode:: U+02270 .. NEITHER LESS-THAN NOR EQUAL TO
+.. |NotLessGreater|                  unicode:: U+02278 .. NEITHER LESS-THAN NOR GREATER-THAN
+.. |NotLessLess|                     unicode:: U+0226A U+00338 .. MUCH LESS THAN with slash
+.. |NotLessSlantEqual|               unicode:: U+02A7D U+00338 .. LESS-THAN OR SLANTED EQUAL TO with slash
+.. |NotLessTilde|                    unicode:: U+02274 .. NEITHER LESS-THAN NOR EQUIVALENT TO
+.. |NotPrecedes|                     unicode:: U+02280 .. DOES NOT PRECEDE
+.. |NotPrecedesEqual|                unicode:: U+02AAF U+00338 .. PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash
+.. |NotPrecedesSlantEqual|           unicode:: U+022E0 .. DOES NOT PRECEDE OR EQUAL
+.. |NotReverseElement|               unicode:: U+0220C .. DOES NOT CONTAIN AS MEMBER
+.. |NotRightTriangle|                unicode:: U+022EB .. DOES NOT CONTAIN AS NORMAL SUBGROUP
+.. |NotRightTriangleEqual|           unicode:: U+022ED .. DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL
+.. |NotSquareSubsetEqual|            unicode:: U+022E2 .. NOT SQUARE IMAGE OF OR EQUAL TO
+.. |NotSquareSupersetEqual|          unicode:: U+022E3 .. NOT SQUARE ORIGINAL OF OR EQUAL TO
+.. |NotSubset|                       unicode:: U+02282 U+020D2 .. SUBSET OF with vertical line
+.. |NotSubsetEqual|                  unicode:: U+02288 .. NEITHER A SUBSET OF NOR EQUAL TO
+.. |NotSucceeds|                     unicode:: U+02281 .. DOES NOT SUCCEED
+.. |NotSucceedsEqual|                unicode:: U+02AB0 U+00338 .. SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash
+.. |NotSucceedsSlantEqual|           unicode:: U+022E1 .. DOES NOT SUCCEED OR EQUAL
+.. |NotSuperset|                     unicode:: U+02283 U+020D2 .. SUPERSET OF with vertical line
+.. |NotSupersetEqual|                unicode:: U+02289 .. NEITHER A SUPERSET OF NOR EQUAL TO
+.. |NotTilde|                        unicode:: U+02241 .. NOT TILDE
+.. |NotTildeEqual|                   unicode:: U+02244 .. NOT ASYMPTOTICALLY EQUAL TO
+.. |NotTildeFullEqual|               unicode:: U+02247 .. NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO
+.. |NotTildeTilde|                   unicode:: U+02249 .. NOT ALMOST EQUAL TO
+.. |NotVerticalBar|                  unicode:: U+02224 .. DOES NOT DIVIDE
+.. |nparallel|                       unicode:: U+02226 .. NOT PARALLEL TO
+.. |nprec|                           unicode:: U+02280 .. DOES NOT PRECEDE
+.. |npreceq|                         unicode:: U+02AAF U+00338 .. PRECEDES ABOVE SINGLE-LINE EQUALS SIGN with slash
+.. |nRightarrow|                     unicode:: U+021CF .. RIGHTWARDS DOUBLE ARROW WITH STROKE
+.. |nrightarrow|                     unicode:: U+0219B .. RIGHTWARDS ARROW WITH STROKE
+.. |nshortmid|                       unicode:: U+02224 .. DOES NOT DIVIDE
+.. |nshortparallel|                  unicode:: U+02226 .. NOT PARALLEL TO
+.. |nsimeq|                          unicode:: U+02244 .. NOT ASYMPTOTICALLY EQUAL TO
+.. |nsubset|                         unicode:: U+02282 U+020D2 .. SUBSET OF with vertical line
+.. |nsubseteq|                       unicode:: U+02288 .. NEITHER A SUBSET OF NOR EQUAL TO
+.. |nsubseteqq|                      unicode:: U+02AC5 U+00338 .. SUBSET OF ABOVE EQUALS SIGN with slash
+.. |nsucc|                           unicode:: U+02281 .. DOES NOT SUCCEED
+.. |nsucceq|                         unicode:: U+02AB0 U+00338 .. SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN with slash
+.. |nsupset|                         unicode:: U+02283 U+020D2 .. SUPERSET OF with vertical line
+.. |nsupseteq|                       unicode:: U+02289 .. NEITHER A SUPERSET OF NOR EQUAL TO
+.. |nsupseteqq|                      unicode:: U+02AC6 U+00338 .. SUPERSET OF ABOVE EQUALS SIGN with slash
+.. |ntriangleleft|                   unicode:: U+022EA .. NOT NORMAL SUBGROUP OF
+.. |ntrianglelefteq|                 unicode:: U+022EC .. NOT NORMAL SUBGROUP OF OR EQUAL TO
+.. |ntriangleright|                  unicode:: U+022EB .. DOES NOT CONTAIN AS NORMAL SUBGROUP
+.. |ntrianglerighteq|                unicode:: U+022ED .. DOES NOT CONTAIN AS NORMAL SUBGROUP OR EQUAL
+.. |nwarrow|                         unicode:: U+02196 .. NORTH WEST ARROW
+.. |oint|                            unicode:: U+0222E .. CONTOUR INTEGRAL
+.. |OpenCurlyDoubleQuote|            unicode:: U+0201C .. LEFT DOUBLE QUOTATION MARK
+.. |OpenCurlyQuote|                  unicode:: U+02018 .. LEFT SINGLE QUOTATION MARK
+.. |orderof|                         unicode:: U+02134 .. SCRIPT SMALL O
+.. |parallel|                        unicode:: U+02225 .. PARALLEL TO
+.. |PartialD|                        unicode:: U+02202 .. PARTIAL DIFFERENTIAL
+.. |pitchfork|                       unicode:: U+022D4 .. PITCHFORK
+.. |PlusMinus|                       unicode:: U+000B1 .. PLUS-MINUS SIGN
+.. |pm|                              unicode:: U+000B1 .. PLUS-MINUS SIGN
+.. |Poincareplane|                   unicode:: U+0210C .. BLACK-LETTER CAPITAL H
+.. |prec|                            unicode:: U+0227A .. PRECEDES
+.. |precapprox|                      unicode:: U+02AB7 .. PRECEDES ABOVE ALMOST EQUAL TO
+.. |preccurlyeq|                     unicode:: U+0227C .. PRECEDES OR EQUAL TO
+.. |Precedes|                        unicode:: U+0227A .. PRECEDES
+.. |PrecedesEqual|                   unicode:: U+02AAF .. PRECEDES ABOVE SINGLE-LINE EQUALS SIGN
+.. |PrecedesSlantEqual|              unicode:: U+0227C .. PRECEDES OR EQUAL TO
+.. |PrecedesTilde|                   unicode:: U+0227E .. PRECEDES OR EQUIVALENT TO
+.. |preceq|                          unicode:: U+02AAF .. PRECEDES ABOVE SINGLE-LINE EQUALS SIGN
+.. |precnapprox|                     unicode:: U+02AB9 .. PRECEDES ABOVE NOT ALMOST EQUAL TO
+.. |precneqq|                        unicode:: U+02AB5 .. PRECEDES ABOVE NOT EQUAL TO
+.. |precnsim|                        unicode:: U+022E8 .. PRECEDES BUT NOT EQUIVALENT TO
+.. |precsim|                         unicode:: U+0227E .. PRECEDES OR EQUIVALENT TO
+.. |primes|                          unicode:: U+02119 .. DOUBLE-STRUCK CAPITAL P
+.. |Proportion|                      unicode:: U+02237 .. PROPORTION
+.. |Proportional|                    unicode:: U+0221D .. PROPORTIONAL TO
+.. |propto|                          unicode:: U+0221D .. PROPORTIONAL TO
+.. |quaternions|                     unicode:: U+0210D .. DOUBLE-STRUCK CAPITAL H
+.. |questeq|                         unicode:: U+0225F .. QUESTIONED EQUAL TO
+.. |rangle|                          unicode:: U+0232A .. RIGHT-POINTING ANGLE BRACKET
+.. |rationals|                       unicode:: U+0211A .. DOUBLE-STRUCK CAPITAL Q
+.. |rbrace|                          unicode:: U+0007D .. RIGHT CURLY BRACKET
+.. |rbrack|                          unicode:: U+0005D .. RIGHT SQUARE BRACKET
+.. |Re|                              unicode:: U+0211C .. BLACK-LETTER CAPITAL R
+.. |realine|                         unicode:: U+0211B .. SCRIPT CAPITAL R
+.. |realpart|                        unicode:: U+0211C .. BLACK-LETTER CAPITAL R
+.. |reals|                           unicode:: U+0211D .. DOUBLE-STRUCK CAPITAL R
+.. |ReverseElement|                  unicode:: U+0220B .. CONTAINS AS MEMBER
+.. |ReverseEquilibrium|              unicode:: U+021CB .. LEFTWARDS HARPOON OVER RIGHTWARDS HARPOON
+.. |ReverseUpEquilibrium|            unicode:: U+0296F .. DOWNWARDS HARPOON WITH BARB LEFT BESIDE UPWARDS HARPOON WITH BARB RIGHT
+.. |RightAngleBracket|               unicode:: U+0232A .. RIGHT-POINTING ANGLE BRACKET
+.. |RightArrow|                      unicode:: U+02192 .. RIGHTWARDS ARROW
+.. |Rightarrow|                      unicode:: U+021D2 .. RIGHTWARDS DOUBLE ARROW
+.. |rightarrow|                      unicode:: U+02192 .. RIGHTWARDS ARROW
+.. |RightArrowBar|                   unicode:: U+021E5 .. RIGHTWARDS ARROW TO BAR
+.. |RightArrowLeftArrow|             unicode:: U+021C4 .. RIGHTWARDS ARROW OVER LEFTWARDS ARROW
+.. |rightarrowtail|                  unicode:: U+021A3 .. RIGHTWARDS ARROW WITH TAIL
+.. |RightCeiling|                    unicode:: U+02309 .. RIGHT CEILING
+.. |RightDoubleBracket|              unicode:: U+0301B .. RIGHT WHITE SQUARE BRACKET
+.. |RightDownVector|                 unicode:: U+021C2 .. DOWNWARDS HARPOON WITH BARB RIGHTWARDS
+.. |RightFloor|                      unicode:: U+0230B .. RIGHT FLOOR
+.. |rightharpoondown|                unicode:: U+021C1 .. RIGHTWARDS HARPOON WITH BARB DOWNWARDS
+.. |rightharpoonup|                  unicode:: U+021C0 .. RIGHTWARDS HARPOON WITH BARB UPWARDS
+.. |rightleftarrows|                 unicode:: U+021C4 .. RIGHTWARDS ARROW OVER LEFTWARDS ARROW
+.. |rightleftharpoons|               unicode:: U+021CC .. RIGHTWARDS HARPOON OVER LEFTWARDS HARPOON
+.. |rightrightarrows|                unicode:: U+021C9 .. RIGHTWARDS PAIRED ARROWS
+.. |rightsquigarrow|                 unicode:: U+0219D .. RIGHTWARDS WAVE ARROW
+.. |RightTee|                        unicode:: U+022A2 .. RIGHT TACK
+.. |RightTeeArrow|                   unicode:: U+021A6 .. RIGHTWARDS ARROW FROM BAR
+.. |rightthreetimes|                 unicode:: U+022CC .. RIGHT SEMIDIRECT PRODUCT
+.. |RightTriangle|                   unicode:: U+022B3 .. CONTAINS AS NORMAL SUBGROUP
+.. |RightTriangleEqual|              unicode:: U+022B5 .. CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
+.. |RightUpVector|                   unicode:: U+021BE .. UPWARDS HARPOON WITH BARB RIGHTWARDS
+.. |RightVector|                     unicode:: U+021C0 .. RIGHTWARDS HARPOON WITH BARB UPWARDS
+.. |risingdotseq|                    unicode:: U+02253 .. IMAGE OF OR APPROXIMATELY EQUAL TO
+.. |rmoustache|                      unicode:: U+023B1 .. UPPER RIGHT OR LOWER LEFT CURLY BRACKET SECTION
+.. |Rrightarrow|                     unicode:: U+021DB .. RIGHTWARDS TRIPLE ARROW
+.. |Rsh|                             unicode:: U+021B1 .. UPWARDS ARROW WITH TIP RIGHTWARDS
+.. |searrow|                         unicode:: U+02198 .. SOUTH EAST ARROW
+.. |setminus|                        unicode:: U+02216 .. SET MINUS
+.. |ShortDownArrow|                  unicode:: U+02193 .. DOWNWARDS ARROW
+.. |ShortLeftArrow|                  unicode:: U+02190 .. LEFTWARDS ARROW
+.. |shortmid|                        unicode:: U+02223 .. DIVIDES
+.. |shortparallel|                   unicode:: U+02225 .. PARALLEL TO
+.. |ShortRightArrow|                 unicode:: U+02192 .. RIGHTWARDS ARROW
+.. |ShortUpArrow|                    unicode:: U+02191 .. UPWARDS ARROW
+.. |simeq|                           unicode:: U+02243 .. ASYMPTOTICALLY EQUAL TO
+.. |SmallCircle|                     unicode:: U+02218 .. RING OPERATOR
+.. |smallsetminus|                   unicode:: U+02216 .. SET MINUS
+.. |spadesuit|                       unicode:: U+02660 .. BLACK SPADE SUIT
+.. |Sqrt|                            unicode:: U+0221A .. SQUARE ROOT
+.. |sqsubset|                        unicode:: U+0228F .. SQUARE IMAGE OF
+.. |sqsubseteq|                      unicode:: U+02291 .. SQUARE IMAGE OF OR EQUAL TO
+.. |sqsupset|                        unicode:: U+02290 .. SQUARE ORIGINAL OF
+.. |sqsupseteq|                      unicode:: U+02292 .. SQUARE ORIGINAL OF OR EQUAL TO
+.. |Square|                          unicode:: U+025A1 .. WHITE SQUARE
+.. |SquareIntersection|              unicode:: U+02293 .. SQUARE CAP
+.. |SquareSubset|                    unicode:: U+0228F .. SQUARE IMAGE OF
+.. |SquareSubsetEqual|               unicode:: U+02291 .. SQUARE IMAGE OF OR EQUAL TO
+.. |SquareSuperset|                  unicode:: U+02290 .. SQUARE ORIGINAL OF
+.. |SquareSupersetEqual|             unicode:: U+02292 .. SQUARE ORIGINAL OF OR EQUAL TO
+.. |SquareUnion|                     unicode:: U+02294 .. SQUARE CUP
+.. |Star|                            unicode:: U+022C6 .. STAR OPERATOR
+.. |straightepsilon|                 unicode:: U+003F5 .. GREEK LUNATE EPSILON SYMBOL
+.. |straightphi|                     unicode:: U+003D5 .. GREEK PHI SYMBOL
+.. |Subset|                          unicode:: U+022D0 .. DOUBLE SUBSET
+.. |subset|                          unicode:: U+02282 .. SUBSET OF
+.. |subseteq|                        unicode:: U+02286 .. SUBSET OF OR EQUAL TO
+.. |subseteqq|                       unicode:: U+02AC5 .. SUBSET OF ABOVE EQUALS SIGN
+.. |SubsetEqual|                     unicode:: U+02286 .. SUBSET OF OR EQUAL TO
+.. |subsetneq|                       unicode:: U+0228A .. SUBSET OF WITH NOT EQUAL TO
+.. |subsetneqq|                      unicode:: U+02ACB .. SUBSET OF ABOVE NOT EQUAL TO
+.. |succ|                            unicode:: U+0227B .. SUCCEEDS
+.. |succapprox|                      unicode:: U+02AB8 .. SUCCEEDS ABOVE ALMOST EQUAL TO
+.. |succcurlyeq|                     unicode:: U+0227D .. SUCCEEDS OR EQUAL TO
+.. |Succeeds|                        unicode:: U+0227B .. SUCCEEDS
+.. |SucceedsEqual|                   unicode:: U+02AB0 .. SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN
+.. |SucceedsSlantEqual|              unicode:: U+0227D .. SUCCEEDS OR EQUAL TO
+.. |SucceedsTilde|                   unicode:: U+0227F .. SUCCEEDS OR EQUIVALENT TO
+.. |succeq|                          unicode:: U+02AB0 .. SUCCEEDS ABOVE SINGLE-LINE EQUALS SIGN
+.. |succnapprox|                     unicode:: U+02ABA .. SUCCEEDS ABOVE NOT ALMOST EQUAL TO
+.. |succneqq|                        unicode:: U+02AB6 .. SUCCEEDS ABOVE NOT EQUAL TO
+.. |succnsim|                        unicode:: U+022E9 .. SUCCEEDS BUT NOT EQUIVALENT TO
+.. |succsim|                         unicode:: U+0227F .. SUCCEEDS OR EQUIVALENT TO
+.. |SuchThat|                        unicode:: U+0220B .. CONTAINS AS MEMBER
+.. |Sum|                             unicode:: U+02211 .. N-ARY SUMMATION
+.. |Superset|                        unicode:: U+02283 .. SUPERSET OF
+.. |SupersetEqual|                   unicode:: U+02287 .. SUPERSET OF OR EQUAL TO
+.. |Supset|                          unicode:: U+022D1 .. DOUBLE SUPERSET
+.. |supset|                          unicode:: U+02283 .. SUPERSET OF
+.. |supseteq|                        unicode:: U+02287 .. SUPERSET OF OR EQUAL TO
+.. |supseteqq|                       unicode:: U+02AC6 .. SUPERSET OF ABOVE EQUALS SIGN
+.. |supsetneq|                       unicode:: U+0228B .. SUPERSET OF WITH NOT EQUAL TO
+.. |supsetneqq|                      unicode:: U+02ACC .. SUPERSET OF ABOVE NOT EQUAL TO
+.. |swarrow|                         unicode:: U+02199 .. SOUTH WEST ARROW
+.. |Therefore|                       unicode:: U+02234 .. THEREFORE
+.. |therefore|                       unicode:: U+02234 .. THEREFORE
+.. |thickapprox|                     unicode:: U+02248 .. ALMOST EQUAL TO
+.. |thicksim|                        unicode:: U+0223C .. TILDE OPERATOR
+.. |ThinSpace|                       unicode:: U+02009 .. THIN SPACE
+.. |Tilde|                           unicode:: U+0223C .. TILDE OPERATOR
+.. |TildeEqual|                      unicode:: U+02243 .. ASYMPTOTICALLY EQUAL TO
+.. |TildeFullEqual|                  unicode:: U+02245 .. APPROXIMATELY EQUAL TO
+.. |TildeTilde|                      unicode:: U+02248 .. ALMOST EQUAL TO
+.. |toea|                            unicode:: U+02928 .. NORTH EAST ARROW AND SOUTH EAST ARROW
+.. |tosa|                            unicode:: U+02929 .. SOUTH EAST ARROW AND SOUTH WEST ARROW
+.. |triangle|                        unicode:: U+025B5 .. WHITE UP-POINTING SMALL TRIANGLE
+.. |triangledown|                    unicode:: U+025BF .. WHITE DOWN-POINTING SMALL TRIANGLE
+.. |triangleleft|                    unicode:: U+025C3 .. WHITE LEFT-POINTING SMALL TRIANGLE
+.. |trianglelefteq|                  unicode:: U+022B4 .. NORMAL SUBGROUP OF OR EQUAL TO
+.. |triangleq|                       unicode:: U+0225C .. DELTA EQUAL TO
+.. |triangleright|                   unicode:: U+025B9 .. WHITE RIGHT-POINTING SMALL TRIANGLE
+.. |trianglerighteq|                 unicode:: U+022B5 .. CONTAINS AS NORMAL SUBGROUP OR EQUAL TO
+.. |TripleDot|                       unicode:: U+020DB .. COMBINING THREE DOTS ABOVE
+.. |twoheadleftarrow|                unicode:: U+0219E .. LEFTWARDS TWO HEADED ARROW
+.. |twoheadrightarrow|               unicode:: U+021A0 .. RIGHTWARDS TWO HEADED ARROW
+.. |ulcorner|                        unicode:: U+0231C .. TOP LEFT CORNER
+.. |Union|                           unicode:: U+022C3 .. N-ARY UNION
+.. |UnionPlus|                       unicode:: U+0228E .. MULTISET UNION
+.. |UpArrow|                         unicode:: U+02191 .. UPWARDS ARROW
+.. |Uparrow|                         unicode:: U+021D1 .. UPWARDS DOUBLE ARROW
+.. |uparrow|                         unicode:: U+02191 .. UPWARDS ARROW
+.. |UpArrowDownArrow|                unicode:: U+021C5 .. UPWARDS ARROW LEFTWARDS OF DOWNWARDS ARROW
+.. |UpDownArrow|                     unicode:: U+02195 .. UP DOWN ARROW
+.. |Updownarrow|                     unicode:: U+021D5 .. UP DOWN DOUBLE ARROW
+.. |updownarrow|                     unicode:: U+02195 .. UP DOWN ARROW
+.. |UpEquilibrium|                   unicode:: U+0296E .. UPWARDS HARPOON WITH BARB LEFT BESIDE DOWNWARDS HARPOON WITH BARB RIGHT
+.. |upharpoonleft|                   unicode:: U+021BF .. UPWARDS HARPOON WITH BARB LEFTWARDS
+.. |upharpoonright|                  unicode:: U+021BE .. UPWARDS HARPOON WITH BARB RIGHTWARDS
+.. |UpperLeftArrow|                  unicode:: U+02196 .. NORTH WEST ARROW
+.. |UpperRightArrow|                 unicode:: U+02197 .. NORTH EAST ARROW
+.. |upsilon|                         unicode:: U+003C5 .. GREEK SMALL LETTER UPSILON
+.. |UpTee|                           unicode:: U+022A5 .. UP TACK
+.. |UpTeeArrow|                      unicode:: U+021A5 .. UPWARDS ARROW FROM BAR
+.. |upuparrows|                      unicode:: U+021C8 .. UPWARDS PAIRED ARROWS
+.. |urcorner|                        unicode:: U+0231D .. TOP RIGHT CORNER
+.. |varepsilon|                      unicode:: U+003B5 .. GREEK SMALL LETTER EPSILON
+.. |varkappa|                        unicode:: U+003F0 .. GREEK KAPPA SYMBOL
+.. |varnothing|                      unicode:: U+02205 .. EMPTY SET
+.. |varphi|                          unicode:: U+003C6 .. GREEK SMALL LETTER PHI
+.. |varpi|                           unicode:: U+003D6 .. GREEK PI SYMBOL
+.. |varpropto|                       unicode:: U+0221D .. PROPORTIONAL TO
+.. |varrho|                          unicode:: U+003F1 .. GREEK RHO SYMBOL
+.. |varsigma|                        unicode:: U+003C2 .. GREEK SMALL LETTER FINAL SIGMA
+.. |varsubsetneq|                    unicode:: U+0228A U+0FE00 .. SUBSET OF WITH NOT EQUAL TO - variant with stroke through bottom members
+.. |varsubsetneqq|                   unicode:: U+02ACB U+0FE00 .. SUBSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members
+.. |varsupsetneq|                    unicode:: U+0228B U+0FE00 .. SUPERSET OF WITH NOT EQUAL TO - variant with stroke through bottom members
+.. |varsupsetneqq|                   unicode:: U+02ACC U+0FE00 .. SUPERSET OF ABOVE NOT EQUAL TO - variant with stroke through bottom members
+.. |vartheta|                        unicode:: U+003D1 .. GREEK THETA SYMBOL
+.. |vartriangleleft|                 unicode:: U+022B2 .. NORMAL SUBGROUP OF
+.. |vartriangleright|                unicode:: U+022B3 .. CONTAINS AS NORMAL SUBGROUP
+.. |Vee|                             unicode:: U+022C1 .. N-ARY LOGICAL OR
+.. |vee|                             unicode:: U+02228 .. LOGICAL OR
+.. |Vert|                            unicode:: U+02016 .. DOUBLE VERTICAL LINE
+.. |vert|                            unicode:: U+0007C .. VERTICAL LINE
+.. |VerticalBar|                     unicode:: U+02223 .. DIVIDES
+.. |VerticalTilde|                   unicode:: U+02240 .. WREATH PRODUCT
+.. |VeryThinSpace|                   unicode:: U+0200A .. HAIR SPACE
+.. |Wedge|                           unicode:: U+022C0 .. N-ARY LOGICAL AND
+.. |wedge|                           unicode:: U+02227 .. LOGICAL AND
+.. |wp|                              unicode:: U+02118 .. SCRIPT CAPITAL P
+.. |wr|                              unicode:: U+02240 .. WREATH PRODUCT
+.. |zeetrf|                          unicode:: U+02128 .. BLACK-LETTER CAPITAL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlextra-wide.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlextra-wide.txt
new file mode 100644
index 00000000..f45fc8cb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlextra-wide.txt
@@ -0,0 +1,113 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |af|                      unicode:: U+02061 .. FUNCTION APPLICATION
+.. |aopf|                    unicode:: U+1D552 .. MATHEMATICAL DOUBLE-STRUCK SMALL A
+.. |asympeq|                 unicode:: U+0224D .. EQUIVALENT TO
+.. |bopf|                    unicode:: U+1D553 .. MATHEMATICAL DOUBLE-STRUCK SMALL B
+.. |copf|                    unicode:: U+1D554 .. MATHEMATICAL DOUBLE-STRUCK SMALL C
+.. |Cross|                   unicode:: U+02A2F .. VECTOR OR CROSS PRODUCT
+.. |DD|                      unicode:: U+02145 .. DOUBLE-STRUCK ITALIC CAPITAL D
+.. |dd|                      unicode:: U+02146 .. DOUBLE-STRUCK ITALIC SMALL D
+.. |dopf|                    unicode:: U+1D555 .. MATHEMATICAL DOUBLE-STRUCK SMALL D
+.. |DownArrowBar|            unicode:: U+02913 .. DOWNWARDS ARROW TO BAR
+.. |DownBreve|               unicode:: U+00311 .. COMBINING INVERTED BREVE
+.. |DownLeftRightVector|     unicode:: U+02950 .. LEFT BARB DOWN RIGHT BARB DOWN HARPOON
+.. |DownLeftTeeVector|       unicode:: U+0295E .. LEFTWARDS HARPOON WITH BARB DOWN FROM BAR
+.. |DownLeftVectorBar|       unicode:: U+02956 .. LEFTWARDS HARPOON WITH BARB DOWN TO BAR
+.. |DownRightTeeVector|      unicode:: U+0295F .. RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR
+.. |DownRightVectorBar|      unicode:: U+02957 .. RIGHTWARDS HARPOON WITH BARB DOWN TO BAR
+.. |ee|                      unicode:: U+02147 .. DOUBLE-STRUCK ITALIC SMALL E
+.. |EmptySmallSquare|        unicode:: U+025FB .. WHITE MEDIUM SQUARE
+.. |EmptyVerySmallSquare|    unicode:: U+025AB .. WHITE SMALL SQUARE
+.. |eopf|                    unicode:: U+1D556 .. MATHEMATICAL DOUBLE-STRUCK SMALL E
+.. |Equal|                   unicode:: U+02A75 .. TWO CONSECUTIVE EQUALS SIGNS
+.. |FilledSmallSquare|       unicode:: U+025FC .. BLACK MEDIUM SQUARE
+.. |FilledVerySmallSquare|   unicode:: U+025AA .. BLACK SMALL SQUARE
+.. |fopf|                    unicode:: U+1D557 .. MATHEMATICAL DOUBLE-STRUCK SMALL F
+.. |gopf|                    unicode:: U+1D558 .. MATHEMATICAL DOUBLE-STRUCK SMALL G
+.. |GreaterGreater|          unicode:: U+02AA2 .. DOUBLE NESTED GREATER-THAN
+.. |Hat|                     unicode:: U+0005E .. CIRCUMFLEX ACCENT
+.. |hopf|                    unicode:: U+1D559 .. MATHEMATICAL DOUBLE-STRUCK SMALL H
+.. |HorizontalLine|          unicode:: U+02500 .. BOX DRAWINGS LIGHT HORIZONTAL
+.. |ic|                      unicode:: U+02063 .. INVISIBLE SEPARATOR
+.. |ii|                      unicode:: U+02148 .. DOUBLE-STRUCK ITALIC SMALL I
+.. |iopf|                    unicode:: U+1D55A .. MATHEMATICAL DOUBLE-STRUCK SMALL I
+.. |it|                      unicode:: U+02062 .. INVISIBLE TIMES
+.. |jopf|                    unicode:: U+1D55B .. MATHEMATICAL DOUBLE-STRUCK SMALL J
+.. |kopf|                    unicode:: U+1D55C .. MATHEMATICAL DOUBLE-STRUCK SMALL K
+.. |larrb|                   unicode:: U+021E4 .. LEFTWARDS ARROW TO BAR
+.. |LeftDownTeeVector|       unicode:: U+02961 .. DOWNWARDS HARPOON WITH BARB LEFT FROM BAR
+.. |LeftDownVectorBar|       unicode:: U+02959 .. DOWNWARDS HARPOON WITH BARB LEFT TO BAR
+.. |LeftRightVector|         unicode:: U+0294E .. LEFT BARB UP RIGHT BARB UP HARPOON
+.. |LeftTeeVector|           unicode:: U+0295A .. LEFTWARDS HARPOON WITH BARB UP FROM BAR
+.. |LeftTriangleBar|         unicode:: U+029CF .. LEFT TRIANGLE BESIDE VERTICAL BAR
+.. |LeftUpDownVector|        unicode:: U+02951 .. UP BARB LEFT DOWN BARB LEFT HARPOON
+.. |LeftUpTeeVector|         unicode:: U+02960 .. UPWARDS HARPOON WITH BARB LEFT FROM BAR
+.. |LeftUpVectorBar|         unicode:: U+02958 .. UPWARDS HARPOON WITH BARB LEFT TO BAR
+.. |LeftVectorBar|           unicode:: U+02952 .. LEFTWARDS HARPOON WITH BARB UP TO BAR
+.. |LessLess|                unicode:: U+02AA1 .. DOUBLE NESTED LESS-THAN
+.. |lopf|                    unicode:: U+1D55D .. MATHEMATICAL DOUBLE-STRUCK SMALL L
+.. |mapstodown|              unicode:: U+021A7 .. DOWNWARDS ARROW FROM BAR
+.. |mapstoleft|              unicode:: U+021A4 .. LEFTWARDS ARROW FROM BAR
+.. |mapstoup|                unicode:: U+021A5 .. UPWARDS ARROW FROM BAR
+.. |MediumSpace|             unicode:: U+0205F .. MEDIUM MATHEMATICAL SPACE
+.. |mopf|                    unicode:: U+1D55E .. MATHEMATICAL DOUBLE-STRUCK SMALL M
+.. |nbump|                   unicode:: U+0224E U+00338 .. GEOMETRICALLY EQUIVALENT TO with slash
+.. |nbumpe|                  unicode:: U+0224F U+00338 .. DIFFERENCE BETWEEN with slash
+.. |nesim|                   unicode:: U+02242 U+00338 .. MINUS TILDE with slash
+.. |NewLine|                 unicode:: U+0000A .. LINE FEED (LF)
+.. |NoBreak|                 unicode:: U+02060 .. WORD JOINER
+.. |nopf|                    unicode:: U+1D55F .. MATHEMATICAL DOUBLE-STRUCK SMALL N
+.. |NotCupCap|               unicode:: U+0226D .. NOT EQUIVALENT TO
+.. |NotHumpEqual|            unicode:: U+0224F U+00338 .. DIFFERENCE BETWEEN with slash
+.. |NotLeftTriangleBar|      unicode:: U+029CF U+00338 .. LEFT TRIANGLE BESIDE VERTICAL BAR with slash
+.. |NotNestedGreaterGreater| unicode:: U+02AA2 U+00338 .. DOUBLE NESTED GREATER-THAN with slash
+.. |NotNestedLessLess|       unicode:: U+02AA1 U+00338 .. DOUBLE NESTED LESS-THAN with slash
+.. |NotRightTriangleBar|     unicode:: U+029D0 U+00338 .. VERTICAL BAR BESIDE RIGHT TRIANGLE with slash
+.. |NotSquareSubset|         unicode:: U+0228F U+00338 .. SQUARE IMAGE OF with slash
+.. |NotSquareSuperset|       unicode:: U+02290 U+00338 .. SQUARE ORIGINAL OF with slash
+.. |NotSucceedsTilde|        unicode:: U+0227F U+00338 .. SUCCEEDS OR EQUIVALENT TO with slash
+.. |oopf|                    unicode:: U+1D560 .. MATHEMATICAL DOUBLE-STRUCK SMALL O
+.. |OverBar|                 unicode:: U+000AF .. MACRON
+.. |OverBrace|               unicode:: U+0FE37 .. PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
+.. |OverBracket|             unicode:: U+023B4 .. TOP SQUARE BRACKET
+.. |OverParenthesis|         unicode:: U+0FE35 .. PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
+.. |planckh|                 unicode:: U+0210E .. PLANCK CONSTANT
+.. |popf|                    unicode:: U+1D561 .. MATHEMATICAL DOUBLE-STRUCK SMALL P
+.. |Product|                 unicode:: U+0220F .. N-ARY PRODUCT
+.. |qopf|                    unicode:: U+1D562 .. MATHEMATICAL DOUBLE-STRUCK SMALL Q
+.. |rarrb|                   unicode:: U+021E5 .. RIGHTWARDS ARROW TO BAR
+.. |RightDownTeeVector|      unicode:: U+0295D .. DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR
+.. |RightDownVectorBar|      unicode:: U+02955 .. DOWNWARDS HARPOON WITH BARB RIGHT TO BAR
+.. |RightTeeVector|          unicode:: U+0295B .. RIGHTWARDS HARPOON WITH BARB UP FROM BAR
+.. |RightTriangleBar|        unicode:: U+029D0 .. VERTICAL BAR BESIDE RIGHT TRIANGLE
+.. |RightUpDownVector|       unicode:: U+0294F .. UP BARB RIGHT DOWN BARB RIGHT HARPOON
+.. |RightUpTeeVector|        unicode:: U+0295C .. UPWARDS HARPOON WITH BARB RIGHT FROM BAR
+.. |RightUpVectorBar|        unicode:: U+02954 .. UPWARDS HARPOON WITH BARB RIGHT TO BAR
+.. |RightVectorBar|          unicode:: U+02953 .. RIGHTWARDS HARPOON WITH BARB UP TO BAR
+.. |ropf|                    unicode:: U+1D563 .. MATHEMATICAL DOUBLE-STRUCK SMALL R
+.. |RoundImplies|            unicode:: U+02970 .. RIGHT DOUBLE ARROW WITH ROUNDED HEAD
+.. |RuleDelayed|             unicode:: U+029F4 .. RULE-DELAYED
+.. |sopf|                    unicode:: U+1D564 .. MATHEMATICAL DOUBLE-STRUCK SMALL S
+.. |Tab|                     unicode:: U+00009 .. CHARACTER TABULATION
+.. |ThickSpace|              unicode:: U+02009 U+0200A U+0200A .. space of width 5/18 em
+.. |topf|                    unicode:: U+1D565 .. MATHEMATICAL DOUBLE-STRUCK SMALL T
+.. |UnderBar|                unicode:: U+00332 .. COMBINING LOW LINE
+.. |UnderBrace|              unicode:: U+0FE38 .. PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
+.. |UnderBracket|            unicode:: U+023B5 .. BOTTOM SQUARE BRACKET
+.. |UnderParenthesis|        unicode:: U+0FE36 .. PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
+.. |uopf|                    unicode:: U+1D566 .. MATHEMATICAL DOUBLE-STRUCK SMALL U
+.. |UpArrowBar|              unicode:: U+02912 .. UPWARDS ARROW TO BAR
+.. |Upsilon|                 unicode:: U+003A5 .. GREEK CAPITAL LETTER UPSILON
+.. |VerticalLine|            unicode:: U+0007C .. VERTICAL LINE
+.. |VerticalSeparator|       unicode:: U+02758 .. LIGHT VERTICAL BAR
+.. |vopf|                    unicode:: U+1D567 .. MATHEMATICAL DOUBLE-STRUCK SMALL V
+.. |wopf|                    unicode:: U+1D568 .. MATHEMATICAL DOUBLE-STRUCK SMALL W
+.. |xopf|                    unicode:: U+1D569 .. MATHEMATICAL DOUBLE-STRUCK SMALL X
+.. |yopf|                    unicode:: U+1D56A .. MATHEMATICAL DOUBLE-STRUCK SMALL Y
+.. |ZeroWidthSpace|          unicode:: U+0200B .. ZERO WIDTH SPACE
+.. |zopf|                    unicode:: U+1D56B .. MATHEMATICAL DOUBLE-STRUCK SMALL Z
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlextra.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlextra.txt
new file mode 100644
index 00000000..27262473
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/mmlextra.txt
@@ -0,0 +1,87 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |af|                      unicode:: U+02061 .. FUNCTION APPLICATION
+.. |asympeq|                 unicode:: U+0224D .. EQUIVALENT TO
+.. |Cross|                   unicode:: U+02A2F .. VECTOR OR CROSS PRODUCT
+.. |DD|                      unicode:: U+02145 .. DOUBLE-STRUCK ITALIC CAPITAL D
+.. |dd|                      unicode:: U+02146 .. DOUBLE-STRUCK ITALIC SMALL D
+.. |DownArrowBar|            unicode:: U+02913 .. DOWNWARDS ARROW TO BAR
+.. |DownBreve|               unicode:: U+00311 .. COMBINING INVERTED BREVE
+.. |DownLeftRightVector|     unicode:: U+02950 .. LEFT BARB DOWN RIGHT BARB DOWN HARPOON
+.. |DownLeftTeeVector|       unicode:: U+0295E .. LEFTWARDS HARPOON WITH BARB DOWN FROM BAR
+.. |DownLeftVectorBar|       unicode:: U+02956 .. LEFTWARDS HARPOON WITH BARB DOWN TO BAR
+.. |DownRightTeeVector|      unicode:: U+0295F .. RIGHTWARDS HARPOON WITH BARB DOWN FROM BAR
+.. |DownRightVectorBar|      unicode:: U+02957 .. RIGHTWARDS HARPOON WITH BARB DOWN TO BAR
+.. |ee|                      unicode:: U+02147 .. DOUBLE-STRUCK ITALIC SMALL E
+.. |EmptySmallSquare|        unicode:: U+025FB .. WHITE MEDIUM SQUARE
+.. |EmptyVerySmallSquare|    unicode:: U+025AB .. WHITE SMALL SQUARE
+.. |Equal|                   unicode:: U+02A75 .. TWO CONSECUTIVE EQUALS SIGNS
+.. |FilledSmallSquare|       unicode:: U+025FC .. BLACK MEDIUM SQUARE
+.. |FilledVerySmallSquare|   unicode:: U+025AA .. BLACK SMALL SQUARE
+.. |GreaterGreater|          unicode:: U+02AA2 .. DOUBLE NESTED GREATER-THAN
+.. |Hat|                     unicode:: U+0005E .. CIRCUMFLEX ACCENT
+.. |HorizontalLine|          unicode:: U+02500 .. BOX DRAWINGS LIGHT HORIZONTAL
+.. |ic|                      unicode:: U+02063 .. INVISIBLE SEPARATOR
+.. |ii|                      unicode:: U+02148 .. DOUBLE-STRUCK ITALIC SMALL I
+.. |it|                      unicode:: U+02062 .. INVISIBLE TIMES
+.. |larrb|                   unicode:: U+021E4 .. LEFTWARDS ARROW TO BAR
+.. |LeftDownTeeVector|       unicode:: U+02961 .. DOWNWARDS HARPOON WITH BARB LEFT FROM BAR
+.. |LeftDownVectorBar|       unicode:: U+02959 .. DOWNWARDS HARPOON WITH BARB LEFT TO BAR
+.. |LeftRightVector|         unicode:: U+0294E .. LEFT BARB UP RIGHT BARB UP HARPOON
+.. |LeftTeeVector|           unicode:: U+0295A .. LEFTWARDS HARPOON WITH BARB UP FROM BAR
+.. |LeftTriangleBar|         unicode:: U+029CF .. LEFT TRIANGLE BESIDE VERTICAL BAR
+.. |LeftUpDownVector|        unicode:: U+02951 .. UP BARB LEFT DOWN BARB LEFT HARPOON
+.. |LeftUpTeeVector|         unicode:: U+02960 .. UPWARDS HARPOON WITH BARB LEFT FROM BAR
+.. |LeftUpVectorBar|         unicode:: U+02958 .. UPWARDS HARPOON WITH BARB LEFT TO BAR
+.. |LeftVectorBar|           unicode:: U+02952 .. LEFTWARDS HARPOON WITH BARB UP TO BAR
+.. |LessLess|                unicode:: U+02AA1 .. DOUBLE NESTED LESS-THAN
+.. |mapstodown|              unicode:: U+021A7 .. DOWNWARDS ARROW FROM BAR
+.. |mapstoleft|              unicode:: U+021A4 .. LEFTWARDS ARROW FROM BAR
+.. |mapstoup|                unicode:: U+021A5 .. UPWARDS ARROW FROM BAR
+.. |MediumSpace|             unicode:: U+0205F .. MEDIUM MATHEMATICAL SPACE
+.. |nbump|                   unicode:: U+0224E U+00338 .. GEOMETRICALLY EQUIVALENT TO with slash
+.. |nbumpe|                  unicode:: U+0224F U+00338 .. DIFFERENCE BETWEEN with slash
+.. |nesim|                   unicode:: U+02242 U+00338 .. MINUS TILDE with slash
+.. |NewLine|                 unicode:: U+0000A .. LINE FEED (LF)
+.. |NoBreak|                 unicode:: U+02060 .. WORD JOINER
+.. |NotCupCap|               unicode:: U+0226D .. NOT EQUIVALENT TO
+.. |NotHumpEqual|            unicode:: U+0224F U+00338 .. DIFFERENCE BETWEEN with slash
+.. |NotLeftTriangleBar|      unicode:: U+029CF U+00338 .. LEFT TRIANGLE BESIDE VERTICAL BAR with slash
+.. |NotNestedGreaterGreater| unicode:: U+02AA2 U+00338 .. DOUBLE NESTED GREATER-THAN with slash
+.. |NotNestedLessLess|       unicode:: U+02AA1 U+00338 .. DOUBLE NESTED LESS-THAN with slash
+.. |NotRightTriangleBar|     unicode:: U+029D0 U+00338 .. VERTICAL BAR BESIDE RIGHT TRIANGLE with slash
+.. |NotSquareSubset|         unicode:: U+0228F U+00338 .. SQUARE IMAGE OF with slash
+.. |NotSquareSuperset|       unicode:: U+02290 U+00338 .. SQUARE ORIGINAL OF with slash
+.. |NotSucceedsTilde|        unicode:: U+0227F U+00338 .. SUCCEEDS OR EQUIVALENT TO with slash
+.. |OverBar|                 unicode:: U+000AF .. MACRON
+.. |OverBrace|               unicode:: U+0FE37 .. PRESENTATION FORM FOR VERTICAL LEFT CURLY BRACKET
+.. |OverBracket|             unicode:: U+023B4 .. TOP SQUARE BRACKET
+.. |OverParenthesis|         unicode:: U+0FE35 .. PRESENTATION FORM FOR VERTICAL LEFT PARENTHESIS
+.. |planckh|                 unicode:: U+0210E .. PLANCK CONSTANT
+.. |Product|                 unicode:: U+0220F .. N-ARY PRODUCT
+.. |rarrb|                   unicode:: U+021E5 .. RIGHTWARDS ARROW TO BAR
+.. |RightDownTeeVector|      unicode:: U+0295D .. DOWNWARDS HARPOON WITH BARB RIGHT FROM BAR
+.. |RightDownVectorBar|      unicode:: U+02955 .. DOWNWARDS HARPOON WITH BARB RIGHT TO BAR
+.. |RightTeeVector|          unicode:: U+0295B .. RIGHTWARDS HARPOON WITH BARB UP FROM BAR
+.. |RightTriangleBar|        unicode:: U+029D0 .. VERTICAL BAR BESIDE RIGHT TRIANGLE
+.. |RightUpDownVector|       unicode:: U+0294F .. UP BARB RIGHT DOWN BARB RIGHT HARPOON
+.. |RightUpTeeVector|        unicode:: U+0295C .. UPWARDS HARPOON WITH BARB RIGHT FROM BAR
+.. |RightUpVectorBar|        unicode:: U+02954 .. UPWARDS HARPOON WITH BARB RIGHT TO BAR
+.. |RightVectorBar|          unicode:: U+02953 .. RIGHTWARDS HARPOON WITH BARB UP TO BAR
+.. |RoundImplies|            unicode:: U+02970 .. RIGHT DOUBLE ARROW WITH ROUNDED HEAD
+.. |RuleDelayed|             unicode:: U+029F4 .. RULE-DELAYED
+.. |Tab|                     unicode:: U+00009 .. CHARACTER TABULATION
+.. |ThickSpace|              unicode:: U+02009 U+0200A U+0200A .. space of width 5/18 em
+.. |UnderBar|                unicode:: U+00332 .. COMBINING LOW LINE
+.. |UnderBrace|              unicode:: U+0FE38 .. PRESENTATION FORM FOR VERTICAL RIGHT CURLY BRACKET
+.. |UnderBracket|            unicode:: U+023B5 .. BOTTOM SQUARE BRACKET
+.. |UnderParenthesis|        unicode:: U+0FE36 .. PRESENTATION FORM FOR VERTICAL RIGHT PARENTHESIS
+.. |UpArrowBar|              unicode:: U+02912 .. UPWARDS ARROW TO BAR
+.. |Upsilon|                 unicode:: U+003A5 .. GREEK CAPITAL LETTER UPSILON
+.. |VerticalLine|            unicode:: U+0007C .. VERTICAL LINE
+.. |VerticalSeparator|       unicode:: U+02758 .. LIGHT VERTICAL BAR
+.. |ZeroWidthSpace|          unicode:: U+0200B .. ZERO WIDTH SPACE
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/s5defs.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/s5defs.txt
new file mode 100644
index 00000000..8aceeac0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/s5defs.txt
@@ -0,0 +1,68 @@
+.. Definitions of interpreted text roles (classes) for S5/HTML data.
+.. This data file has been placed in the public domain.
+
+.. Colours
+   =======
+
+.. role:: black
+.. role:: gray
+.. role:: silver
+.. role:: white
+
+.. role:: maroon
+.. role:: red
+.. role:: magenta
+.. role:: fuchsia
+.. role:: pink
+.. role:: orange
+.. role:: yellow
+.. role:: lime
+.. role:: green
+.. role:: olive
+.. role:: teal
+.. role:: cyan
+.. role:: aqua
+.. role:: blue
+.. role:: navy
+.. role:: purple
+
+
+.. Text Sizes
+   ==========
+
+.. role:: huge
+.. role:: big
+.. role:: small
+.. role:: tiny
+
+
+.. Display in Slides (Presentation Mode) Only
+   ==========================================
+
+.. role:: slide
+   :class: slide-display
+
+
+.. Display in Outline Mode Only
+   ============================
+
+.. role:: outline
+
+
+.. Display in Print Only
+   =====================
+
+.. role:: print
+
+
+.. Display in Handout Mode Only
+   ============================
+
+.. role:: handout
+
+
+.. Incremental Display
+   ===================
+
+.. role:: incremental
+.. default-role:: incremental
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-lat1.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-lat1.txt
new file mode 100644
index 00000000..1cae194e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-lat1.txt
@@ -0,0 +1,102 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |Aacute| unicode:: U+000C1 .. LATIN CAPITAL LETTER A WITH ACUTE
+.. |aacute| unicode:: U+000E1 .. LATIN SMALL LETTER A WITH ACUTE
+.. |Acirc|  unicode:: U+000C2 .. LATIN CAPITAL LETTER A WITH CIRCUMFLEX
+.. |acirc|  unicode:: U+000E2 .. LATIN SMALL LETTER A WITH CIRCUMFLEX
+.. |acute|  unicode:: U+000B4 .. ACUTE ACCENT
+.. |AElig|  unicode:: U+000C6 .. LATIN CAPITAL LETTER AE
+.. |aelig|  unicode:: U+000E6 .. LATIN SMALL LETTER AE
+.. |Agrave| unicode:: U+000C0 .. LATIN CAPITAL LETTER A WITH GRAVE
+.. |agrave| unicode:: U+000E0 .. LATIN SMALL LETTER A WITH GRAVE
+.. |Aring|  unicode:: U+000C5 .. LATIN CAPITAL LETTER A WITH RING ABOVE
+.. |aring|  unicode:: U+000E5 .. LATIN SMALL LETTER A WITH RING ABOVE
+.. |Atilde| unicode:: U+000C3 .. LATIN CAPITAL LETTER A WITH TILDE
+.. |atilde| unicode:: U+000E3 .. LATIN SMALL LETTER A WITH TILDE
+.. |Auml|   unicode:: U+000C4 .. LATIN CAPITAL LETTER A WITH DIAERESIS
+.. |auml|   unicode:: U+000E4 .. LATIN SMALL LETTER A WITH DIAERESIS
+.. |brvbar| unicode:: U+000A6 .. BROKEN BAR
+.. |Ccedil| unicode:: U+000C7 .. LATIN CAPITAL LETTER C WITH CEDILLA
+.. |ccedil| unicode:: U+000E7 .. LATIN SMALL LETTER C WITH CEDILLA
+.. |cedil|  unicode:: U+000B8 .. CEDILLA
+.. |cent|   unicode:: U+000A2 .. CENT SIGN
+.. |copy|   unicode:: U+000A9 .. COPYRIGHT SIGN
+.. |curren| unicode:: U+000A4 .. CURRENCY SIGN
+.. |deg|    unicode:: U+000B0 .. DEGREE SIGN
+.. |divide| unicode:: U+000F7 .. DIVISION SIGN
+.. |Eacute| unicode:: U+000C9 .. LATIN CAPITAL LETTER E WITH ACUTE
+.. |eacute| unicode:: U+000E9 .. LATIN SMALL LETTER E WITH ACUTE
+.. |Ecirc|  unicode:: U+000CA .. LATIN CAPITAL LETTER E WITH CIRCUMFLEX
+.. |ecirc|  unicode:: U+000EA .. LATIN SMALL LETTER E WITH CIRCUMFLEX
+.. |Egrave| unicode:: U+000C8 .. LATIN CAPITAL LETTER E WITH GRAVE
+.. |egrave| unicode:: U+000E8 .. LATIN SMALL LETTER E WITH GRAVE
+.. |ETH|    unicode:: U+000D0 .. LATIN CAPITAL LETTER ETH
+.. |eth|    unicode:: U+000F0 .. LATIN SMALL LETTER ETH
+.. |Euml|   unicode:: U+000CB .. LATIN CAPITAL LETTER E WITH DIAERESIS
+.. |euml|   unicode:: U+000EB .. LATIN SMALL LETTER E WITH DIAERESIS
+.. |frac12| unicode:: U+000BD .. VULGAR FRACTION ONE HALF
+.. |frac14| unicode:: U+000BC .. VULGAR FRACTION ONE QUARTER
+.. |frac34| unicode:: U+000BE .. VULGAR FRACTION THREE QUARTERS
+.. |Iacute| unicode:: U+000CD .. LATIN CAPITAL LETTER I WITH ACUTE
+.. |iacute| unicode:: U+000ED .. LATIN SMALL LETTER I WITH ACUTE
+.. |Icirc|  unicode:: U+000CE .. LATIN CAPITAL LETTER I WITH CIRCUMFLEX
+.. |icirc|  unicode:: U+000EE .. LATIN SMALL LETTER I WITH CIRCUMFLEX
+.. |iexcl|  unicode:: U+000A1 .. INVERTED EXCLAMATION MARK
+.. |Igrave| unicode:: U+000CC .. LATIN CAPITAL LETTER I WITH GRAVE
+.. |igrave| unicode:: U+000EC .. LATIN SMALL LETTER I WITH GRAVE
+.. |iquest| unicode:: U+000BF .. INVERTED QUESTION MARK
+.. |Iuml|   unicode:: U+000CF .. LATIN CAPITAL LETTER I WITH DIAERESIS
+.. |iuml|   unicode:: U+000EF .. LATIN SMALL LETTER I WITH DIAERESIS
+.. |laquo|  unicode:: U+000AB .. LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+.. |macr|   unicode:: U+000AF .. MACRON
+.. |micro|  unicode:: U+000B5 .. MICRO SIGN
+.. |middot| unicode:: U+000B7 .. MIDDLE DOT
+.. |nbsp|   unicode:: U+000A0 .. NO-BREAK SPACE
+.. |not|    unicode:: U+000AC .. NOT SIGN
+.. |Ntilde| unicode:: U+000D1 .. LATIN CAPITAL LETTER N WITH TILDE
+.. |ntilde| unicode:: U+000F1 .. LATIN SMALL LETTER N WITH TILDE
+.. |Oacute| unicode:: U+000D3 .. LATIN CAPITAL LETTER O WITH ACUTE
+.. |oacute| unicode:: U+000F3 .. LATIN SMALL LETTER O WITH ACUTE
+.. |Ocirc|  unicode:: U+000D4 .. LATIN CAPITAL LETTER O WITH CIRCUMFLEX
+.. |ocirc|  unicode:: U+000F4 .. LATIN SMALL LETTER O WITH CIRCUMFLEX
+.. |Ograve| unicode:: U+000D2 .. LATIN CAPITAL LETTER O WITH GRAVE
+.. |ograve| unicode:: U+000F2 .. LATIN SMALL LETTER O WITH GRAVE
+.. |ordf|   unicode:: U+000AA .. FEMININE ORDINAL INDICATOR
+.. |ordm|   unicode:: U+000BA .. MASCULINE ORDINAL INDICATOR
+.. |Oslash| unicode:: U+000D8 .. LATIN CAPITAL LETTER O WITH STROKE
+.. |oslash| unicode:: U+000F8 .. LATIN SMALL LETTER O WITH STROKE
+.. |Otilde| unicode:: U+000D5 .. LATIN CAPITAL LETTER O WITH TILDE
+.. |otilde| unicode:: U+000F5 .. LATIN SMALL LETTER O WITH TILDE
+.. |Ouml|   unicode:: U+000D6 .. LATIN CAPITAL LETTER O WITH DIAERESIS
+.. |ouml|   unicode:: U+000F6 .. LATIN SMALL LETTER O WITH DIAERESIS
+.. |para|   unicode:: U+000B6 .. PILCROW SIGN
+.. |plusmn| unicode:: U+000B1 .. PLUS-MINUS SIGN
+.. |pound|  unicode:: U+000A3 .. POUND SIGN
+.. |raquo|  unicode:: U+000BB .. RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+.. |reg|    unicode:: U+000AE .. REGISTERED SIGN
+.. |sect|   unicode:: U+000A7 .. SECTION SIGN
+.. |shy|    unicode:: U+000AD .. SOFT HYPHEN
+.. |sup1|   unicode:: U+000B9 .. SUPERSCRIPT ONE
+.. |sup2|   unicode:: U+000B2 .. SUPERSCRIPT TWO
+.. |sup3|   unicode:: U+000B3 .. SUPERSCRIPT THREE
+.. |szlig|  unicode:: U+000DF .. LATIN SMALL LETTER SHARP S
+.. |THORN|  unicode:: U+000DE .. LATIN CAPITAL LETTER THORN
+.. |thorn|  unicode:: U+000FE .. LATIN SMALL LETTER THORN
+.. |times|  unicode:: U+000D7 .. MULTIPLICATION SIGN
+.. |Uacute| unicode:: U+000DA .. LATIN CAPITAL LETTER U WITH ACUTE
+.. |uacute| unicode:: U+000FA .. LATIN SMALL LETTER U WITH ACUTE
+.. |Ucirc|  unicode:: U+000DB .. LATIN CAPITAL LETTER U WITH CIRCUMFLEX
+.. |ucirc|  unicode:: U+000FB .. LATIN SMALL LETTER U WITH CIRCUMFLEX
+.. |Ugrave| unicode:: U+000D9 .. LATIN CAPITAL LETTER U WITH GRAVE
+.. |ugrave| unicode:: U+000F9 .. LATIN SMALL LETTER U WITH GRAVE
+.. |uml|    unicode:: U+000A8 .. DIAERESIS
+.. |Uuml|   unicode:: U+000DC .. LATIN CAPITAL LETTER U WITH DIAERESIS
+.. |uuml|   unicode:: U+000FC .. LATIN SMALL LETTER U WITH DIAERESIS
+.. |Yacute| unicode:: U+000DD .. LATIN CAPITAL LETTER Y WITH ACUTE
+.. |yacute| unicode:: U+000FD .. LATIN SMALL LETTER Y WITH ACUTE
+.. |yen|    unicode:: U+000A5 .. YEN SIGN
+.. |yuml|   unicode:: U+000FF .. LATIN SMALL LETTER Y WITH DIAERESIS
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-special.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-special.txt
new file mode 100644
index 00000000..b19c0b51
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-special.txt
@@ -0,0 +1,37 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |bdquo|  unicode:: U+0201E .. DOUBLE LOW-9 QUOTATION MARK
+.. |circ|   unicode:: U+002C6 .. MODIFIER LETTER CIRCUMFLEX ACCENT
+.. |Dagger| unicode:: U+02021 .. DOUBLE DAGGER
+.. |dagger| unicode:: U+02020 .. DAGGER
+.. |emsp|   unicode:: U+02003 .. EM SPACE
+.. |ensp|   unicode:: U+02002 .. EN SPACE
+.. |euro|   unicode:: U+020AC .. EURO SIGN
+.. |gt|     unicode:: U+0003E .. GREATER-THAN SIGN
+.. |ldquo|  unicode:: U+0201C .. LEFT DOUBLE QUOTATION MARK
+.. |lrm|    unicode:: U+0200E .. LEFT-TO-RIGHT MARK
+.. |lsaquo| unicode:: U+02039 .. SINGLE LEFT-POINTING ANGLE QUOTATION MARK
+.. |lsquo|  unicode:: U+02018 .. LEFT SINGLE QUOTATION MARK
+.. |lt|     unicode:: U+0003C .. LESS-THAN SIGN
+.. |mdash|  unicode:: U+02014 .. EM DASH
+.. |ndash|  unicode:: U+02013 .. EN DASH
+.. |OElig|  unicode:: U+00152 .. LATIN CAPITAL LIGATURE OE
+.. |oelig|  unicode:: U+00153 .. LATIN SMALL LIGATURE OE
+.. |permil| unicode:: U+02030 .. PER MILLE SIGN
+.. |quot|   unicode:: U+00022 .. QUOTATION MARK
+.. |rdquo|  unicode:: U+0201D .. RIGHT DOUBLE QUOTATION MARK
+.. |rlm|    unicode:: U+0200F .. RIGHT-TO-LEFT MARK
+.. |rsaquo| unicode:: U+0203A .. SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
+.. |rsquo|  unicode:: U+02019 .. RIGHT SINGLE QUOTATION MARK
+.. |sbquo|  unicode:: U+0201A .. SINGLE LOW-9 QUOTATION MARK
+.. |Scaron| unicode:: U+00160 .. LATIN CAPITAL LETTER S WITH CARON
+.. |scaron| unicode:: U+00161 .. LATIN SMALL LETTER S WITH CARON
+.. |thinsp| unicode:: U+02009 .. THIN SPACE
+.. |tilde|  unicode:: U+002DC .. SMALL TILDE
+.. |Yuml|   unicode:: U+00178 .. LATIN CAPITAL LETTER Y WITH DIAERESIS
+.. |zwj|    unicode:: U+0200D .. ZERO WIDTH JOINER
+.. |zwnj|   unicode:: U+0200C .. ZERO WIDTH NON-JOINER
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-symbol.txt b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-symbol.txt
new file mode 100644
index 00000000..1f935905
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/include/xhtml1-symbol.txt
@@ -0,0 +1,130 @@
+.. This data file has been placed in the public domain.
+.. Derived from the Unicode character mappings available from
+   <http://www.w3.org/2003/entities/xml/>.
+   Processed by unicode2rstsubs.py, part of Docutils:
+   <https://docutils.sourceforge.io>.
+
+.. |alefsym|  unicode:: U+02135 .. ALEF SYMBOL
+.. |Alpha|    unicode:: U+00391 .. GREEK CAPITAL LETTER ALPHA
+.. |alpha|    unicode:: U+003B1 .. GREEK SMALL LETTER ALPHA
+.. |and|      unicode:: U+02227 .. LOGICAL AND
+.. |ang|      unicode:: U+02220 .. ANGLE
+.. |asymp|    unicode:: U+02248 .. ALMOST EQUAL TO
+.. |Beta|     unicode:: U+00392 .. GREEK CAPITAL LETTER BETA
+.. |beta|     unicode:: U+003B2 .. GREEK SMALL LETTER BETA
+.. |bull|     unicode:: U+02022 .. BULLET
+.. |cap|      unicode:: U+02229 .. INTERSECTION
+.. |Chi|      unicode:: U+003A7 .. GREEK CAPITAL LETTER CHI
+.. |chi|      unicode:: U+003C7 .. GREEK SMALL LETTER CHI
+.. |clubs|    unicode:: U+02663 .. BLACK CLUB SUIT
+.. |cong|     unicode:: U+02245 .. APPROXIMATELY EQUAL TO
+.. |crarr|    unicode:: U+021B5 .. DOWNWARDS ARROW WITH CORNER LEFTWARDS
+.. |cup|      unicode:: U+0222A .. UNION
+.. |dArr|     unicode:: U+021D3 .. DOWNWARDS DOUBLE ARROW
+.. |darr|     unicode:: U+02193 .. DOWNWARDS ARROW
+.. |Delta|    unicode:: U+00394 .. GREEK CAPITAL LETTER DELTA
+.. |delta|    unicode:: U+003B4 .. GREEK SMALL LETTER DELTA
+.. |diams|    unicode:: U+02666 .. BLACK DIAMOND SUIT
+.. |empty|    unicode:: U+02205 .. EMPTY SET
+.. |Epsilon|  unicode:: U+00395 .. GREEK CAPITAL LETTER EPSILON
+.. |epsilon|  unicode:: U+003B5 .. GREEK SMALL LETTER EPSILON
+.. |equiv|    unicode:: U+02261 .. IDENTICAL TO
+.. |Eta|      unicode:: U+00397 .. GREEK CAPITAL LETTER ETA
+.. |eta|      unicode:: U+003B7 .. GREEK SMALL LETTER ETA
+.. |exist|    unicode:: U+02203 .. THERE EXISTS
+.. |fnof|     unicode:: U+00192 .. LATIN SMALL LETTER F WITH HOOK
+.. |forall|   unicode:: U+02200 .. FOR ALL
+.. |frasl|    unicode:: U+02044 .. FRACTION SLASH
+.. |Gamma|    unicode:: U+00393 .. GREEK CAPITAL LETTER GAMMA
+.. |gamma|    unicode:: U+003B3 .. GREEK SMALL LETTER GAMMA
+.. |ge|       unicode:: U+02265 .. GREATER-THAN OR EQUAL TO
+.. |hArr|     unicode:: U+021D4 .. LEFT RIGHT DOUBLE ARROW
+.. |harr|     unicode:: U+02194 .. LEFT RIGHT ARROW
+.. |hearts|   unicode:: U+02665 .. BLACK HEART SUIT
+.. |hellip|   unicode:: U+02026 .. HORIZONTAL ELLIPSIS
+.. |image|    unicode:: U+02111 .. BLACK-LETTER CAPITAL I
+.. |infin|    unicode:: U+0221E .. INFINITY
+.. |int|      unicode:: U+0222B .. INTEGRAL
+.. |Iota|     unicode:: U+00399 .. GREEK CAPITAL LETTER IOTA
+.. |iota|     unicode:: U+003B9 .. GREEK SMALL LETTER IOTA
+.. |isin|     unicode:: U+02208 .. ELEMENT OF
+.. |Kappa|    unicode:: U+0039A .. GREEK CAPITAL LETTER KAPPA
+.. |kappa|    unicode:: U+003BA .. GREEK SMALL LETTER KAPPA
+.. |Lambda|   unicode:: U+0039B .. GREEK CAPITAL LETTER LAMDA
+.. |lambda|   unicode:: U+003BB .. GREEK SMALL LETTER LAMDA
+.. |lang|     unicode:: U+02329 .. LEFT-POINTING ANGLE BRACKET
+.. |lArr|     unicode:: U+021D0 .. LEFTWARDS DOUBLE ARROW
+.. |larr|     unicode:: U+02190 .. LEFTWARDS ARROW
+.. |lceil|    unicode:: U+02308 .. LEFT CEILING
+.. |le|       unicode:: U+02264 .. LESS-THAN OR EQUAL TO
+.. |lfloor|   unicode:: U+0230A .. LEFT FLOOR
+.. |lowast|   unicode:: U+02217 .. ASTERISK OPERATOR
+.. |loz|      unicode:: U+025CA .. LOZENGE
+.. |minus|    unicode:: U+02212 .. MINUS SIGN
+.. |Mu|       unicode:: U+0039C .. GREEK CAPITAL LETTER MU
+.. |mu|       unicode:: U+003BC .. GREEK SMALL LETTER MU
+.. |nabla|    unicode:: U+02207 .. NABLA
+.. |ne|       unicode:: U+02260 .. NOT EQUAL TO
+.. |ni|       unicode:: U+0220B .. CONTAINS AS MEMBER
+.. |notin|    unicode:: U+02209 .. NOT AN ELEMENT OF
+.. |nsub|     unicode:: U+02284 .. NOT A SUBSET OF
+.. |Nu|       unicode:: U+0039D .. GREEK CAPITAL LETTER NU
+.. |nu|       unicode:: U+003BD .. GREEK SMALL LETTER NU
+.. |oline|    unicode:: U+0203E .. OVERLINE
+.. |Omega|    unicode:: U+003A9 .. GREEK CAPITAL LETTER OMEGA
+.. |omega|    unicode:: U+003C9 .. GREEK SMALL LETTER OMEGA
+.. |Omicron|  unicode:: U+0039F .. GREEK CAPITAL LETTER OMICRON
+.. |omicron|  unicode:: U+003BF .. GREEK SMALL LETTER OMICRON
+.. |oplus|    unicode:: U+02295 .. CIRCLED PLUS
+.. |or|       unicode:: U+02228 .. LOGICAL OR
+.. |otimes|   unicode:: U+02297 .. CIRCLED TIMES
+.. |part|     unicode:: U+02202 .. PARTIAL DIFFERENTIAL
+.. |perp|     unicode:: U+022A5 .. UP TACK
+.. |Phi|      unicode:: U+003A6 .. GREEK CAPITAL LETTER PHI
+.. |phi|      unicode:: U+003D5 .. GREEK PHI SYMBOL
+.. |Pi|       unicode:: U+003A0 .. GREEK CAPITAL LETTER PI
+.. |pi|       unicode:: U+003C0 .. GREEK SMALL LETTER PI
+.. |piv|      unicode:: U+003D6 .. GREEK PI SYMBOL
+.. |Prime|    unicode:: U+02033 .. DOUBLE PRIME
+.. |prime|    unicode:: U+02032 .. PRIME
+.. |prod|     unicode:: U+0220F .. N-ARY PRODUCT
+.. |prop|     unicode:: U+0221D .. PROPORTIONAL TO
+.. |Psi|      unicode:: U+003A8 .. GREEK CAPITAL LETTER PSI
+.. |psi|      unicode:: U+003C8 .. GREEK SMALL LETTER PSI
+.. |radic|    unicode:: U+0221A .. SQUARE ROOT
+.. |rang|     unicode:: U+0232A .. RIGHT-POINTING ANGLE BRACKET
+.. |rArr|     unicode:: U+021D2 .. RIGHTWARDS DOUBLE ARROW
+.. |rarr|     unicode:: U+02192 .. RIGHTWARDS ARROW
+.. |rceil|    unicode:: U+02309 .. RIGHT CEILING
+.. |real|     unicode:: U+0211C .. BLACK-LETTER CAPITAL R
+.. |rfloor|   unicode:: U+0230B .. RIGHT FLOOR
+.. |Rho|      unicode:: U+003A1 .. GREEK CAPITAL LETTER RHO
+.. |rho|      unicode:: U+003C1 .. GREEK SMALL LETTER RHO
+.. |sdot|     unicode:: U+022C5 .. DOT OPERATOR
+.. |Sigma|    unicode:: U+003A3 .. GREEK CAPITAL LETTER SIGMA
+.. |sigma|    unicode:: U+003C3 .. GREEK SMALL LETTER SIGMA
+.. |sigmaf|   unicode:: U+003C2 .. GREEK SMALL LETTER FINAL SIGMA
+.. |sim|      unicode:: U+0223C .. TILDE OPERATOR
+.. |spades|   unicode:: U+02660 .. BLACK SPADE SUIT
+.. |sub|      unicode:: U+02282 .. SUBSET OF
+.. |sube|     unicode:: U+02286 .. SUBSET OF OR EQUAL TO
+.. |sum|      unicode:: U+02211 .. N-ARY SUMMATION
+.. |sup|      unicode:: U+02283 .. SUPERSET OF
+.. |supe|     unicode:: U+02287 .. SUPERSET OF OR EQUAL TO
+.. |Tau|      unicode:: U+003A4 .. GREEK CAPITAL LETTER TAU
+.. |tau|      unicode:: U+003C4 .. GREEK SMALL LETTER TAU
+.. |there4|   unicode:: U+02234 .. THEREFORE
+.. |Theta|    unicode:: U+00398 .. GREEK CAPITAL LETTER THETA
+.. |theta|    unicode:: U+003B8 .. GREEK SMALL LETTER THETA
+.. |thetasym| unicode:: U+003D1 .. GREEK THETA SYMBOL
+.. |trade|    unicode:: U+02122 .. TRADE MARK SIGN
+.. |uArr|     unicode:: U+021D1 .. UPWARDS DOUBLE ARROW
+.. |uarr|     unicode:: U+02191 .. UPWARDS ARROW
+.. |upsih|    unicode:: U+003D2 .. GREEK UPSILON WITH HOOK SYMBOL
+.. |Upsilon|  unicode:: U+003A5 .. GREEK CAPITAL LETTER UPSILON
+.. |upsilon|  unicode:: U+003C5 .. GREEK SMALL LETTER UPSILON
+.. |weierp|   unicode:: U+02118 .. SCRIPT CAPITAL P
+.. |Xi|       unicode:: U+0039E .. GREEK CAPITAL LETTER XI
+.. |xi|       unicode:: U+003BE .. GREEK SMALL LETTER XI
+.. |Zeta|     unicode:: U+00396 .. GREEK CAPITAL LETTER ZETA
+.. |zeta|     unicode:: U+003B6 .. GREEK SMALL LETTER ZETA
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/__init__.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/__init__.py
new file mode 100644
index 00000000..a8bfd231
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/__init__.py
@@ -0,0 +1,40 @@
+# $Id: __init__.py 9026 2022-03-04 15:57:13Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+# Internationalization details are documented in
+# <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+
+"""
+This package contains modules for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+from docutils.languages import LanguageImporter
+
+
+class RstLanguageImporter(LanguageImporter):
+    """Import language modules.
+
+    When called with a BCP 47 language tag, instances return a module
+    with localisations for "directive" and "role" names for  from
+    `docutils.parsers.rst.languages` or the PYTHONPATH.
+
+    If there is no matching module, warn (if a `reporter` is passed)
+    and return None.
+    """
+    packages = ('docutils.parsers.rst.languages.', '')
+    warn_msg = 'rST localisation for language "%s" not found.'
+    fallback = None
+
+    def check_content(self, module):
+        """Check if we got an rST language module."""
+        if not (isinstance(module.directives, dict)
+                and isinstance(module.roles, dict)):
+            raise ImportError
+
+
+get_language = RstLanguageImporter()
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/af.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/af.py
new file mode 100644
index 00000000..31cb4ebf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/af.py
@@ -0,0 +1,108 @@
+# $Id: af.py 9417 2023-06-27 20:04:54Z milde $
+# Author: Jannie Hofmeyr <jhsh@sun.ac.za>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Afrikaans-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      'aandag': 'attention',
+      'versigtig': 'caution',
+      'code (translation required)': 'code',
+      'gevaar': 'danger',
+      'fout': 'error',
+      'wenk': 'hint',
+      'belangrik': 'important',
+      'nota': 'note',
+      'tip': 'tip',  # hint and tip both have the same translation: wenk
+      'waarskuwing': 'warning',
+      'advies': 'admonition',
+      'vermaning': 'admonition',  # sic! kept for backwards compatibiltity
+      'kantstreep': 'sidebar',
+      'onderwerp': 'topic',
+      'lynblok': 'line-block',
+      'math (translation required)': 'math',
+      'parsed-literal (translation required)': 'parsed-literal',
+      'rubriek': 'rubric',
+      'epigraaf': 'epigraph',
+      'hoogtepunte': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'vrae': 'questions',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'table (translation required)': 'table',
+      'csv-table (translation required)': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      'meta': 'meta',
+      # 'beeldkaart': 'imagemap',
+      'beeld': 'image',
+      'figuur': 'figure',
+      'insluiting': 'include',
+      'rou': 'raw',
+      'vervang': 'replace',
+      'unicode': 'unicode',  # should this be translated? unikode
+      'datum': 'date',
+      'klas': 'class',
+      'role (translation required)': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'inhoud': 'contents',
+      'sectnum': 'sectnum',
+      'section-numbering': 'sectnum',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'voetnote': 'footnotes',
+      # 'aanhalings': 'citations',
+      'teikennotas': 'target-notes',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Afrikaans name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    'afkorting': 'abbreviation',
+    'ab': 'abbreviation',
+    'akroniem': 'acronym',
+    'ac': 'acronym',
+    'code (translation required)': 'code',
+    'indeks': 'index',
+    'i': 'index',
+    'voetskrif': 'subscript',
+    'sub': 'subscript',
+    'boskrif': 'superscript',
+    'sup': 'superscript',
+    'titelverwysing': 'title-reference',
+    'titel': 'title-reference',
+    't': 'title-reference',
+    'pep-verwysing': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-verwysing': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'nadruk': 'emphasis',
+    'sterk': 'strong',
+    'literal (translation required)': 'literal',
+    'math (translation required)': 'math',
+    'benoemde verwysing': 'named-reference',
+    'anonieme verwysing': 'anonymous-reference',
+    'voetnootverwysing': 'footnote-reference',
+    'aanhalingverwysing': 'citation-reference',
+    'vervangingsverwysing': 'substitution-reference',
+    'teiken': 'target',
+    'uri-verwysing': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'rou': 'raw',
+    }
+"""Mapping of Afrikaans role names to canonical names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ar.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ar.py
new file mode 100644
index 00000000..71be92a5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ar.py
@@ -0,0 +1,99 @@
+# $Id: fa.py 4564 2016-08-10 11:48:42Z
+# Author: Shahin <me@5hah.in>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Arabic-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+directives = {
+    # language-dependent: fixed
+    'تنبيه': 'attention',
+    'احتیاط': 'caution',
+    'كود': 'code',
+    'خطر': 'danger',
+    'خطأ': 'error',
+    'تلميح': 'hint',
+    'مهم': 'important',
+    'ملاحظة': 'note',
+    'نصيحة': 'tip',
+    'تحذير': 'warning',
+    'تذكير': 'admonition',
+    'شريط-جانبي': 'sidebar',
+    'موضوع': 'topic',
+    'قالب-سطري': 'line-block',
+    'لفظ-حرفي': 'parsed-literal',
+    'معيار': 'rubric',
+    'فكرة-الكتاب': 'epigraph',
+    'تمييز': 'highlights',
+    'نقل-قول': 'pull-quote',
+    'ترکیب': 'compound',
+    'وعاء': 'container',
+    # 'questions': 'questions',
+    'جدول': 'table',
+    'جدول-csv': 'csv-table',
+    'جدول-قوائم': 'list-table',
+    # 'qa': 'questions',
+    # 'faq': 'questions',
+    'ميتا': 'meta',
+    'رياضيات': 'math',
+    # 'imagemap': 'imagemap',
+    'صورة': 'image',
+    'رسم-توضيحي': 'figure',
+    'تضمين': 'include',
+    'خام': 'raw',
+    'تبديل': 'replace',
+    'یونیکد': 'unicode',
+    'تاریخ': 'date',
+    'كائن': 'class',
+    'قانون': 'role',
+    'قانون-افتراضي': 'default-role',
+    'عنوان': 'title',
+    'المحتوى': 'contents',
+    'رقم-الفصل': 'sectnum',
+    'رقم-القسم': 'sectnum',
+    'رأس-الصفحة': 'header',
+    'هامش': 'footer',
+    # 'footnotes': 'footnotes',
+    # 'citations': 'citations',
+    '': 'target-notes',
+}
+"""Arabic name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'اختصار': 'abbreviation',
+    'اختزال': 'acronym',
+    'كود': 'code',
+    'فهرس': 'index',
+    'خفض': 'subscript',
+    'رفع': 'superscript',
+    'عنوان-مرجع': 'title-reference',
+    'مرجع-pep': 'pep-reference',
+    'rfc-مرجع': 'rfc-reference',
+    'تأكيد': 'emphasis',
+    'عريض': 'strong',
+    'لفظی': 'literal',
+    'رياضيات': 'math',
+    'مرجع-مسمى': 'named-reference',
+    'مرجع-مجهول': 'anonymous-reference',
+    'مرجع-هامشي': 'footnote-reference',
+    'مرجع-منقول': 'citation-reference',
+    'مرجع-معوض': 'substitution-reference',
+    'هدف': 'target',
+    'منبع-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'خام': 'raw',
+}
+"""Mapping of Arabic role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ca.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ca.py
new file mode 100644
index 00000000..8c8eae40
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ca.py
@@ -0,0 +1,130 @@
+# $Id: ca.py 9457 2023-10-02 16:25:50Z milde $
+# Authors: Ivan Vilata i Balaguer <ivan@selidor.net>;
+#          Antoni Bella Pérez <antonibella5@yahoo.com>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation,
+# please read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+# These translations can be used without changes for
+# Valencian variant of Catalan (use language tag "ca-valencia").
+# Checked by a native speaker of Valentian.
+
+"""
+Catalan-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'atenció': 'attention',
+      'compte': 'caution',
+      'perill': 'danger',
+      'error': 'error',
+      'suggeriment': 'hint',
+      'important': 'important',
+      'nota': 'note',
+      'consell': 'tip',
+      'avís': 'warning',
+      'advertiment': 'admonition',
+      'nota-al-marge': 'sidebar',
+      'nota-marge': 'sidebar',
+      'tema': 'topic',
+      'bloc-de-línies': 'line-block',
+      'bloc-línies': 'line-block',
+      'literal-analitzat': 'parsed-literal',
+      'codi': 'code',
+      'bloc-de-codi': 'code',
+      'matemàtiques': 'math',
+      'rúbrica': 'rubric',
+      'epígraf': 'epigraph',
+      'sumari': 'highlights',
+      'cita-destacada': 'pull-quote',
+      'compost': 'compound',
+      'contenidor': 'container',
+      'taula': 'table',
+      'taula-csv': 'csv-table',
+      'taula-llista': 'list-table',
+      'meta': 'meta',
+      # 'imagemap': 'imagemap',
+      'imatge': 'image',
+      'figura': 'figure',
+      'inclou': 'include',
+      'incloure': 'include',
+      'cru': 'raw',
+      'reemplaça': 'replace',
+      'reemplaçar': 'replace',
+      'unicode': 'unicode',
+      'data': 'date',
+      'classe': 'class',
+      'rol': 'role',
+      'rol-predeterminat': 'default-role',
+      'títol': 'title',
+      'contingut': 'contents',
+      'numsec': 'sectnum',
+      'numeració-de-seccions': 'sectnum',
+      'numeració-seccions': 'sectnum',
+      'capçalera': 'header',
+      'peu-de-pàgina': 'footer',
+      'peu-pàgina': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'notes-amb-destinacions': 'target-notes',
+      'notes-destinacions': 'target-notes',
+      'directiva-de-prova-de-restructuredtext': 'restructuredtext-test-directive'}  # noqa:E501
+"""Catalan name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'abreviatura': 'abbreviation',
+    'abreviació': 'abbreviation',
+    'abrev': 'abbreviation',
+    'ab': 'abbreviation',
+    'acrònim': 'acronym',
+    'ac': 'acronym',
+    'codi': 'code',
+    'èmfasi': 'emphasis',
+    'literal': 'literal',
+    'matemàtiques': 'math',
+    'referència-a-pep': 'pep-reference',
+    'referència-pep': 'pep-reference',
+    'pep': 'pep-reference',
+    'referència-a-rfc': 'rfc-reference',
+    'referència-rfc': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'destacat': 'strong',
+    'subíndex': 'subscript',
+    'sub': 'subscript',
+    'superíndex': 'superscript',
+    'sup': 'superscript',
+    'referència-a-títol': 'title-reference',
+    'referència-títol': 'title-reference',
+    'títol': 'title-reference',
+    't': 'title-reference',
+    'cru': 'raw',
+    # the following roles are not implemented in Docutils
+    'índex': 'index',
+    'i': 'index',
+    'referència-anònima': 'anonymous-reference',
+    'referència-a-cita': 'citation-reference',
+    'referència-cita': 'citation-reference',
+    'referència-a-nota-al-peu': 'footnote-reference',
+    'referència-nota-al-peu': 'footnote-reference',
+    'referència-amb-nom': 'named-reference',
+    'referència-nom': 'named-reference',
+    'referència-a-substitució': 'substitution-reference',
+    'referència-substitució': 'substitution-reference',
+    'referència-a-uri': 'uri-reference',
+    'referència-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'destinació': 'target',
+    }
+"""Mapping of Catalan role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/cs.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/cs.py
new file mode 100644
index 00000000..70274d28
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/cs.py
@@ -0,0 +1,110 @@
+# $Id: cs.py 9452 2023-09-27 00:11:54Z milde $
+# Author: Marek Blaha <mb@dat.cz>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Czech-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'pozor': 'attention',
+      # jak rozlisit caution a warning?
+      'caution (translation required)': 'caution',
+      'code (translation required)': 'code',
+      'nebezpečí': 'danger',
+      'chyba': 'error',
+      'rada': 'hint',
+      'důležité': 'important',
+      'poznámka': 'note',
+      'tip (translation required)': 'tip',
+      'varování': 'warning',
+      'admonition (translation required)': 'admonition',
+      'sidebar (translation required)': 'sidebar',
+      'téma': 'topic',
+      'line-block (translation required)': 'line-block',
+      'parsed-literal (translation required)': 'parsed-literal',
+      'oddíl': 'rubric',
+      'moto': 'epigraph',
+      'highlights (translation required)': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'questions': 'questions',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'table (translation required)': 'table',
+      'csv-table (translation required)': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      'math (translation required)': 'math',
+      'meta (translation required)': 'meta',
+      # 'imagemap': 'imagemap',
+      'image (translation required)': 'image',    # obrazek
+      'figure (translation required)': 'figure',  # a tady?
+      'include (translation required)': 'include',
+      'raw (translation required)': 'raw',
+      'replace (translation required)': 'replace',
+      'unicode (translation required)': 'unicode',
+      'datum': 'date',
+      'třída': 'class',
+      'role (translation required)': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'obsah': 'contents',
+      'sectnum (translation required)': 'sectnum',
+      'section-numbering (translation required)': 'sectnum',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'target-notes (translation required)': 'target-notes',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Czech name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'abbreviation (translation required)': 'abbreviation',
+    'ab (translation required)': 'abbreviation',
+    'acronym (translation required)': 'acronym',
+    'ac (translation required)': 'acronym',
+    'code (translation required)': 'code',
+    'index (translation required)': 'index',
+    'i (translation required)': 'index',
+    'subscript (translation required)': 'subscript',
+    'sub (translation required)': 'subscript',
+    'superscript (translation required)': 'superscript',
+    'sup (translation required)': 'superscript',
+    'title-reference (translation required)': 'title-reference',
+    'title (translation required)': 'title-reference',
+    't (translation required)': 'title-reference',
+    'pep-reference (translation required)': 'pep-reference',
+    'pep (translation required)': 'pep-reference',
+    'rfc-reference (translation required)': 'rfc-reference',
+    'rfc (translation required)': 'rfc-reference',
+    'emphasis (translation required)': 'emphasis',
+    'strong (translation required)': 'strong',
+    'literal (translation required)': 'literal',
+    'math (translation required)': 'math',
+    'named-reference (translation required)': 'named-reference',
+    'anonymous-reference (translation required)': 'anonymous-reference',
+    'footnote-reference (translation required)': 'footnote-reference',
+    'citation-reference (translation required)': 'citation-reference',
+    'substitution-reference (translation required)': 'substitution-reference',
+    'target (translation required)': 'target',
+    'uri-reference (translation required)': 'uri-reference',
+    'uri (translation required)': 'uri-reference',
+    'url (translation required)': 'uri-reference',
+    'raw (translation required)': 'raw',
+    }
+"""Mapping of Czech role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/da.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/da.py
new file mode 100644
index 00000000..31a250e1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/da.py
@@ -0,0 +1,114 @@
+# $Id: da.py 9417 2023-06-27 20:04:54Z milde $
+# Author: E D
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Danish-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'giv agt': 'attention',
+      'pas på': 'caution',
+      'kode': 'code',
+      'kode-blok': 'code',
+      'kildekode': 'code',
+      'fare': 'danger',
+      'fejl': 'error',
+      'vink': 'hint',
+      'vigtigt': 'important',
+      'bemærk': 'note',
+      'tips': 'tip',
+      'advarsel': 'warning',
+      'varsel': 'admonition',
+      'formaning': 'admonition',  # sic! kept for backwards compatibiltity
+      'sidebjælke': 'sidebar',
+      'emne': 'topic',
+      'linje-blok': 'line-block',
+      'linie-blok': 'line-block',
+      'parset-literal': 'parsed-literal',
+      'rubrik': 'rubric',
+      'epigraf': 'epigraph',
+      'fremhævninger': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'questions': 'questions',
+      'tabel': 'table',
+      'csv-tabel': 'csv-table',
+      'liste-tabel': 'list-table',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap': 'imagemap',
+      'billede': 'image',
+      'figur': 'figure',
+      'inkludér': 'include',
+      'inkluder': 'include',
+      'rå': 'raw',
+      'erstat': 'replace',
+      'unicode': 'unicode',
+      'dato': 'date',
+      'klasse': 'class',
+      'rolle': 'role',
+      'forvalgt-rolle': 'default-role',
+      'titel': 'title',
+      'indhold': 'contents',
+      'sektnum': 'sectnum',
+      'sektions-nummerering': 'sectnum',
+      'sidehovede': 'header',
+      'sidefod': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'target-notes (translation required)': 'target-notes',
+      'restructuredtext-test-direktiv': 'restructuredtext-test-directive'}
+"""Danish name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'forkortelse': 'abbreviation',
+    'fork': 'abbreviation',
+    'akronym': 'acronym',
+    'ac (translation required)': 'acronym',
+    'kode': 'code',
+    'indeks': 'index',
+    'i': 'index',
+    'subscript (translation required)': 'subscript',
+    'sub (translation required)': 'subscript',
+    'superscript (translation required)': 'superscript',
+    'sup (translation required)': 'superscript',
+    'titel-reference': 'title-reference',
+    'titel': 'title-reference',
+    't': 'title-reference',
+    'pep-reference': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-reference': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'emfase': 'emphasis',
+    'kraftig': 'strong',
+    'literal': 'literal',
+    'math (translation required)': 'math',
+    'navngivet-reference': 'named-reference',
+    'anonym-reference': 'anonymous-reference',
+    'fodnote-reference': 'footnote-reference',
+    'citation-reference (translation required)': 'citation-reference',
+    'substitutions-reference': 'substitution-reference',
+    'target (translation required)': 'target',
+    'uri-reference': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'rå': 'raw',
+    }
+"""Mapping of Danish role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/de.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/de.py
new file mode 100644
index 00000000..4b7ef8e0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/de.py
@@ -0,0 +1,107 @@
+# $Id: de.py 9428 2023-07-07 06:50:26Z milde $
+# Authors: Engelbert Gruber <grubert@users.sourceforge.net>;
+#          Lea Wiemann <LeWiemann@gmail.com>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+German-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      'warnhinweis': 'admonition',  # or, more generally, 'anmerkung'?
+      'ermahnung': 'admonition',  # sic! kept for backwards compatibiltity
+      'achtung': 'attention',
+      'vorsicht': 'caution',
+      'code': 'code',
+      'gefahr': 'danger',
+      'fehler': 'error',
+      'hinweis': 'hint',  # Wink
+      'wichtig': 'important',
+      'notiz': 'note',
+      'tipp': 'tip',
+      'warnung': 'warning',
+      'kasten': 'sidebar',
+      'seitenkasten': 'sidebar',  # kept for backwards compatibiltity
+      'seitenleiste': 'sidebar',
+      'thema': 'topic',
+      'zeilenblock': 'line-block',
+      'parsed-literal (translation required)': 'parsed-literal',
+      'rubrik': 'rubric',
+      'epigraph': 'epigraph',
+      'highlights': 'highlights',
+      'pull-quote': 'pull-quote',  # commonly used in German too
+      'seitenansprache': 'pull-quote',
+      # cf. http://www.typografie.info/2/wiki.php?title=Seitenansprache
+      'zusammengesetzt': 'compound',
+      'verbund': 'compound',
+      'container': 'container',
+      # 'fragen': 'questions',
+      'tabelle': 'table',
+      'csv-tabelle': 'csv-table',
+      'listentabelle': 'list-table',
+      'mathe': 'math',
+      'formel': 'math',
+      'meta': 'meta',
+      # 'imagemap': 'imagemap',
+      'bild': 'image',
+      'abbildung': 'figure',
+      'unverändert': 'raw',
+      'roh': 'raw',
+      'einfügen': 'include',
+      'ersetzung': 'replace',
+      'ersetzen': 'replace',
+      'ersetze': 'replace',
+      'unicode': 'unicode',
+      'datum': 'date',
+      'klasse': 'class',
+      'rolle': 'role',
+      'standardrolle': 'default-role',
+      'titel': 'title',
+      'inhalt': 'contents',
+      'kapitelnummerierung': 'sectnum',
+      'abschnittsnummerierung': 'sectnum',
+      'linkziel-fußnoten': 'target-notes',
+      'kopfzeilen': 'header',
+      'fußzeilen': 'footer',
+      # 'fußnoten': 'footnotes',
+      # 'zitate': 'citations',
+      }
+"""German name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+      'abkürzung': 'abbreviation',
+      'akronym': 'acronym',
+      'code': 'code',
+      'index': 'index',
+      'tiefgestellt': 'subscript',
+      'hochgestellt': 'superscript',
+      'titel-referenz': 'title-reference',
+      'pep-referenz': 'pep-reference',
+      'rfc-referenz': 'rfc-reference',
+      'betonung': 'emphasis',  # for backwards compatibility
+      'betont': 'emphasis',
+      'fett': 'strong',
+      'wörtlich': 'literal',
+      'mathe': 'math',
+      'benannte-referenz': 'named-reference',
+      'unbenannte-referenz': 'anonymous-reference',
+      'fußnoten-referenz': 'footnote-reference',
+      'zitat-referenz': 'citation-reference',
+      'ersetzungs-referenz': 'substitution-reference',
+      'ziel': 'target',
+      'uri-referenz': 'uri-reference',
+      'unverändert': 'raw',
+      'roh': 'raw',
+      }
+"""Mapping of German role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/en.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/en.py
new file mode 100644
index 00000000..7b9319e6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/en.py
@@ -0,0 +1,114 @@
+# $Id: en.py 9417 2023-06-27 20:04:54Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+English-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'attention': 'attention',
+      'caution': 'caution',
+      'danger': 'danger',
+      'error': 'error',
+      'hint': 'hint',
+      'important': 'important',
+      'note': 'note',
+      'tip': 'tip',
+      'warning': 'warning',
+      'admonition': 'admonition',  # advice/advisory/remark, not reprimand
+      'sidebar': 'sidebar',
+      'topic': 'topic',
+      'line-block': 'line-block',
+      'parsed-literal': 'parsed-literal',
+      'code': 'code',
+      'code-block': 'code',
+      'sourcecode': 'code',
+      'math': 'math',
+      'rubric': 'rubric',
+      'epigraph': 'epigraph',
+      'highlights': 'highlights',
+      'pull-quote': 'pull-quote',
+      'compound': 'compound',
+      'container': 'container',
+      'table': 'table',
+      'csv-table': 'csv-table',
+      'list-table': 'list-table',
+      'meta': 'meta',
+      # 'imagemap': 'imagemap',
+      'image': 'image',
+      'figure': 'figure',
+      'include': 'include',
+      'raw': 'raw',
+      'replace': 'replace',
+      'unicode': 'unicode',
+      'date': 'date',
+      'class': 'class',
+      'role': 'role',
+      'default-role': 'default-role',
+      'title': 'title',
+      'contents': 'contents',
+      'sectnum': 'sectnum',
+      'section-numbering': 'sectnum',
+      'header': 'header',
+      'footer': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'target-notes': 'target-notes',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Mapping of English directive name to registered directive names
+
+Cf. https://docutils.sourceforge.io/docs/ref/rst/directives.html
+and `_directive_registry` in ``directives/__init__.py``.
+"""
+
+roles = {
+    # language-dependent: fixed
+    'abbreviation': 'abbreviation',
+    'ab': 'abbreviation',
+    'acronym': 'acronym',
+    'ac': 'acronym',
+    'code': 'code',
+    'emphasis': 'emphasis',
+    'literal': 'literal',
+    'math': 'math',
+    'pep-reference': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-reference': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'strong': 'strong',
+    'subscript': 'subscript',
+    'sub': 'subscript',
+    'superscript': 'superscript',
+    'sup': 'superscript',
+    'title-reference': 'title-reference',
+    'title': 'title-reference',
+    't': 'title-reference',
+    'raw': 'raw',
+    # the following roles are not implemented in Docutils
+    'index': 'index',
+    'i': 'index',
+    'anonymous-reference': 'anonymous-reference',
+    'citation-reference': 'citation-reference',
+    'footnote-reference': 'footnote-reference',
+    'named-reference': 'named-reference',
+    'substitution-reference': 'substitution-reference',
+    'uri-reference': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'target': 'target',
+    }
+"""Mapping of English role names to canonical role names for interpreted text.
+
+Cf. https://docutils.sourceforge.io/docs/ref/rst/roles.html
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/eo.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/eo.py
new file mode 100644
index 00000000..1db6694f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/eo.py
@@ -0,0 +1,119 @@
+# $Id: eo.py 9452 2023-09-27 00:11:54Z milde $
+# Author: Marcelo Huerta San Martin <richieadler@users.sourceforge.net>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Esperanto-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+    # language-dependent: fixed
+    'atentu': 'attention',
+    'zorgu': 'caution',
+    'code (translation required)': 'code',
+    'dangxero': 'danger',
+    'danĝero': 'danger',
+    'eraro': 'error',
+    'spuro': 'hint',
+    'grava': 'important',
+    'noto': 'note',
+    'helpeto': 'tip',
+    'averto': 'warning',
+    'sciigo': 'admonition',
+    'admono': 'admonition',  # sic! kept for backwards compatibiltity
+    'flankteksto': 'sidebar',
+    'temo': 'topic',
+    'linea-bloko': 'line-block',
+    'analizota-literalo': 'parsed-literal',
+    'rubriko': 'rubric',
+    'epigrafo': 'epigraph',
+    'elstarajxoj': 'highlights',
+    'elstaraĵoj': 'highlights',
+    'ekstera-citajxo': 'pull-quote',
+    'ekstera-citaĵo': 'pull-quote',
+    'kombinajxo': 'compound',
+    'kombinaĵo': 'compound',
+    'tekstingo': 'container',
+    'enhavilo': 'container',
+    # 'questions': 'questions',
+    # 'qa': 'questions',
+    # 'faq': 'questions',
+    'tabelo': 'table',
+    'tabelo-vdk': 'csv-table',  # "valoroj disigitaj per komoj"
+    'tabelo-csv': 'csv-table',
+    'tabelo-lista': 'list-table',
+    'meta': 'meta',
+    'math (translation required)': 'math',
+    # 'imagemap': 'imagemap',
+    'bildo': 'image',
+    'figuro': 'figure',
+    'inkludi': 'include',
+    'senanaliza': 'raw',
+    'anstatauxi': 'replace',
+    'anstataŭi': 'replace',
+    'unicode': 'unicode',
+    'dato': 'date',
+    'klaso': 'class',
+    'rolo': 'role',
+    'preterlasita-rolo': 'default-role',
+    'titolo': 'title',
+    'enhavo': 'contents',
+    'seknum': 'sectnum',
+    'sekcia-numerado': 'sectnum',
+    'kapsekcio': 'header',
+    'piedsekcio': 'footer',
+    # 'footnotes': 'footnotes',
+    # 'citations': 'citations',
+    'celaj-notoj': 'target-notes',
+    'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Esperanto name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'mallongigo': 'abbreviation',
+    'mall': 'abbreviation',
+    'komenclitero': 'acronym',
+    'kl': 'acronym',
+    'code (translation required)': 'code',
+    'indekso': 'index',
+    'i': 'index',
+    'subskribo': 'subscript',
+    'sub': 'subscript',
+    'supraskribo': 'superscript',
+    'sup': 'superscript',
+    'titola-referenco': 'title-reference',
+    'titolo': 'title-reference',
+    't': 'title-reference',
+    'pep-referenco': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-referenco': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'emfazo': 'emphasis',
+    'forta': 'strong',
+    'litera': 'literal',
+    'math (translation required)': 'math',
+    'nomita-referenco': 'named-reference',
+    'nenomita-referenco': 'anonymous-reference',
+    'piednota-referenco': 'footnote-reference',
+    'citajxo-referenco': 'citation-reference',
+    'citaĵo-referenco': 'citation-reference',
+    'anstatauxa-referenco': 'substitution-reference',
+    'anstataŭa-referenco': 'substitution-reference',
+    'celo': 'target',
+    'uri-referenco': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'senanaliza': 'raw',
+}
+"""Mapping of Esperanto role names to canonical names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/es.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/es.py
new file mode 100644
index 00000000..b7dda6c9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/es.py
@@ -0,0 +1,123 @@
+# $Id: es.py 9452 2023-09-27 00:11:54Z milde $
+# Author: Marcelo Huerta San Martín <richieadler@users.sourceforge.net>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Spanish-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+directives = {
+    'atención': 'attention',
+    'atencion': 'attention',
+    'precaución': 'caution',
+    'code (translation required)': 'code',
+    'precaucion': 'caution',
+    'peligro': 'danger',
+    'error': 'error',
+    'sugerencia': 'hint',
+    'importante': 'important',
+    'nota': 'note',
+    'consejo': 'tip',
+    'advertencia': 'warning',
+    'aviso': 'admonition',
+    'exhortacion': 'admonition',  # sic! kept for backwards compatibiltity
+    'exhortación': 'admonition',  # sic! kept for backwards compatibiltity
+    'nota-al-margen': 'sidebar',
+    'tema': 'topic',
+    'bloque-de-lineas': 'line-block',
+    'bloque-de-líneas': 'line-block',
+    'literal-evaluado': 'parsed-literal',
+    'firma': 'rubric',
+    'epígrafe': 'epigraph',
+    'epigrafe': 'epigraph',
+    'destacado': 'highlights',
+    'cita-destacada': 'pull-quote',
+    'combinacion': 'compound',
+    'combinación': 'compound',
+    'contenedor': 'container',
+    # 'questions': 'questions',
+    # 'qa': 'questions',
+    # 'faq': 'questions',
+    'tabla': 'table',
+    'tabla-vsc': 'csv-table',
+    'tabla-csv': 'csv-table',
+    'tabla-lista': 'list-table',
+    'meta': 'meta',
+    'math (translation required)': 'math',
+    # 'imagemap': 'imagemap',
+    'imagen': 'image',
+    'figura': 'figure',
+    'incluir': 'include',
+    'sin-analisis': 'raw',
+    'sin-análisis': 'raw',
+    'reemplazar': 'replace',
+    'unicode': 'unicode',
+    'fecha': 'date',
+    'clase': 'class',
+    'rol': 'role',
+    'rol-por-omision': 'default-role',
+    'rol-por-omisión': 'default-role',
+    'titulo': 'title',
+    'título': 'title',
+    'contenido': 'contents',
+    'numseccion': 'sectnum',
+    'numsección': 'sectnum',
+    'numeracion-seccion': 'sectnum',
+    'numeración-sección': 'sectnum',
+    'notas-destino': 'target-notes',
+    'cabecera': 'header',
+    'pie': 'footer',
+    # 'footnotes': 'footnotes',
+    # 'citations': 'citations',
+    'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Spanish name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    'abreviatura': 'abbreviation',
+    'ab': 'abbreviation',
+    'acronimo': 'acronym',
+    'ac': 'acronym',
+    'code (translation required)': 'code',
+    'indice': 'index',
+    'i': 'index',
+    'subindice': 'subscript',
+    'subíndice': 'subscript',
+    'superindice': 'superscript',
+    'superíndice': 'superscript',
+    'referencia-titulo': 'title-reference',
+    'titulo': 'title-reference',
+    't': 'title-reference',
+    'referencia-pep': 'pep-reference',
+    'pep': 'pep-reference',
+    'referencia-rfc': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'enfasis': 'emphasis',
+    'énfasis': 'emphasis',
+    'destacado': 'strong',
+    'literal': 'literal',  # "literal" is also a word in Spanish :-)
+    'math (translation required)': 'math',
+    'referencia-con-nombre': 'named-reference',
+    'referencia-anonima': 'anonymous-reference',
+    'referencia-anónima': 'anonymous-reference',
+    'referencia-nota-al-pie': 'footnote-reference',
+    'referencia-cita': 'citation-reference',
+    'referencia-sustitucion': 'substitution-reference',
+    'referencia-sustitución': 'substitution-reference',
+    'destino': 'target',
+    'referencia-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'sin-analisis': 'raw',
+    'sin-análisis': 'raw',
+}
+"""Mapping of Spanish role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fa.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fa.py
new file mode 100644
index 00000000..420a315e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fa.py
@@ -0,0 +1,102 @@
+# $Id: fa.py 4564 2016-08-10 11:48:42Z
+# Author: Shahin <me@5hah.in>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Persian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+    # language-dependent: fixed
+    'توجه': 'attention',
+    'احتیاط': 'caution',
+    'کد': 'code',
+    'بلوک-کد': 'code',
+    'کد-منبع': 'code',
+    'خطر': 'danger',
+    'خطا': 'error',
+    'راهنما': 'hint',
+    'مهم': 'important',
+    'یادداشت': 'note',
+    'نکته': 'tip',
+    'اخطار': 'warning',
+    'تذکر': 'admonition',
+    'نوار-کناری': 'sidebar',
+    'موضوع': 'topic',
+    'بلوک-خط': 'line-block',
+    'تلفظ-پردازش-شده': 'parsed-literal',
+    'سر-فصل': 'rubric',
+    'کتیبه': 'epigraph',
+    'نکات-برجسته': 'highlights',
+    'نقل-قول': 'pull-quote',
+    'ترکیب': 'compound',
+    'ظرف': 'container',
+    # 'questions': 'questions',
+    'جدول': 'table',
+    'جدول-csv': 'csv-table',
+    'جدول-لیست': 'list-table',
+    # 'qa': 'questions',
+    # 'faq': 'questions',
+    'متا': 'meta',
+    'ریاضی': 'math',
+    # 'imagemap': 'imagemap',
+    'تصویر': 'image',
+    'شکل': 'figure',
+    'شامل': 'include',
+    'خام': 'raw',
+    'جایگزین': 'replace',
+    'یونیکد': 'unicode',
+    'تاریخ': 'date',
+    'کلاس': 'class',
+    'قانون': 'role',
+    'قانون-پیش‌فرض': 'default-role',
+    'عنوان': 'title',
+    'محتوا': 'contents',
+    'شماره-فصل': 'sectnum',
+    'شماره‌گذاری-فصل': 'sectnum',
+    'سرآیند': 'header',
+    'پاصفحه': 'footer',
+    # 'footnotes': 'footnotes',
+    # 'citations': 'citations',
+    'یادداشت-هدف': 'target-notes',
+}
+"""Persian name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'مخفف': 'abbreviation',
+    'سرنام': 'acronym',
+    'کد': 'code',
+    'شاخص': 'index',
+    'زیرنویس': 'subscript',
+    'بالانویس': 'superscript',
+    'عنوان': 'title-reference',
+    'نیرو': 'pep-reference',
+    'rfc-reference (translation required)': 'rfc-reference',
+    'تاکید': 'emphasis',
+    'قوی': 'strong',
+    'لفظی': 'literal',
+    'ریاضی': 'math',
+    'منبع-نام‌گذاری': 'named-reference',
+    'منبع-ناشناس': 'anonymous-reference',
+    'منبع-پانویس': 'footnote-reference',
+    'منبع-نقل‌فول': 'citation-reference',
+    'منبع-جایگزینی': 'substitution-reference',
+    'هدف': 'target',
+    'منبع-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'خام': 'raw',
+}
+"""Mapping of Persian role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fi.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fi.py
new file mode 100644
index 00000000..88653ac5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fi.py
@@ -0,0 +1,98 @@
+# $Id: fi.py 9452 2023-09-27 00:11:54Z milde $
+# Author: Asko Soukka <asko.soukka@iki.fi>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Finnish-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'huomio': 'attention',
+      'varo': 'caution',
+      'code (translation required)': 'code',
+      'vaara': 'danger',
+      'virhe': 'error',
+      'vihje': 'hint',
+      'tärkeää': 'important',
+      'huomautus': 'note',
+      'neuvo': 'tip',
+      'varoitus': 'warning',
+      'kehotus': 'admonition',  # sic! advice/advisory/remark, not reprimand
+      'sivupalkki': 'sidebar',
+      'aihe': 'topic',
+      'rivi': 'line-block',
+      'tasalevyinen': 'parsed-literal',
+      'ohje': 'rubric',
+      'epigraafi': 'epigraph',
+      'kohokohdat': 'highlights',
+      'lainaus': 'pull-quote',
+      'taulukko': 'table',
+      'csv-taulukko': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'kysymykset': 'questions',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      # 'kuvakartta': 'imagemap',
+      'kuva': 'image',
+      'kaavio': 'figure',
+      'sisällytä': 'include',
+      'raaka': 'raw',
+      'korvaa': 'replace',
+      'unicode': 'unicode',
+      'päiväys': 'date',
+      'luokka': 'class',
+      'rooli': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'sisällys': 'contents',
+      'kappale': 'sectnum',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'alaviitteet': 'footnotes',
+      # 'viitaukset': 'citations',
+      'target-notes (translation required)': 'target-notes'}
+"""Finnish name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'lyhennys': 'abbreviation',
+    'akronyymi': 'acronym',
+    'kirjainsana': 'acronym',
+    'code (translation required)': 'code',
+    'hakemisto': 'index',
+    'luettelo': 'index',
+    'alaindeksi': 'subscript',
+    'indeksi': 'subscript',
+    'yläindeksi': 'superscript',
+    'title-reference (translation required)': 'title-reference',
+    'title (translation required)': 'title-reference',
+    'pep-reference (translation required)': 'pep-reference',
+    'rfc-reference (translation required)': 'rfc-reference',
+    'korostus': 'emphasis',
+    'vahvistus': 'strong',
+    'tasalevyinen': 'literal',
+    'math (translation required)': 'math',
+    'named-reference (translation required)': 'named-reference',
+    'anonymous-reference (translation required)': 'anonymous-reference',
+    'footnote-reference (translation required)': 'footnote-reference',
+    'citation-reference (translation required)': 'citation-reference',
+    'substitution-reference (translation required)': 'substitution-reference',
+    'kohde': 'target',
+    'uri-reference (translation required)': 'uri-reference',
+    'raw (translation required)': 'raw',
+    }
+"""Mapping of Finnish role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fr.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fr.py
new file mode 100644
index 00000000..cd4ca9db
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/fr.py
@@ -0,0 +1,108 @@
+# $Id: fr.py 9417 2023-06-27 20:04:54Z milde $
+# Authors: David Goodger <goodger@python.org>; William Dode
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+French-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      'attention': 'attention',
+      'précaution': 'caution',
+      'danger': 'danger',
+      'erreur': 'error',
+      'conseil': 'hint',
+      'important': 'important',
+      'note': 'note',
+      'astuce': 'tip',
+      'avertissement': 'warning',
+      'annonce': 'admonition',
+      'admonition': 'admonition',  # sic! kept for backwards compatibiltity
+      # suggestions: annonce, avis, indication, remarque, renseignement
+      # see also https://sourceforge.net/p/docutils/bugs/453/
+      'encadré': 'sidebar',
+      'sujet': 'topic',
+      'bloc-textuel': 'line-block',
+      'bloc-interprété': 'parsed-literal',
+      'code-interprété': 'parsed-literal',
+      'code': 'code',
+      'math (translation required)': 'math',
+      'intertitre': 'rubric',
+      'exergue': 'epigraph',
+      'épigraphe': 'epigraph',
+      'chapeau': 'highlights',
+      'accroche': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      'tableau': 'table',
+      'csv-table (translation required)': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      'méta': 'meta',
+      # 'imagemap (translation required)': 'imagemap',
+      'image': 'image',
+      'figure': 'figure',
+      'inclure': 'include',
+      'brut': 'raw',
+      'remplacer': 'replace',
+      'remplace': 'replace',
+      'unicode': 'unicode',
+      'date': 'date',
+      'classe': 'class',
+      'role (translation required)': 'role',
+      'default-role (translation required)': 'default-role',
+      'titre (translation required)': 'title',
+      'sommaire': 'contents',
+      'table-des-matières': 'contents',
+      'sectnum': 'sectnum',
+      'section-numérotée': 'sectnum',
+      'liens': 'target-notes',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'footnotes (translation required)': 'footnotes',
+      # 'citations (translation required)': 'citations',
+      }
+"""Mapping of French directive names to registered directive names
+
+Cf. https://docutils.sourceforge.io/docs/ref/rst/directives.html
+and `_directive_registry` in ``directives/__init__.py``.
+"""
+
+roles = {
+      'abréviation': 'abbreviation',
+      'acronyme': 'acronym',
+      'sigle': 'acronym',
+      'code': 'code',
+      'emphase': 'emphasis',
+      'littéral': 'literal',
+      'math (translation required)': 'math',
+      'pep-référence': 'pep-reference',
+      'rfc-référence': 'rfc-reference',
+      'fort': 'strong',
+      'indice': 'subscript',
+      'ind': 'subscript',
+      'exposant': 'superscript',
+      'exp': 'superscript',
+      'titre-référence': 'title-reference',
+      'titre': 'title-reference',
+      'brut': 'raw',
+      # the following roles are not implemented in Docutils
+      'index': 'index',
+      'nommée-référence': 'named-reference',
+      'anonyme-référence': 'anonymous-reference',
+      'note-référence': 'footnote-reference',
+      'citation-référence': 'citation-reference',
+      'substitution-référence': 'substitution-reference',
+      'lien': 'target',
+      'uri-référence': 'uri-reference',
+      }
+"""Mapping of French role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/gl.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/gl.py
new file mode 100644
index 00000000..837c3f1f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/gl.py
@@ -0,0 +1,106 @@
+# Author: David Goodger
+# Contact: goodger@users.sourceforge.net
+# Revision: $Revision: 4229 $
+# Date: $Date: 2005-12-23 00:46:16 +0100 (Fri, 23 Dec 2005) $
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Galician-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'atención': 'attention',
+      'advertencia': 'caution',
+      'code (translation required)': 'code',
+      'perigo': 'danger',
+      'erro': 'error',
+      'pista': 'hint',
+      'importante': 'important',
+      'nota': 'note',
+      'consello': 'tip',
+      'aviso': 'warning',
+      'admonición': 'admonition',  # sic! advice/advisory/remark, not reprimand
+      'barra lateral': 'sidebar',
+      'tópico': 'topic',
+      'bloque-liña': 'line-block',
+      'literal-analizado': 'parsed-literal',
+      'rúbrica': 'rubric',
+      'epígrafe': 'epigraph',
+      'realzados': 'highlights',
+      'coller-citación': 'pull-quote',
+      'compor': 'compound',
+      'recipiente': 'container',
+      'táboa': 'table',
+      'táboa-csv': 'csv-table',
+      'táboa-listaxe': 'list-table',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      'imaxe': 'image',
+      'figura': 'figure',
+      'incluír': 'include',
+      'cru': 'raw',
+      'substituír': 'replace',
+      'unicode': 'unicode',
+      'data': 'date',
+      'clase': 'class',
+      'regra': 'role',
+      'regra-predeterminada': 'default-role',
+      'título': 'title',
+      'contido': 'contents',
+      'seccnum': 'sectnum',
+      'sección-numerar': 'sectnum',
+      'cabeceira': 'header',
+      'pé de páxina': 'footer',
+      'notas-destino': 'target-notes',
+      'texto restruturado-proba-directiva': 'restructuredtext-test-directive',
+      }
+"""Galician name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'abreviatura': 'abbreviation',
+    'ab': 'abbreviation',
+    'acrónimo': 'acronym',
+    'ac': 'acronym',
+    'code (translation required)': 'code',
+    'índice': 'index',
+    'i': 'index',
+    'subíndice': 'subscript',
+    'sub': 'subscript',
+    'superíndice': 'superscript',
+    'sup': 'superscript',
+    'referencia título': 'title-reference',
+    'título': 'title-reference',
+    't': 'title-reference',
+    'referencia-pep': 'pep-reference',
+    'pep': 'pep-reference',
+    'referencia-rfc': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'énfase': 'emphasis',
+    'forte': 'strong',
+    'literal': 'literal',
+    'math (translation required)': 'math',
+    'referencia-nome': 'named-reference',
+    'referencia-anónimo': 'anonymous-reference',
+    'referencia-nota ao pé': 'footnote-reference',
+    'referencia-citación': 'citation-reference',
+    'referencia-substitución': 'substitution-reference',
+    'destino': 'target',
+    'referencia-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'cru': 'raw',
+    }
+"""Mapping of Galician role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/he.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/he.py
new file mode 100644
index 00000000..7a5f3bae
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/he.py
@@ -0,0 +1,110 @@
+# Author: Meir Kriheli
+# Id: $Id: he.py 9452 2023-09-27 00:11:54Z milde $
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+English-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+    # language-dependent: fixed
+    'תשומת לב': 'attention',
+    'זהירות': 'caution',
+    'code (translation required)': 'code',
+    'סכנה': 'danger',
+    'שגיאה': 'error',
+    'רמז': 'hint',
+    'חשוב': 'important',
+    'הערה': 'note',
+    'טיפ': 'tip',
+    'אזהרה': 'warning',
+    'admonition': 'admonition',
+    'sidebar': 'sidebar',
+    'topic': 'topic',
+    'line-block': 'line-block',
+    'parsed-literal': 'parsed-literal',
+    'rubric': 'rubric',
+    'epigraph': 'epigraph',
+    'highlights': 'highlights',
+    'pull-quote': 'pull-quote',
+    'compound': 'compound',
+    'container': 'container',
+    'table': 'table',
+    'csv-table': 'csv-table',
+    'list-table': 'list-table',
+    'meta': 'meta',
+    'math (translation required)': 'math',
+    'תמונה': 'image',
+    'figure': 'figure',
+    'include': 'include',
+    'raw': 'raw',
+    'replace': 'replace',
+    'unicode': 'unicode',
+    'date': 'date',
+    'סגנון': 'class',
+    'role': 'role',
+    'default-role': 'default-role',
+    'title': 'title',
+    'תוכן': 'contents',
+    'sectnum': 'sectnum',
+    'section-numbering': 'sectnum',
+    'header': 'header',
+    'footer': 'footer',
+    'target-notes': 'target-notes',
+    'restructuredtext-test-directive': 'restructuredtext-test-directive',
+    # 'questions': 'questions',
+    # 'qa': 'questions',
+    # 'faq': 'questions',
+    # 'imagemap': 'imagemap',
+    # 'footnotes': 'footnotes',
+    # 'citations': 'citations',
+    }
+"""English name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'abbreviation': 'abbreviation',
+    'ab': 'abbreviation',
+    'acronym': 'acronym',
+    'ac': 'acronym',
+    'code (translation required)': 'code',
+    'index': 'index',
+    'i': 'index',
+    'תחתי': 'subscript',
+    'sub': 'subscript',
+    'עילי': 'superscript',
+    'sup': 'superscript',
+    'title-reference': 'title-reference',
+    'title': 'title-reference',
+    't': 'title-reference',
+    'pep-reference': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-reference': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'emphasis': 'emphasis',
+    'strong': 'strong',
+    'literal': 'literal',
+    'math (translation required)': 'math',
+    'named-reference': 'named-reference',
+    'anonymous-reference': 'anonymous-reference',
+    'footnote-reference': 'footnote-reference',
+    'citation-reference': 'citation-reference',
+    'substitution-reference': 'substitution-reference',
+    'target': 'target',
+    'uri-reference': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'raw': 'raw',
+    }
+"""Mapping of English role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/it.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/it.py
new file mode 100644
index 00000000..ee5ba829
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/it.py
@@ -0,0 +1,99 @@
+# $Id: it.py 9417 2023-06-27 20:04:54Z milde $
+# Authors: Nicola Larosa <docutils@tekNico.net>;
+#          Lele Gaifax <lele@seldati.it>
+# Copyright: This module has been placed in the public domain.
+
+# Beware: the italian translation of the reStructuredText documentation
+# at http://docit.bice.dyndns.org/static/ReST, in particular
+# http://docit.bice.dyndns.org/static/ReST/ref/rst/directives.html, needs
+# to be synced with the content of this file.
+
+"""
+Italian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      'attenzione': 'attention',
+      'cautela': 'caution',
+      'code (translation required)': 'code',
+      'pericolo': 'danger',
+      'errore': 'error',
+      'suggerimento': 'hint',
+      'importante': 'important',
+      'nota': 'note',
+      'consiglio': 'tip',
+      'avvertenza': 'warning',
+      'avviso': 'admonition',
+      'ammonizione': 'admonition',  # sic! kept for backards compatibility
+      'riquadro': 'sidebar',
+      'argomento': 'topic',
+      'blocco-di-righe': 'line-block',
+      'blocco-interpretato': 'parsed-literal',
+      'rubrica': 'rubric',
+      'epigrafe': 'epigraph',
+      'punti-salienti': 'highlights',
+      'estratto-evidenziato': 'pull-quote',
+      'composito': 'compound',
+      'container (translation required)': 'container',
+      # 'questions': 'questions',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'tabella': 'table',
+      'tabella-csv': 'csv-table',
+      'tabella-elenco': 'list-table',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap': 'imagemap',
+      'immagine': 'image',
+      'figura': 'figure',
+      'includi': 'include',
+      'grezzo': 'raw',
+      'sostituisci': 'replace',
+      'unicode': 'unicode',
+      'data': 'date',
+      'classe': 'class',
+      'ruolo': 'role',
+      'ruolo-predefinito': 'default-role',
+      'titolo': 'title',
+      'indice': 'contents',
+      'contenuti': 'contents',
+      'seznum': 'sectnum',
+      'sezioni-autonumerate': 'sectnum',
+      'annota-riferimenti-esterni': 'target-notes',
+      'intestazione': 'header',
+      'piede-pagina': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Italian name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+      'abbreviazione': 'abbreviation',
+      'acronimo': 'acronym',
+      'code (translation required)': 'code',
+      'indice': 'index',
+      'deponente': 'subscript',
+      'esponente': 'superscript',
+      'riferimento-titolo': 'title-reference',
+      'riferimento-pep': 'pep-reference',
+      'riferimento-rfc': 'rfc-reference',
+      'enfasi': 'emphasis',
+      'forte': 'strong',
+      'letterale': 'literal',
+      'math (translation required)': 'math',
+      'riferimento-con-nome': 'named-reference',
+      'riferimento-anonimo': 'anonymous-reference',
+      'riferimento-nota': 'footnote-reference',
+      'riferimento-citazione': 'citation-reference',
+      'riferimento-sostituzione': 'substitution-reference',
+      'destinazione': 'target',
+      'riferimento-uri': 'uri-reference',
+      'grezzo': 'raw',
+      }
+"""Mapping of Italian role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ja.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ja.py
new file mode 100644
index 00000000..eef1549d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ja.py
@@ -0,0 +1,119 @@
+# $Id: ja.py 9030 2022-03-05 23:28:32Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Japanese-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+# Corrections to these translations are welcome!
+# 間違いがあれば、どうぞ正しい翻訳を教えて下さい。
+
+directives = {
+    # language-dependent: fixed
+    '注目': 'attention',
+    '注意': 'caution',
+    'code (translation required)': 'code',
+    '危険': 'danger',
+    'エラー': 'error',
+    'ヒント': 'hint',
+    '重要': 'important',
+    '備考': 'note',
+    '通報': 'tip',
+    '警告': 'warning',
+    '戒告': 'admonition',
+    'サイドバー': 'sidebar',
+    'トピック': 'topic',
+    'ラインブロック': 'line-block',
+    'パーズドリテラル': 'parsed-literal',
+    'ルブリック': 'rubric',
+    'エピグラフ': 'epigraph',
+    '題言': 'epigraph',
+    'ハイライト': 'highlights',
+    '見所': 'highlights',
+    'プルクオート': 'pull-quote',
+    '合成': 'compound',
+    'コンテナー': 'container',
+    '容器': 'container',
+    '表': 'table',
+    'csv表': 'csv-table',
+    'リスト表': 'list-table',
+    # '質問': 'questions',
+    # '問答': 'questions',
+    # 'faq': 'questions',
+    'math (translation required)': 'math',
+    'メタ': 'meta',
+    # 'イメージマプ': 'imagemap',
+    'イメージ': 'image',
+    '画像': 'image',
+    'フィグア': 'figure',
+    '図版': 'figure',
+    'インクルード': 'include',
+    '含む': 'include',
+    '組み込み': 'include',
+    '生': 'raw',
+    '原': 'raw',
+    '換える': 'replace',
+    '取り換える': 'replace',
+    '掛け替える': 'replace',
+    'ユニコード': 'unicode',
+    '日付': 'date',
+    'クラス': 'class',
+    'ロール': 'role',
+    '役': 'role',
+    'ディフォルトロール': 'default-role',
+    '既定役': 'default-role',
+    'タイトル': 'title',
+    '題': 'title',                       # 題名　件名
+    '目次': 'contents',
+    '節数': 'sectnum',
+    'ヘッダ': 'header',
+    'フッタ': 'footer',
+    # '脚注': 'footnotes',                # 脚註?
+    # 'サイテーション': 'citations',　　　# 出典　引証　引用
+    'ターゲットノート': 'target-notes',  # 的注　的脚注
+    }
+"""Japanese name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    '略': 'abbreviation',
+    '頭字語': 'acronym',
+    'code (translation required)': 'code',
+    'インデックス': 'index',
+    '索引': 'index',
+    '添字': 'subscript',
+    '下付': 'subscript',
+    '下': 'subscript',
+    '上付': 'superscript',
+    '上': 'superscript',
+    '題参照': 'title-reference',
+    'pep参照': 'pep-reference',
+    'rfc参照': 'rfc-reference',
+    '強調': 'emphasis',
+    '強い': 'strong',
+    'リテラル': 'literal',
+    '整形済み': 'literal',
+    'math (translation required)': 'math',
+    '名付参照': 'named-reference',
+    '無名参照': 'anonymous-reference',
+    '脚注参照': 'footnote-reference',
+    '出典参照': 'citation-reference',
+    '代入参照': 'substitution-reference',
+    '的': 'target',
+    'uri参照': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    '生': 'raw',
+    }
+"""Mapping of Japanese role names to canonical role names for interpreted
+text."""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ka.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ka.py
new file mode 100644
index 00000000..e7f18ab7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ka.py
@@ -0,0 +1,90 @@
+# $Id: ka.py 9444 2023-08-23 12:02:41Z grubert $
+# Author: Temuri Doghonadze <temuri.doghonadze@gmail.com>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Georgian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+directives = {
+    'ხაზების-ბლოკი': 'line-block',
+    'მეტა': 'meta',
+    'მათემატიკა': 'math',
+    'დამუშავებული-ლიტერალი': 'parsed-literal',
+    'გამოყოფილი-ციტატა': 'pull-quote',
+    'კოდი': 'code',
+    'შერეული': 'compound',
+    'კონტეინერი': 'container',
+    'ცხრილი': 'table',
+    'csv-ცხრილი': 'csv-table',
+    'ჩამონათვალი-ცხრილი': 'list-table',
+    'დაუმუშავებელი': 'raw',
+    'ჩანაცვლება': 'replace',
+    'restructuredtext-ის-სატესტო-დირექტივა': 'restructuredtext-test-directive',
+    'სამიზნე-შენიშვნები': 'target-notes',
+    'უნიკოდი': 'unicode',
+    'თარიღი': 'date',
+    'გვერდითი-პანელი': 'sidebar',
+    'მნიშვნელოვანი': 'important',
+    'ჩასმა': 'include',
+    'ყურადღება': 'attention',
+    'გამოკვეთა': 'highlights',
+    'შენიშვნა': 'admonition',
+    'გამოსახულება': 'image',
+    'კლასი': 'class',
+    'როლი': 'role',
+    'ნაგულისხმევი-როლი': 'default-role',
+    'სათაური': 'title',
+    'განყ-ნომერი': 'sectnum',
+    'განყ-ნომერი': 'sectnum',
+    'საფრთხე': 'danger',
+    'ფრთხილად': 'caution',
+    'შეცდომა': 'error',
+    'მინიშნება': 'tip',
+    'ყურადღებით': 'warning',
+    'აღნიშვნა': 'note',
+    'ფიგურა': 'figure',
+    'რუბრიკა': 'rubric',
+    'რჩევა': 'hint',
+    'შემცველობა': 'contents',
+    'თემა': 'topic',
+    'ეპიგრაფი': 'epigraph',
+    'თავსართი': 'header',
+    'ქვედა კოლონტიტული': 'footer',
+    }
+"""Georgian name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    'აკრონიმი': 'acronym',
+    'კოდი': 'code',
+    'ანონიმური-მიმართვა': 'anonymous-reference',
+    'სიტყვასიტყვითი': 'literal',
+    'მათემატიკა': 'math',
+    'ზედა-ინდექსი': 'superscript',
+    'მახვილი': 'emphasis',
+    'სახელიანი-მიმართვა': 'named-reference',
+    'ინდექსი': 'index',
+    'ქვედა-ინდექსი': 'subscript',
+    'სქელი-ფონტი': 'strong',
+    'აბრევიატურა': 'abbreviation',
+    'ჩანაცვლების-მიმართვა': 'substitution-reference',
+    'pep-მიმართვა': 'pep-reference',
+    'rfc-მიმართვა	': 'rfc-reference',
+    'uri-მიმართვა': 'uri-reference',
+    'title-მიმართვა': 'title-reference',
+    'ქვედა-კოლონტიტულზე-მიმართვა': 'footnote-reference',
+    'ციტატაზე-მიმართვა': 'citation-reference',
+    'სამიზნე': 'target',
+    'დაუმუშავებელი': 'raw',
+    }
+"""Mapping of Georgian role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ko.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ko.py
new file mode 100644
index 00000000..434fea12
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ko.py
@@ -0,0 +1,111 @@
+# $Id: ko.py 9030 2022-03-05 23:28:32Z milde $
+# Author: Thomas SJ Kang <thomas.kangsj@ujuc.kr>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Korean-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      '집중': 'attention',
+      '주의': 'caution',
+      '코드': 'code',
+      '코드-블록': 'code',
+      '소스코드': 'code',
+      '위험': 'danger',
+      '오류': 'error',
+      '실마리': 'hint',
+      '중요한': 'important',
+      '비고': 'note',
+      '팁': 'tip',
+      '경고': 'warning',
+      '권고': 'admonition',
+      '사이드바': 'sidebar',
+      '주제': 'topic',
+      '라인-블록': 'line-block',
+      '파싱된-리터럴': 'parsed-literal',
+      '지시문': 'rubric',
+      '제명': 'epigraph',
+      '하이라이트': 'highlights',
+      '발췌문': 'pull-quote',
+      '합성어': 'compound',
+      '컨테이너': 'container',
+      # '질문': 'questions',
+      '표': 'table',
+      'csv-표': 'csv-table',
+      'list-표': 'list-table',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      '메타': 'meta',
+      '수학': 'math',
+      # '이미지맵': 'imagemap',
+      '이미지': 'image',
+      '도표': 'figure',
+      '포함': 'include',
+      'raw': 'raw',
+      '대신하다': 'replace',
+      '유니코드': 'unicode',
+      '날짜': 'date',
+      '클래스': 'class',
+      '역할': 'role',
+      '기본-역할': 'default-role',
+      '제목': 'title',
+      '내용': 'contents',
+      'sectnum': 'sectnum',
+      '섹션-번호-매기기': 'sectnum',
+      '머리말': 'header',
+      '꼬리말': 'footer',
+      # '긱주': 'footnotes',
+      # '인용구': 'citations',
+      '목표-노트': 'target-notes',
+      'restructuredtext 테스트 지시어': 'restructuredtext-test-directive'}
+"""Korean name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    '약어': 'abbreviation',
+    'ab': 'abbreviation',
+    '두음문자': 'acronym',
+    'ac': 'acronym',
+    '코드': 'code',
+    '색인': 'index',
+    'i': 'index',
+    '다리-글자': 'subscript',
+    'sub': 'subscript',
+    '어깨-글자': 'superscript',
+    'sup': 'superscript',
+    '제목-참조': 'title-reference',
+    '제목': 'title-reference',
+    't': 'title-reference',
+    'pep-참조': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-참조': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    '강조': 'emphasis',
+    '굵게': 'strong',
+    '기울기': 'literal',
+    '수학': 'math',
+    '명명된-참조': 'named-reference',
+    '익명-참조': 'anonymous-reference',
+    '각주-참조': 'footnote-reference',
+    '인용-참조': 'citation-reference',
+    '대리-참조': 'substitution-reference',
+    '대상': 'target',
+    'uri-참조': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'raw': 'raw',
+    }
+"""Mapping of Korean role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/lt.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/lt.py
new file mode 100644
index 00000000..7d324d67
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/lt.py
@@ -0,0 +1,109 @@
+# $Id: lt.py 9030 2022-03-05 23:28:32Z milde $
+# Author: Dalius Dobravolskas <dalius.do...@gmail.com>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Lithuanian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'dėmesio': 'attention',
+      'atsargiai': 'caution',
+      'code (translation required)': 'code',
+      'pavojinga': 'danger',
+      'klaida': 'error',
+      'užuomina': 'hint',
+      'svarbu': 'important',
+      'pastaba': 'note',
+      'patarimas': 'tip',
+      'įspėjimas': 'warning',
+      'perspėjimas': 'admonition',
+      'šoninė-juosta': 'sidebar',
+      'tema': 'topic',
+      'linijinis-blokas': 'line-block',
+      'išanalizuotas-literalas': 'parsed-literal',
+      'rubrika': 'rubric',
+      'epigrafas': 'epigraph',
+      'pagridiniai-momentai': 'highlights',
+      'atitraukta-citata': 'pull-quote',
+      'sudėtinis-darinys': 'compound',
+      'konteineris': 'container',
+      # 'questions': 'questions',
+      'lentelė': 'table',
+      'csv-lentelė': 'csv-table',
+      'sąrašo-lentelė': 'list-table',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'meta': 'meta',
+      'matematika': 'math',
+      # 'imagemap': 'imagemap',
+      'paveiksliukas': 'image',
+      'iliustracija': 'figure',
+      'pridėti': 'include',
+      'žalia': 'raw',
+      'pakeisti': 'replace',
+      'unikodas': 'unicode',
+      'data': 'date',
+      'klasė': 'class',
+      'rolė': 'role',
+      'numatytoji-rolė': 'default-role',
+      'titulas': 'title',
+      'turinys': 'contents',
+      'seknum': 'sectnum',
+      'sekcijos-numeravimas': 'sectnum',
+      'antraštė': 'header',
+      'poraštė': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'nutaikytos-pastaba': 'target-notes',
+      'restructuredtext-testinė-direktyva': 'restructuredtext-test-directive'}
+"""Lithuanian name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'santrumpa': 'abbreviation',
+    'sa': 'abbreviation',
+    'akronimas': 'acronym',
+    'ak': 'acronym',
+    'code (translation required)': 'code',
+    'indeksas': 'index',
+    'i': 'index',
+    'apatinis-indeksas': 'subscript',
+    'sub': 'subscript',
+    'viršutinis-indeksas': 'superscript',
+    'sup': 'superscript',
+    'antrašės-nuoroda': 'title-reference',
+    'antraštė': 'title-reference',
+    'a': 'title-reference',
+    'pep-nuoroda': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-nuoroda': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'paryškinimas': 'emphasis',
+    'sustiprintas': 'strong',
+    'literalas': 'literal',
+    'matematika': 'math',
+    'vardinė-nuoroda': 'named-reference',
+    'anoniminė-nuoroda': 'anonymous-reference',
+    'išnašos-nuoroda': 'footnote-reference',
+    'citatos-nuoroda': 'citation-reference',
+    'pakeitimo-nuoroda': 'substitution-reference',
+    'taikinys': 'target',
+    'uri-nuoroda': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'žalia': 'raw',
+    }
+"""Mapping of English role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/lv.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/lv.py
new file mode 100644
index 00000000..18e4dc49
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/lv.py
@@ -0,0 +1,108 @@
+# $Id: lv.py 9030 2022-03-05 23:28:32Z milde $
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Latvian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'uzmanību': 'attention',
+      'piesardzību': 'caution',
+      'kods': 'code',
+      'koda-bloks': 'code',
+      'pirmkods': 'code',
+      'bīstami': 'danger',
+      'kļūda': 'error',
+      'ieteikums': 'hint',
+      'svarīgi': 'important',
+      'piezīme': 'note',
+      'padoms': 'tip',
+      'brīdinājums': 'warning',
+      'aizrādījums': 'admonition',
+      'sānjosla': 'sidebar',
+      'tēma': 'topic',
+      'rindu-bloks': 'line-block',
+      'parsēts-literālis': 'parsed-literal',
+      'rubrika': 'rubric',
+      'epigrāfs': 'epigraph',
+      'apskats': 'highlights',
+      'izvilkuma-citāts': 'pull-quote',
+      'savienojums': 'compound',
+      'konteiners': 'container',
+      # 'questions': 'questions',
+      'tabula': 'table',
+      'csv-tabula': 'csv-table',
+      'sarakstveida-tabula': 'list-table',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'meta': 'meta',
+      'matemātika': 'math',
+      # 'imagemap': 'imagemap',
+      'attēls': 'image',
+      'figūra': 'figure',
+      'ietvert': 'include',
+      'burtiski': 'raw',
+      'aizvieto': 'replace',
+      'unicode': 'unicode',
+      'datums': 'date',
+      'klase': 'class',
+      'role': 'role',
+      'noklusējuma-role': 'default-role',
+      'virsraksts': 'title',
+      'saturs': 'contents',
+      'numurēt-sekcijas': 'sectnum',
+      'galvene': 'header',
+      'kājene': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      'atsauces-apakšā': 'target-notes',
+      'restructuredtext-testa-direktīva': 'restructuredtext-test-directive'}
+"""English name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'saīsinājums': 'abbreviation',
+    'īsi': 'abbreviation',
+    'akronīms': 'acronym',
+    'kods': 'code',
+    'indekss': 'index',
+    'i': 'index',
+    'apakšraksts': 'subscript',
+    'apakšā': 'subscript',
+    'augšraksts': 'superscript',
+    'augšā': 'superscript',
+    'virsraksta-atsauce': 'title-reference',
+    'virsraksts': 'title-reference',
+    'v': 'title-reference',
+    'atsauce-uz-pep': 'pep-reference',
+    'pep': 'pep-reference',
+    'atsauce-uz-rfc': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'izcēlums': 'emphasis',
+    'blīvs': 'strong',
+    'literālis': 'literal',
+    'matemātika': 'math',
+    'nosaukta-atsauce': 'named-reference',
+    'nenosaukta-atsauce': 'anonymous-reference',
+    'kājenes-atsauce': 'footnote-reference',
+    'citātā-atsauce': 'citation-reference',
+    'aizvietojuma-atsauce': 'substitution-reference',
+    'mēr''kis': 'target',
+    'atsauce-uz-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'burtiski': 'raw',
+    }
+"""Mapping of English role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/nl.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/nl.py
new file mode 100644
index 00000000..762ddcf2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/nl.py
@@ -0,0 +1,114 @@
+# $Id: nl.py 9417 2023-06-27 20:04:54Z milde $
+# Author: Martijn Pieters <mjpieters@users.sourceforge.net>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Dutch-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'attentie': 'attention',
+      'let-op': 'caution',
+      'code (translation required)': 'code',
+      'gevaar': 'danger',
+      'fout': 'error',
+      'hint': 'hint',
+      'belangrijk': 'important',
+      'opmerking': 'note',
+      'tip': 'tip',
+      'waarschuwing': 'warning',
+      'advies': 'admonition',
+      'aanmaning': 'admonition',  # sic! kept for backwards compatibiltity
+      'katern': 'sidebar',
+      'onderwerp': 'topic',
+      'lijn-blok': 'line-block',
+      'letterlijk-ontleed': 'parsed-literal',
+      'rubriek': 'rubric',
+      'opschrift': 'epigraph',
+      'hoogtepunten': 'highlights',
+      'pull-quote': 'pull-quote',  # Dutch printers use the english term
+      'samenstelling': 'compound',
+      'verbinding': 'compound',
+      'container (translation required)': 'container',
+      # 'vragen': 'questions',
+      'tabel': 'table',
+      'csv-tabel': 'csv-table',
+      'lijst-tabel': 'list-table',
+      # 'veelgestelde-vragen': 'questions',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap': 'imagemap',
+      'beeld': 'image',
+      'figuur': 'figure',
+      'opnemen': 'include',
+      'onbewerkt': 'raw',
+      'vervang': 'replace',
+      'vervanging': 'replace',
+      'unicode': 'unicode',
+      'datum': 'date',
+      'klasse': 'class',
+      'rol': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'inhoud': 'contents',
+      'sectnum': 'sectnum',
+      'sectie-nummering': 'sectnum',
+      'hoofdstuk-nummering': 'sectnum',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'voetnoten': 'footnotes',
+      # 'citaten': 'citations',
+      'verwijzing-voetnoten': 'target-notes',
+      'restructuredtext-test-instructie': 'restructuredtext-test-directive'}
+"""Dutch name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'afkorting': 'abbreviation',
+    # 'ab': 'abbreviation',
+    'acroniem': 'acronym',
+    'ac': 'acronym',
+    'code (translation required)': 'code',
+    'index': 'index',
+    'i': 'index',
+    'inferieur': 'subscript',
+    'inf': 'subscript',
+    'superieur': 'superscript',
+    'sup': 'superscript',
+    'titel-referentie': 'title-reference',
+    'titel': 'title-reference',
+    't': 'title-reference',
+    'pep-referentie': 'pep-reference',
+    'pep': 'pep-reference',
+    'rfc-referentie': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'nadruk': 'emphasis',
+    'extra': 'strong',
+    'extra-nadruk': 'strong',
+    'vet': 'strong',
+    'letterlijk': 'literal',
+    'math (translation required)': 'math',
+    'benoemde-referentie': 'named-reference',
+    'anonieme-referentie': 'anonymous-reference',
+    'voetnoot-referentie': 'footnote-reference',
+    'citaat-referentie': 'citation-reference',
+    'substitie-reference': 'substitution-reference',
+    'verwijzing': 'target',
+    'uri-referentie': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'onbewerkt': 'raw',
+    }
+"""Mapping of Dutch role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/pl.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/pl.py
new file mode 100644
index 00000000..9aac2d42
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/pl.py
@@ -0,0 +1,101 @@
+# $Id$
+# Author: Robert Wojciechowicz <rw@smsnet.pl>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Polish-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+    # language-dependent: fixed
+    'uwaga': 'attention',
+    'ostrożnie': 'caution',
+    'code (translation required)': 'code',
+    'niebezpieczeństwo': 'danger',
+    'błąd': 'error',
+    'wskazówka': 'hint',
+    'ważne': 'important',
+    'przypis': 'note',
+    'rada': 'tip',
+    'ostrzeżenie': 'warning',
+    'zauważenie': 'admonition',  # remark
+    'upomnienie': 'admonition',  # sic! kept for backwards compatibiltity
+    'ramka': 'sidebar',
+    'temat': 'topic',
+    'blok-linii': 'line-block',
+    'sparsowany-literał': 'parsed-literal',
+    'rubryka': 'rubric',
+    'epigraf': 'epigraph',
+    'highlights': 'highlights',  # FIXME no polish equivalent?
+    'pull-quote': 'pull-quote',  # FIXME no polish equivalent?
+    'złożony': 'compound',
+    'kontener': 'container',
+    # 'questions': 'questions',
+    'tabela': 'table',
+    'tabela-csv': 'csv-table',
+    'tabela-listowa': 'list-table',
+    # 'qa': 'questions',
+    # 'faq': 'questions',
+    'meta': 'meta',
+    'math (translation required)': 'math',
+    # 'imagemap': 'imagemap',
+    'obraz': 'image',
+    'rycina': 'figure',
+    'dołącz': 'include',
+    'surowe': 'raw',
+    'zastąp': 'replace',
+    'unikod': 'unicode',
+    'data': 'date',
+    'klasa': 'class',
+    'rola': 'role',
+    'rola-domyślna': 'default-role',
+    'tytuł': 'title',
+    'treść': 'contents',
+    'sectnum': 'sectnum',
+    'numeracja-sekcji': 'sectnum',
+    'nagłówek': 'header',
+    'stopka': 'footer',
+    # 'footnotes': 'footnotes',
+    # 'citations': 'citations',
+    'target-notes': 'target-notes',  # FIXME no polish equivalent?
+    'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Polish name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'skrót': 'abbreviation',
+    'akronim': 'acronym',
+    'code (translation required)': 'code',
+    'indeks': 'index',
+    'indeks-dolny': 'subscript',
+    'indeks-górny': 'superscript',
+    'referencja-tytuł': 'title-reference',
+    'referencja-pep': 'pep-reference',
+    'referencja-rfc': 'rfc-reference',
+    'podkreślenie': 'emphasis',
+    'wytłuszczenie': 'strong',
+    'dosłownie': 'literal',
+    'math (translation required)': 'math',
+    'referencja-nazwana': 'named-reference',
+    'referencja-anonimowa': 'anonymous-reference',
+    'referencja-przypis': 'footnote-reference',
+    'referencja-cytat': 'citation-reference',
+    'referencja-podstawienie': 'substitution-reference',
+    'cel': 'target',
+    'referencja-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'surowe': 'raw',
+    }
+"""Mapping of Polish role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/pt_br.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/pt_br.py
new file mode 100644
index 00000000..45a670db
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/pt_br.py
@@ -0,0 +1,110 @@
+# $Id: pt_br.py 9452 2023-09-27 00:11:54Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Brazilian Portuguese-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'atenção': 'attention',
+      'cuidado': 'caution',
+      'code (translation required)': 'code',
+      'perigo': 'danger',
+      'erro': 'error',
+      'sugestão': 'hint',
+      'importante': 'important',
+      'nota': 'note',
+      'dica': 'tip',
+      'aviso': 'warning',
+      'advertência': 'admonition',
+      'exortação': 'admonition',  # sic! advice/advisory/remark, not reprimand
+      'barra-lateral': 'sidebar',
+      'tópico': 'topic',
+      'bloco-de-linhas': 'line-block',
+      'literal-interpretado': 'parsed-literal',
+      'rubrica': 'rubric',
+      'epígrafo': 'epigraph',
+      'destaques': 'highlights',
+      'citação-destacada': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'perguntas': 'questions',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'table (translation required)': 'table',
+      'csv-table (translation required)': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap': 'imagemap',
+      'imagem': 'image',
+      'figura': 'figure',
+      'inclusão': 'include',
+      'cru': 'raw',
+      'substituição': 'replace',
+      'unicode': 'unicode',
+      'data': 'date',
+      'classe': 'class',
+      'role (translation required)': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'índice': 'contents',
+      'numsec': 'sectnum',
+      'numeração-de-seções': 'sectnum',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'notas-de-rorapé': 'footnotes',
+      # 'citações': 'citations',
+      'links-no-rodapé': 'target-notes',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Brazilian Portuguese name to registered (in directives/__init__.py)
+directive name mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'abbreviação': 'abbreviation',
+    'ab': 'abbreviation',
+    'acrônimo': 'acronym',
+    'ac': 'acronym',
+    'code (translation required)': 'code',
+    'índice-remissivo': 'index',
+    'i': 'index',
+    'subscrito': 'subscript',
+    'sub': 'subscript',
+    'sobrescrito': 'superscript',
+    'sob': 'superscript',
+    'referência-a-título': 'title-reference',
+    'título': 'title-reference',
+    't': 'title-reference',
+    'referência-a-pep': 'pep-reference',
+    'pep': 'pep-reference',
+    'referência-a-rfc': 'rfc-reference',
+    'rfc': 'rfc-reference',
+    'ênfase': 'emphasis',
+    'forte': 'strong',
+    'literal': 'literal',
+    'math (translation required)': 'math',  # translation required?
+    'referência-por-nome': 'named-reference',
+    'referência-anônima': 'anonymous-reference',
+    'referência-a-nota-de-rodapé': 'footnote-reference',
+    'referência-a-citação': 'citation-reference',
+    'referência-a-substituição': 'substitution-reference',
+    'alvo': 'target',
+    'referência-a-uri': 'uri-reference',
+    'uri': 'uri-reference',
+    'url': 'uri-reference',
+    'cru': 'raw',
+    }
+"""Mapping of Brazilian Portuguese role names to canonical role names
+for interpreted text."""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ru.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ru.py
new file mode 100644
index 00000000..7c84cd02
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/ru.py
@@ -0,0 +1,90 @@
+# $Id: ru.py 9030 2022-03-05 23:28:32Z milde $
+# Author: Roman Suzi <rnd@onego.ru>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Russian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+directives = {
+    'блок-строк': 'line-block',
+    'meta': 'meta',
+    'математика': 'math',
+    'обработанный-литерал': 'parsed-literal',
+    'выделенная-цитата': 'pull-quote',
+    'код': 'code',
+    'compound (translation required)': 'compound',
+    'контейнер': 'container',
+    'таблица': 'table',
+    'csv-table (translation required)': 'csv-table',
+    'list-table (translation required)': 'list-table',
+    'сырой': 'raw',
+    'замена': 'replace',
+    'тестовая-директива-restructuredtext': 'restructuredtext-test-directive',
+    'целевые-сноски': 'target-notes',
+    'unicode': 'unicode',
+    'дата': 'date',
+    'боковая-полоса': 'sidebar',
+    'важно': 'important',
+    'включать': 'include',
+    'внимание': 'attention',
+    'выделение': 'highlights',
+    'замечание': 'admonition',
+    'изображение': 'image',
+    'класс': 'class',
+    'роль': 'role',
+    'default-role (translation required)': 'default-role',
+    'титул': 'title',
+    'номер-раздела': 'sectnum',
+    'нумерация-разделов': 'sectnum',
+    'опасно': 'danger',
+    'осторожно': 'caution',
+    'ошибка': 'error',
+    'подсказка': 'tip',
+    'предупреждение': 'warning',
+    'примечание': 'note',
+    'рисунок': 'figure',
+    'рубрика': 'rubric',
+    'совет': 'hint',
+    'содержание': 'contents',
+    'тема': 'topic',
+    'эпиграф': 'epigraph',
+    'header (translation required)': 'header',
+    'footer (translation required)': 'footer',
+    }
+"""Russian name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    'акроним': 'acronym',
+    'код': 'code',
+    'анонимная-ссылка': 'anonymous-reference',
+    'буквально': 'literal',
+    'математика': 'math',
+    'верхний-индекс': 'superscript',
+    'выделение': 'emphasis',
+    'именованная-ссылка': 'named-reference',
+    'индекс': 'index',
+    'нижний-индекс': 'subscript',
+    'сильное-выделение': 'strong',
+    'сокращение': 'abbreviation',
+    'ссылка-замена': 'substitution-reference',
+    'ссылка-на-pep': 'pep-reference',
+    'ссылка-на-rfc': 'rfc-reference',
+    'ссылка-на-uri': 'uri-reference',
+    'ссылка-на-заглавие': 'title-reference',
+    'ссылка-на-сноску': 'footnote-reference',
+    'цитатная-ссылка': 'citation-reference',
+    'цель': 'target',
+    'сырой': 'raw',
+    }
+"""Mapping of Russian role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/sk.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/sk.py
new file mode 100644
index 00000000..7b1cef82
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/sk.py
@@ -0,0 +1,96 @@
+# $Id: sk.py 9452 2023-09-27 00:11:54Z milde $
+# Author: Miroslav Vasko <zemiak@zoznam.sk>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Slovak-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      'pozor': 'attention',
+      'opatrne': 'caution',
+      'code (translation required)': 'code',
+      'nebezpe\xe8enstvo': 'danger',
+      'chyba': 'error',
+      'rada': 'hint',
+      'd\xf4le\x9eit\xe9': 'important',
+      'pozn\xe1mka': 'note',
+      'tip (translation required)': 'tip',
+      'varovanie': 'warning',
+      'admonition (translation required)': 'admonition',
+      'sidebar (translation required)': 'sidebar',
+      't\xe9ma': 'topic',
+      'blok-riadkov': 'line-block',
+      'parsed-literal': 'parsed-literal',
+      'rubric (translation required)': 'rubric',
+      'epigraph (translation required)': 'epigraph',
+      'highlights (translation required)': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'questions': 'questions',
+      # 'qa': 'questions',
+      # 'faq': 'questions',
+      'table (translation required)': 'table',
+      'csv-table (translation required)': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      'meta': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap': 'imagemap',
+      'obr\xe1zok': 'image',
+      'tvar': 'figure',
+      'vlo\x9ei\x9d': 'include',
+      'raw (translation required)': 'raw',
+      'nahradi\x9d': 'replace',
+      'unicode': 'unicode',
+      'dátum': 'date',
+      'class (translation required)': 'class',
+      'role (translation required)': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'obsah': 'contents',
+      '\xe8as\x9d': 'sectnum',
+      '\xe8as\x9d-\xe8\xedslovanie': 'sectnum',
+      'cie\xbeov\xe9-pozn\xe1mky': 'target-notes',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'footnotes': 'footnotes',
+      # 'citations': 'citations',
+      }
+"""Slovak name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+      'abbreviation (translation required)': 'abbreviation',
+      'acronym (translation required)': 'acronym',
+      'code (translation required)': 'code',
+      'index (translation required)': 'index',
+      'subscript (translation required)': 'subscript',
+      'superscript (translation required)': 'superscript',
+      'title-reference (translation required)': 'title-reference',
+      'pep-reference (translation required)': 'pep-reference',
+      'rfc-reference (translation required)': 'rfc-reference',
+      'emphasis (translation required)': 'emphasis',
+      'strong (translation required)': 'strong',
+      'literal (translation required)': 'literal',
+      'math (translation required)': 'math',
+      'named-reference (translation required)': 'named-reference',
+      'anonymous-reference (translation required)': 'anonymous-reference',
+      'footnote-reference (translation required)': 'footnote-reference',
+      'citation-reference (translation required)': 'citation-reference',
+      'substitution-reference (translation required)': 'substitution-reference',  # noqa:E501
+      'target (translation required)': 'target',
+      'uri-reference (translation required)': 'uri-reference',
+      'raw (translation required)': 'raw',
+      }
+"""Mapping of Slovak role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/sv.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/sv.py
new file mode 100644
index 00000000..e6b11aea
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/sv.py
@@ -0,0 +1,96 @@
+# $Id: sv.py 9030 2022-03-05 23:28:32Z milde $
+# Author: Adam Chodorowski <chodorowski@users.sourceforge.net>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Swedish language mappings for language-dependent features of reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+directives = {
+      'observera': 'attention',
+      'akta': 'caution',  # also 'försiktigt'
+      'kod': 'code',
+      'fara': 'danger',
+      'fel': 'error',
+      'vink': 'hint',  # also 'hint'
+      'viktigt': 'important',
+      'notera': 'note',
+      'tips': 'tip',
+      'varning': 'warning',
+      'anmärkning': 'admonition',  # literal 'tillrättavisning', 'förmaning'
+      'sidorad': 'sidebar',
+      'ämne': 'topic',
+      'tema': 'topic',
+      'rad-block': 'line-block',
+      # 'tolkad-bokstavlig'?
+      'parsed-literal (translation required)': 'parsed-literal',
+      'rubrik': 'rubric',
+      'epigraf': 'epigraph',
+      'höjdpunkter': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      'sammansatt': 'compound',
+      'container': 'container',
+      # 'frågor': 'questions',
+      # NOTE: A bit long, but recommended by http://www.nada.kth.se/dataterm/:
+      # 'frågor-och-svar': 'questions',
+      # 'vanliga-frågor': 'questions',
+      'tabell': 'table',
+      'csv-tabell': 'csv-table',
+      'list-tabell': 'list-table',
+      'meta': 'meta',
+      'matematik': 'math',
+      # 'bildkarta': 'imagemap',  # FIXME: Translation might be too literal.
+      'bild': 'image',
+      'figur': 'figure',
+      'inkludera': 'include',
+      'rå': 'raw',
+      'ersätta': 'replace',
+      'unicode': 'unicode',
+      'datum': 'date',
+      'klass': 'class',
+      'roll': 'role',
+      'standardroll': 'default-role',
+      'titel': 'title',
+      'innehåll': 'contents',
+      'sektionsnumrering': 'sectnum',
+      'target-notes (translation required)': 'target-notes',
+      'sidhuvud': 'header',
+      'sidfot': 'footer',
+      # 'fotnoter': 'footnotes',
+      # 'citeringar': 'citations',
+      }
+"""Swedish name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+      'förkortning': 'abbreviation',
+      'akronym': 'acronym',
+      'kod': 'code',
+      'index': 'index',
+      'nedsänkt': 'subscript',
+      'upphöjd': 'superscript',
+      'titel-referens': 'title-reference',
+      'pep-referens': 'pep-reference',
+      'rfc-referens': 'rfc-reference',
+      'betoning': 'emphasis',
+      'stark': 'strong',
+      'bokstavlig': 'literal',  # also 'ordagranna'
+      'matematik': 'math',
+      'namngiven-referens': 'named-reference',
+      'anonym-referens': 'anonymous-reference',
+      'fotnot-referens': 'footnote-reference',
+      'citat-referens': 'citation-reference',
+      'ersättnings-referens': 'substitution-reference',
+      'mål': 'target',
+      'uri-referens': 'uri-reference',
+      'rå': 'raw',
+      }
+"""Mapping of Swedish role names to canonical role names for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/uk.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/uk.py
new file mode 100644
index 00000000..9e74dc32
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/uk.py
@@ -0,0 +1,91 @@
+# $Id: uk.py 9114 2022-07-28 17:06:10Z milde $
+# Author: Dmytro Kazanzhy <dkazanzhy@gmail.com>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <http://docutils.sf.net/docs/howto/i18n.html>.  Two files must be
+# translated for each language: one in docutils/languages, the other in
+# docutils/parsers/rst/languages.
+
+"""
+Ukrainian-language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+directives = {
+    'блок-строк': 'line-block',
+    'мета': 'meta',
+    'математика': 'math',
+    'оброблений-літерал': 'parsed-literal',
+    'виділена-цитата': 'pull-quote',
+    'код': 'code',
+    'складений абзац': 'compound',
+    'контейнер': 'container',
+    'таблиця': 'table',
+    'таблиця-csv': 'csv-table',
+    'таблиця-списків': 'list-table',
+    'сирий': 'raw',
+    'заміна': 'replace',
+    'тестова-директива-restructuredtext': 'restructuredtext-test-directive',
+    'цільові-виноски': 'target-notes',
+    'юнікод': 'unicode',
+    'дата': 'date',
+    'бічна-панель': 'sidebar',
+    'важливо': 'important',
+    'включати': 'include',
+    'увага': 'attention',
+    'виділення': 'highlights',
+    'зауваження': 'admonition',
+    'зображення': 'image',
+    'клас': 'class',
+    'роль': 'role',
+    'роль-за-замовчуванням': 'default-role',
+    'заголовок': 'title',
+    'номер-розділу': 'sectnum',
+    'нумерація-розділів': 'sectnum',
+    'небезпечно': 'danger',
+    'обережно': 'caution',
+    'помилка': 'error',
+    'підказка': 'tip',
+    'попередження': 'warning',
+    'примітка': 'note',
+    'малюнок': 'figure',
+    'рубрика': 'rubric',
+    'порада': 'hint',
+    'зміст': 'contents',
+    'тема': 'topic',
+    'епіграф': 'epigraph',
+    'верхній колонтитул': 'header',
+    'нижній колонтитул': 'footer',
+    }
+"""Ukrainian name to registered (in directives/__init__.py) directive name
+mapping."""
+
+roles = {
+    'акронім': 'acronym',
+    'код': 'code',
+    'анонімне-посилання': 'anonymous-reference',
+    'буквально': 'literal',
+    'математика': 'math',
+    'верхній-індекс': 'superscript',
+    'наголос': 'emphasis',
+    'іменоване-посилання': 'named-reference',
+    'індекс': 'index',
+    'нижній-індекс': 'subscript',
+    'жирне-накреслення': 'strong',
+    'скорочення': 'abbreviation',
+    'посилання-заміна': 'substitution-reference',
+    'посилання-на-pep': 'pep-reference',
+    'посилання-на-rfc': 'rfc-reference',
+    'посилання-на-uri': 'uri-reference',
+    'посилання-на-заголовок': 'title-reference',
+    'посилання-на-зноску': 'footnote-reference',
+    'посилання-на-цитату': 'citation-reference',
+    'ціль': 'target',
+    'сирий': 'raw',
+    }
+"""Mapping of Ukrainian role names to canonical role names
+for interpreted text.
+"""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/zh_cn.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/zh_cn.py
new file mode 100644
index 00000000..fbb6fd8c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/zh_cn.py
@@ -0,0 +1,104 @@
+# $Id: zh_cn.py 9030 2022-03-05 23:28:32Z milde $
+# Author: Panjunyong <panjy@zopechina.com>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Simplified Chinese language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      '注意': 'attention',
+      '小心': 'caution',
+      'code (translation required)': 'code',
+      '危险': 'danger',
+      '错误': 'error',
+      '提示': 'hint',
+      '重要': 'important',
+      '注解': 'note',
+      '技巧': 'tip',
+      '警告': 'warning',
+      '忠告': 'admonition',
+      '侧框': 'sidebar',
+      '主题': 'topic',
+      'line-block (translation required)': 'line-block',
+      'parsed-literal (translation required)': 'parsed-literal',
+      '醒目': 'rubric',
+      '铭文': 'epigraph',
+      '要点': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      '复合': 'compound',
+      '容器': 'container',
+      # 'questions (translation required)': 'questions',
+      '表格': 'table',
+      'csv表格': 'csv-table',
+      '列表表格': 'list-table',
+      # 'qa (translation required)': 'questions',
+      # 'faq (translation required)': 'questions',
+      '元数据': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap (translation required)': 'imagemap',
+      '图片': 'image',
+      '图例': 'figure',
+      '包含': 'include',
+      '原文': 'raw',
+      '代替': 'replace',
+      '统一码': 'unicode',
+      '日期': 'date',
+      '类型': 'class',
+      '角色': 'role',
+      '默认角色': 'default-role',
+      '标题': 'title',
+      '目录': 'contents',
+      '章节序号': 'sectnum',
+      '题头': 'header',
+      '页脚': 'footer',
+      # 'footnotes (translation required)': 'footnotes',
+      # 'citations (translation required)': 'citations',
+      'target-notes (translation required)': 'target-notes',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Simplified Chinese name to registered (in directives/__init__.py)
+directive name mapping."""
+
+roles = {
+    # language-dependent: fixed
+    '缩写': 'abbreviation',
+    '简称': 'acronym',
+    'code (translation required)': 'code',
+    'index (translation required)': 'index',
+    'i (translation required)': 'index',
+    '下标': 'subscript',
+    '上标': 'superscript',
+    'title-reference (translation required)': 'title-reference',
+    'title (translation required)': 'title-reference',
+    't (translation required)': 'title-reference',
+    'pep-reference (translation required)': 'pep-reference',
+    'pep (translation required)': 'pep-reference',
+    'rfc-reference (translation required)': 'rfc-reference',
+    'rfc (translation required)': 'rfc-reference',
+    '强调': 'emphasis',
+    '加粗': 'strong',
+    '字面': 'literal',
+    'math (translation required)': 'math',
+    'named-reference (translation required)': 'named-reference',
+    'anonymous-reference (translation required)': 'anonymous-reference',
+    'footnote-reference (translation required)': 'footnote-reference',
+    'citation-reference (translation required)': 'citation-reference',
+    'substitution-reference (translation required)': 'substitution-reference',
+    'target (translation required)': 'target',
+    'uri-reference (translation required)': 'uri-reference',
+    'uri (translation required)': 'uri-reference',
+    'url (translation required)': 'uri-reference',
+    'raw (translation required)': 'raw',
+    }
+"""Mapping of Simplified Chinese role names to canonical role names
+for interpreted text."""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/zh_tw.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/zh_tw.py
new file mode 100644
index 00000000..126255d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/languages/zh_tw.py
@@ -0,0 +1,109 @@
+# $Id: zh_tw.py 9030 2022-03-05 23:28:32Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+# New language mappings are welcome.  Before doing a new translation, please
+# read <https://docutils.sourceforge.io/docs/howto/i18n.html>.
+# Two files must be translated for each language: one in docutils/languages,
+# the other in docutils/parsers/rst/languages.
+
+"""
+Traditional Chinese language mappings for language-dependent features of
+reStructuredText.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+directives = {
+      # language-dependent: fixed
+      'attention (translation required)': 'attention',
+      'caution (translation required)': 'caution',
+      'code (translation required)': 'code',
+      'danger (translation required)': 'danger',
+      'error (translation required)': 'error',
+      'hint (translation required)': 'hint',
+      'important (translation required)': 'important',
+      'note (translation required)': 'note',
+      'tip (translation required)': 'tip',
+      'warning (translation required)': 'warning',
+      'admonition (translation required)': 'admonition',
+      'sidebar (translation required)': 'sidebar',
+      'topic (translation required)': 'topic',
+      'line-block (translation required)': 'line-block',
+      'parsed-literal (translation required)': 'parsed-literal',
+      'rubric (translation required)': 'rubric',
+      'epigraph (translation required)': 'epigraph',
+      'highlights (translation required)': 'highlights',
+      'pull-quote (translation required)': 'pull-quote',
+      'compound (translation required)': 'compound',
+      'container (translation required)': 'container',
+      # 'questions (translation required)': 'questions',
+      'table (translation required)': 'table',
+      'csv-table (translation required)': 'csv-table',
+      'list-table (translation required)': 'list-table',
+      # 'qa (translation required)': 'questions',
+      # 'faq (translation required)': 'questions',
+      'meta (translation required)': 'meta',
+      'math (translation required)': 'math',
+      # 'imagemap (translation required)': 'imagemap',
+      'image (translation required)': 'image',
+      'figure (translation required)': 'figure',
+      'include (translation required)': 'include',
+      'raw (translation required)': 'raw',
+      'replace (translation required)': 'replace',
+      'unicode (translation required)': 'unicode',
+      '日期': 'date',
+      'class (translation required)': 'class',
+      'role (translation required)': 'role',
+      'default-role (translation required)': 'default-role',
+      'title (translation required)': 'title',
+      'contents (translation required)': 'contents',
+      'sectnum (translation required)': 'sectnum',
+      'section-numbering (translation required)': 'sectnum',
+      'header (translation required)': 'header',
+      'footer (translation required)': 'footer',
+      # 'footnotes (translation required)': 'footnotes',
+      # 'citations (translation required)': 'citations',
+      'target-notes (translation required)': 'target-notes',
+      'restructuredtext-test-directive': 'restructuredtext-test-directive'}
+"""Traditional Chinese name to registered (in directives/__init__.py)
+directive name mapping."""
+
+roles = {
+    # language-dependent: fixed
+    'abbreviation (translation required)': 'abbreviation',
+    'ab (translation required)': 'abbreviation',
+    'acronym (translation required)': 'acronym',
+    'ac (translation required)': 'acronym',
+    'code (translation required)': 'code',
+    'index (translation required)': 'index',
+    'i (translation required)': 'index',
+    'subscript (translation required)': 'subscript',
+    'sub (translation required)': 'subscript',
+    'superscript (translation required)': 'superscript',
+    'sup (translation required)': 'superscript',
+    'title-reference (translation required)': 'title-reference',
+    'title (translation required)': 'title-reference',
+    't (translation required)': 'title-reference',
+    'pep-reference (translation required)': 'pep-reference',
+    'pep (translation required)': 'pep-reference',
+    'rfc-reference (translation required)': 'rfc-reference',
+    'rfc (translation required)': 'rfc-reference',
+    'emphasis (translation required)': 'emphasis',
+    'strong (translation required)': 'strong',
+    'literal (translation required)': 'literal',
+    'math (translation required)': 'math',
+    'named-reference (translation required)': 'named-reference',
+    'anonymous-reference (translation required)': 'anonymous-reference',
+    'footnote-reference (translation required)': 'footnote-reference',
+    'citation-reference (translation required)': 'citation-reference',
+    'substitution-reference (translation required)': 'substitution-reference',
+    'target (translation required)': 'target',
+    'uri-reference (translation required)': 'uri-reference',
+    'uri (translation required)': 'uri-reference',
+    'url (translation required)': 'uri-reference',
+    'raw (translation required)': 'raw',
+    }
+"""Mapping of Traditional Chinese role names to canonical role names for
+interpreted text."""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/roles.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/roles.py
new file mode 100644
index 00000000..657a86ef
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/roles.py
@@ -0,0 +1,439 @@
+# $Id: roles.py 9037 2022-03-05 23:31:10Z milde $
+# Author: Edward Loper <edloper@gradient.cis.upenn.edu>
+# Copyright: This module has been placed in the public domain.
+
+"""
+This module defines standard interpreted text role functions, a registry for
+interpreted text roles, and an API for adding to and retrieving from the
+registry. See also `Creating reStructuredText Interpreted Text Roles`__.
+
+__ https://docutils.sourceforge.io/docs/ref/rst/roles.html
+
+
+The interface for interpreted role functions is as follows::
+
+    def role_fn(name, rawtext, text, lineno, inliner,
+                options=None, content=None):
+        code...
+
+    # Set function attributes for customization:
+    role_fn.options = ...
+    role_fn.content = ...
+
+Parameters:
+
+- ``name`` is the local name of the interpreted text role, the role name
+  actually used in the document.
+
+- ``rawtext`` is a string containing the entire interpreted text construct.
+  Return it as a ``problematic`` node linked to a system message if there is a
+  problem.
+
+- ``text`` is the interpreted text content, with backslash escapes converted
+  to nulls (``\x00``).
+
+- ``lineno`` is the line number where the text block containing the
+  interpreted text begins.
+
+- ``inliner`` is the Inliner object that called the role function.
+  It defines the following useful attributes: ``reporter``,
+  ``problematic``, ``memo``, ``parent``, ``document``.
+
+- ``options``: A dictionary of directive options for customization, to be
+  interpreted by the role function.  Used for additional attributes for the
+  generated elements and other functionality.
+
+- ``content``: A list of strings, the directive content for customization
+  ("role" directive).  To be interpreted by the role function.
+
+Function attributes for customization, interpreted by the "role" directive:
+
+- ``options``: A dictionary, mapping known option names to conversion
+  functions such as `int` or `float`.  ``None`` or an empty dict implies no
+  options to parse.  Several directive option conversion functions are defined
+  in the `directives` module.
+
+  All role functions implicitly support the "class" option, unless disabled
+  with an explicit ``{'class': None}``.
+
+- ``content``: A boolean; true if content is allowed.  Client code must handle
+  the case where content is required but not supplied (an empty content list
+  will be supplied).
+
+Note that unlike directives, the "arguments" function attribute is not
+supported for role customization.  Directive arguments are handled by the
+"role" directive itself.
+
+Interpreted role functions return a tuple of two values:
+
+- A list of nodes which will be inserted into the document tree at the
+  point where the interpreted role was encountered (can be an empty
+  list).
+
+- A list of system messages, which will be inserted into the document tree
+  immediately after the end of the current inline block (can also be empty).
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+from docutils import nodes
+from docutils.parsers.rst import directives
+from docutils.parsers.rst.languages import en as _fallback_language_module
+from docutils.utils.code_analyzer import Lexer, LexerError
+
+DEFAULT_INTERPRETED_ROLE = 'title-reference'
+"""The canonical name of the default interpreted role.
+
+This role is used when no role is specified for a piece of interpreted text.
+"""
+
+_role_registry = {}
+"""Mapping of canonical role names to role functions.
+
+Language-dependent role names are defined in the ``language`` subpackage.
+"""
+
+_roles = {}
+"""Mapping of local or language-dependent interpreted text role names to role
+functions."""
+
+
+def role(role_name, language_module, lineno, reporter):
+    """
+    Locate and return a role function from its language-dependent name, along
+    with a list of system messages.
+
+    If the role is not found in the current language, check English. Return a
+    2-tuple: role function (``None`` if the named role cannot be found) and a
+    list of system messages.
+    """
+    normname = role_name.lower()
+    messages = []
+    msg_text = []
+
+    if normname in _roles:
+        return _roles[normname], messages
+
+    if role_name:
+        canonicalname = None
+        try:
+            canonicalname = language_module.roles[normname]
+        except AttributeError as error:
+            msg_text.append('Problem retrieving role entry from language '
+                            'module %r: %s.' % (language_module, error))
+        except KeyError:
+            msg_text.append('No role entry for "%s" in module "%s".'
+                            % (role_name, language_module.__name__))
+    else:
+        canonicalname = DEFAULT_INTERPRETED_ROLE
+
+    # If we didn't find it, try English as a fallback.
+    if not canonicalname:
+        try:
+            canonicalname = _fallback_language_module.roles[normname]
+            msg_text.append('Using English fallback for role "%s".'
+                            % role_name)
+        except KeyError:
+            msg_text.append('Trying "%s" as canonical role name.'
+                            % role_name)
+            # The canonical name should be an English name, but just in case:
+            canonicalname = normname
+
+    # Collect any messages that we generated.
+    if msg_text:
+        message = reporter.info('\n'.join(msg_text), line=lineno)
+        messages.append(message)
+
+    # Look the role up in the registry, and return it.
+    if canonicalname in _role_registry:
+        role_fn = _role_registry[canonicalname]
+        register_local_role(normname, role_fn)
+        return role_fn, messages
+    return None, messages  # Error message will be generated by caller.
+
+
+def register_canonical_role(name, role_fn):
+    """
+    Register an interpreted text role by its canonical name.
+
+    :Parameters:
+      - `name`: The canonical name of the interpreted role.
+      - `role_fn`: The role function.  See the module docstring.
+    """
+    set_implicit_options(role_fn)
+    _role_registry[name.lower()] = role_fn
+
+
+def register_local_role(name, role_fn):
+    """
+    Register an interpreted text role by its local or language-dependent name.
+
+    :Parameters:
+      - `name`: The local or language-dependent name of the interpreted role.
+      - `role_fn`: The role function.  See the module docstring.
+    """
+    set_implicit_options(role_fn)
+    _roles[name.lower()] = role_fn
+
+
+def set_implicit_options(role_fn):
+    """
+    Add customization options to role functions, unless explicitly set or
+    disabled.
+    """
+    if not hasattr(role_fn, 'options') or role_fn.options is None:
+        role_fn.options = {'class': directives.class_option}
+    elif 'class' not in role_fn.options:
+        role_fn.options['class'] = directives.class_option
+
+
+def register_generic_role(canonical_name, node_class):
+    """For roles which simply wrap a given `node_class` around the text."""
+    role = GenericRole(canonical_name, node_class)
+    register_canonical_role(canonical_name, role)
+
+
+class GenericRole:
+    """
+    Generic interpreted text role.
+
+    The interpreted text is simply wrapped with the provided node class.
+    """
+
+    def __init__(self, role_name, node_class):
+        self.name = role_name
+        self.node_class = node_class
+
+    def __call__(self, role, rawtext, text, lineno, inliner,
+                 options=None, content=None):
+        options = normalized_role_options(options)
+        return [self.node_class(rawtext, text, **options)], []
+
+
+class CustomRole:
+    """Wrapper for custom interpreted text roles."""
+
+    def __init__(self, role_name, base_role, options=None, content=None):
+        self.name = role_name
+        self.base_role = base_role
+        self.options = getattr(base_role, 'options', None)
+        self.content = getattr(base_role, 'content', None)
+        self.supplied_options = options
+        self.supplied_content = content
+
+    def __call__(self, role, rawtext, text, lineno, inliner,
+                 options=None, content=None):
+        opts = normalized_role_options(self.supplied_options)
+        try:
+            opts.update(options)
+        except TypeError:  # options may be ``None``
+            pass
+        # pass concatenation of content from instance and call argument:
+        supplied_content = self.supplied_content or []
+        content = content or []
+        delimiter = ['\n'] if supplied_content and content else []
+        return self.base_role(role, rawtext, text, lineno, inliner,
+                              options=opts,
+                              content=supplied_content+delimiter+content)
+
+
+def generic_custom_role(role, rawtext, text, lineno, inliner,
+                        options=None, content=None):
+    """Base for custom roles if no other base role is specified."""
+    # Once nested inline markup is implemented, this and other methods should
+    # recursively call inliner.nested_parse().
+    options = normalized_role_options(options)
+    return [nodes.inline(rawtext, text, **options)], []
+
+
+generic_custom_role.options = {'class': directives.class_option}
+
+
+######################################################################
+# Define and register the standard roles:
+######################################################################
+
+register_generic_role('abbreviation', nodes.abbreviation)
+register_generic_role('acronym', nodes.acronym)
+register_generic_role('emphasis', nodes.emphasis)
+register_generic_role('literal', nodes.literal)
+register_generic_role('strong', nodes.strong)
+register_generic_role('subscript', nodes.subscript)
+register_generic_role('superscript', nodes.superscript)
+register_generic_role('title-reference', nodes.title_reference)
+
+
+def pep_reference_role(role, rawtext, text, lineno, inliner,
+                       options=None, content=None):
+    options = normalized_role_options(options)
+    try:
+        pepnum = int(nodes.unescape(text))
+        if pepnum < 0 or pepnum > 9999:
+            raise ValueError
+    except ValueError:
+        msg = inliner.reporter.error(
+            'PEP number must be a number from 0 to 9999; "%s" is invalid.'
+            % text, line=lineno)
+        prb = inliner.problematic(rawtext, rawtext, msg)
+        return [prb], [msg]
+    # Base URL mainly used by inliner.pep_reference; so this is correct:
+    ref = (inliner.document.settings.pep_base_url
+           + inliner.document.settings.pep_file_url_template % pepnum)
+    return [nodes.reference(rawtext, 'PEP ' + text, refuri=ref, **options)], []
+
+
+register_canonical_role('pep-reference', pep_reference_role)
+
+
+def rfc_reference_role(role, rawtext, text, lineno, inliner,
+                       options=None, content=None):
+    options = normalized_role_options(options)
+    if "#" in text:
+        rfcnum, section = nodes.unescape(text).split("#", 1)
+    else:
+        rfcnum, section = nodes.unescape(text), None
+    try:
+        rfcnum = int(rfcnum)
+        if rfcnum < 1:
+            raise ValueError
+    except ValueError:
+        msg = inliner.reporter.error(
+            'RFC number must be a number greater than or equal to 1; '
+            '"%s" is invalid.' % text, line=lineno)
+        prb = inliner.problematic(rawtext, rawtext, msg)
+        return [prb], [msg]
+    # Base URL mainly used by inliner.rfc_reference, so this is correct:
+    ref = inliner.document.settings.rfc_base_url + inliner.rfc_url % rfcnum
+    if section is not None:
+        ref += "#" + section
+    node = nodes.reference(rawtext, 'RFC '+str(rfcnum), refuri=ref, **options)
+    return [node], []
+
+
+register_canonical_role('rfc-reference', rfc_reference_role)
+
+
+def raw_role(role, rawtext, text, lineno, inliner, options=None, content=None):
+    options = normalized_role_options(options)
+    if not inliner.document.settings.raw_enabled:
+        msg = inliner.reporter.warning('raw (and derived) roles disabled')
+        prb = inliner.problematic(rawtext, rawtext, msg)
+        return [prb], [msg]
+    if 'format' not in options:
+        msg = inliner.reporter.error(
+            'No format (Writer name) is associated with this role: "%s".\n'
+            'The "raw" role cannot be used directly.\n'
+            'Instead, use the "role" directive to create a new role with '
+            'an associated format.' % role, line=lineno)
+        prb = inliner.problematic(rawtext, rawtext, msg)
+        return [prb], [msg]
+    node = nodes.raw(rawtext, nodes.unescape(text, True), **options)
+    node.source, node.line = inliner.reporter.get_source_and_line(lineno)
+    return [node], []
+
+
+raw_role.options = {'format': directives.unchanged}
+
+register_canonical_role('raw', raw_role)
+
+
+def code_role(role, rawtext, text, lineno, inliner,
+              options=None, content=None):
+    options = normalized_role_options(options)
+    language = options.get('language', '')
+    classes = ['code']
+    if 'classes' in options:
+        classes.extend(options['classes'])
+    if language and language not in classes:
+        classes.append(language)
+    try:
+        tokens = Lexer(nodes.unescape(text, True), language,
+                       inliner.document.settings.syntax_highlight)
+    except LexerError as error:
+        msg = inliner.reporter.warning(error)
+        prb = inliner.problematic(rawtext, rawtext, msg)
+        return [prb], [msg]
+
+    node = nodes.literal(rawtext, '', classes=classes)
+
+    # analyse content and add nodes for every token
+    for classes, value in tokens:
+        if classes:
+            node += nodes.inline(value, value, classes=classes)
+        else:
+            # insert as Text to decrease the verbosity of the output
+            node += nodes.Text(value)
+
+    return [node], []
+
+
+code_role.options = {'language': directives.unchanged}
+
+register_canonical_role('code', code_role)
+
+
+def math_role(role, rawtext, text, lineno, inliner,
+              options=None, content=None):
+    options = normalized_role_options(options)
+    text = nodes.unescape(text, True)  # raw text without inline role markup
+    node = nodes.math(rawtext, text, **options)
+    return [node], []
+
+
+register_canonical_role('math', math_role)
+
+
+######################################################################
+# Register roles that are currently unimplemented.
+######################################################################
+
+def unimplemented_role(role, rawtext, text, lineno, inliner,
+                       options=None, content=None):
+    msg = inliner.reporter.error(
+        'Interpreted text role "%s" not implemented.' % role, line=lineno)
+    prb = inliner.problematic(rawtext, rawtext, msg)
+    return [prb], [msg]
+
+
+register_canonical_role('index', unimplemented_role)
+register_canonical_role('named-reference', unimplemented_role)
+register_canonical_role('anonymous-reference', unimplemented_role)
+register_canonical_role('uri-reference', unimplemented_role)
+register_canonical_role('footnote-reference', unimplemented_role)
+register_canonical_role('citation-reference', unimplemented_role)
+register_canonical_role('substitution-reference', unimplemented_role)
+register_canonical_role('target', unimplemented_role)
+
+# This should remain unimplemented, for testing purposes:
+register_canonical_role('restructuredtext-unimplemented-role',
+                        unimplemented_role)
+
+
+def set_classes(options):
+    """Deprecated. Obsoleted by ``normalized_role_options()``."""
+    # TODO: Change use in directives.py and uncomment.
+    # warnings.warn('The auxiliary function roles.set_classes() is obsoleted'
+    #     ' by roles.normalized_role_options() and will be removed'
+    #     ' in Docutils 0.21 or later', DeprecationWarning, stacklevel=2)
+    if options and 'class' in options:
+        assert 'classes' not in options
+        options['classes'] = options['class']
+        del options['class']
+
+
+def normalized_role_options(options):
+    """
+    Return normalized dictionary of role options.
+
+    * ``None`` is replaced by an empty dictionary.
+    * The key 'class' is renamed to 'classes'.
+    """
+    if options is None:
+        return {}
+    result = options.copy()
+    if 'class' in result:
+        assert 'classes' not in result
+        result['classes'] = result['class']
+        del result['class']
+    return result
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/states.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/states.py
new file mode 100644
index 00000000..e2b25c7c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/states.py
@@ -0,0 +1,3145 @@
+# $Id: states.py 9500 2023-12-14 22:38:49Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+This is the ``docutils.parsers.rst.states`` module, the core of
+the reStructuredText parser.  It defines the following:
+
+:Classes:
+    - `RSTStateMachine`: reStructuredText parser's entry point.
+    - `NestedStateMachine`: recursive StateMachine.
+    - `RSTState`: reStructuredText State superclass.
+    - `Inliner`: For parsing inline markup.
+    - `Body`: Generic classifier of the first line of a block.
+    - `SpecializedBody`: Superclass for compound element members.
+    - `BulletList`: Second and subsequent bullet_list list_items
+    - `DefinitionList`: Second+ definition_list_items.
+    - `EnumeratedList`: Second+ enumerated_list list_items.
+    - `FieldList`: Second+ fields.
+    - `OptionList`: Second+ option_list_items.
+    - `RFC2822List`: Second+ RFC2822-style fields.
+    - `ExtensionOptions`: Parses directive option fields.
+    - `Explicit`: Second+ explicit markup constructs.
+    - `SubstitutionDef`: For embedded directives in substitution definitions.
+    - `Text`: Classifier of second line of a text block.
+    - `SpecializedText`: Superclass for continuation lines of Text-variants.
+    - `Definition`: Second line of potential definition_list_item.
+    - `Line`: Second line of overlined section title or transition marker.
+    - `Struct`: An auxiliary collection class.
+
+:Exception classes:
+    - `MarkupError`
+    - `ParserError`
+    - `MarkupMismatch`
+
+:Functions:
+    - `escape2null()`: Return a string, escape-backslashes converted to nulls.
+    - `unescape()`: Return a string, nulls removed or restored to backslashes.
+
+:Attributes:
+    - `state_classes`: set of State classes used with `RSTStateMachine`.
+
+Parser Overview
+===============
+
+The reStructuredText parser is implemented as a recursive state machine,
+examining its input one line at a time.  To understand how the parser works,
+please first become familiar with the `docutils.statemachine` module.  In the
+description below, references are made to classes defined in this module;
+please see the individual classes for details.
+
+Parsing proceeds as follows:
+
+1. The state machine examines each line of input, checking each of the
+   transition patterns of the state `Body`, in order, looking for a match.
+   The implicit transitions (blank lines and indentation) are checked before
+   any others.  The 'text' transition is a catch-all (matches anything).
+
+2. The method associated with the matched transition pattern is called.
+
+   A. Some transition methods are self-contained, appending elements to the
+      document tree (`Body.doctest` parses a doctest block).  The parser's
+      current line index is advanced to the end of the element, and parsing
+      continues with step 1.
+
+   B. Other transition methods trigger the creation of a nested state machine,
+      whose job is to parse a compound construct ('indent' does a block quote,
+      'bullet' does a bullet list, 'overline' does a section [first checking
+      for a valid section header], etc.).
+
+      - In the case of lists and explicit markup, a one-off state machine is
+        created and run to parse contents of the first item.
+
+      - A new state machine is created and its initial state is set to the
+        appropriate specialized state (`BulletList` in the case of the
+        'bullet' transition; see `SpecializedBody` for more detail).  This
+        state machine is run to parse the compound element (or series of
+        explicit markup elements), and returns as soon as a non-member element
+        is encountered.  For example, the `BulletList` state machine ends as
+        soon as it encounters an element which is not a list item of that
+        bullet list.  The optional omission of inter-element blank lines is
+        enabled by this nested state machine.
+
+      - The current line index is advanced to the end of the elements parsed,
+        and parsing continues with step 1.
+
+   C. The result of the 'text' transition depends on the next line of text.
+      The current state is changed to `Text`, under which the second line is
+      examined.  If the second line is:
+
+      - Indented: The element is a definition list item, and parsing proceeds
+        similarly to step 2.B, using the `DefinitionList` state.
+
+      - A line of uniform punctuation characters: The element is a section
+        header; again, parsing proceeds as in step 2.B, and `Body` is still
+        used.
+
+      - Anything else: The element is a paragraph, which is examined for
+        inline markup and appended to the parent element.  Processing
+        continues with step 1.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+import re
+from types import FunctionType, MethodType
+
+from docutils import nodes, statemachine, utils
+from docutils import ApplicationError, DataError
+from docutils.statemachine import StateMachineWS, StateWS
+from docutils.nodes import fully_normalize_name as normalize_name
+from docutils.nodes import unescape, whitespace_normalize_name
+import docutils.parsers.rst
+from docutils.parsers.rst import directives, languages, tableparser, roles
+from docutils.utils import escape2null, column_width
+from docutils.utils import punctuation_chars, roman, urischemes
+from docutils.utils import split_escaped_whitespace
+
+
+class MarkupError(DataError): pass
+class UnknownInterpretedRoleError(DataError): pass
+class InterpretedRoleNotImplementedError(DataError): pass
+class ParserError(ApplicationError): pass
+class MarkupMismatch(Exception): pass
+
+
+class Struct:
+
+    """Stores data attributes for dotted-attribute access."""
+
+    def __init__(self, **keywordargs):
+        self.__dict__.update(keywordargs)
+
+
+class RSTStateMachine(StateMachineWS):
+
+    """
+    reStructuredText's master StateMachine.
+
+    The entry point to reStructuredText parsing is the `run()` method.
+    """
+
+    def run(self, input_lines, document, input_offset=0, match_titles=True,
+            inliner=None):
+        """
+        Parse `input_lines` and modify the `document` node in place.
+
+        Extend `StateMachineWS.run()`: set up parse-global data and
+        run the StateMachine.
+        """
+        self.language = languages.get_language(
+            document.settings.language_code, document.reporter)
+        self.match_titles = match_titles
+        if inliner is None:
+            inliner = Inliner()
+        inliner.init_customizations(document.settings)
+        self.memo = Struct(document=document,
+                           reporter=document.reporter,
+                           language=self.language,
+                           title_styles=[],
+                           section_level=0,
+                           section_bubble_up_kludge=False,
+                           inliner=inliner)
+        self.document = document
+        self.attach_observer(document.note_source)
+        self.reporter = self.memo.reporter
+        self.node = document
+        results = StateMachineWS.run(self, input_lines, input_offset,
+                                     input_source=document['source'])
+        assert results == [], 'RSTStateMachine.run() results should be empty!'
+        self.node = self.memo = None    # remove unneeded references
+
+
+class NestedStateMachine(StateMachineWS):
+
+    """
+    StateMachine run from within other StateMachine runs, to parse nested
+    document structures.
+    """
+
+    def run(self, input_lines, input_offset, memo, node, match_titles=True):
+        """
+        Parse `input_lines` and populate a `docutils.nodes.document` instance.
+
+        Extend `StateMachineWS.run()`: set up document-wide data.
+        """
+        self.match_titles = match_titles
+        self.memo = memo
+        self.document = memo.document
+        self.attach_observer(self.document.note_source)
+        self.reporter = memo.reporter
+        self.language = memo.language
+        self.node = node
+        results = StateMachineWS.run(self, input_lines, input_offset)
+        assert results == [], ('NestedStateMachine.run() results should be '
+                               'empty!')
+        return results
+
+
+class RSTState(StateWS):
+
+    """
+    reStructuredText State superclass.
+
+    Contains methods used by all State subclasses.
+    """
+
+    nested_sm = NestedStateMachine
+    nested_sm_cache = []
+
+    def __init__(self, state_machine, debug=False):
+        self.nested_sm_kwargs = {'state_classes': state_classes,
+                                 'initial_state': 'Body'}
+        StateWS.__init__(self, state_machine, debug)
+
+    def runtime_init(self):
+        StateWS.runtime_init(self)
+        memo = self.state_machine.memo
+        self.memo = memo
+        self.reporter = memo.reporter
+        self.inliner = memo.inliner
+        self.document = memo.document
+        self.parent = self.state_machine.node
+        # enable the reporter to determine source and source-line
+        if not hasattr(self.reporter, 'get_source_and_line'):
+            self.reporter.get_source_and_line = self.state_machine.get_source_and_line  # noqa:E501
+
+    def goto_line(self, abs_line_offset):
+        """
+        Jump to input line `abs_line_offset`, ignoring jumps past the end.
+        """
+        try:
+            self.state_machine.goto_line(abs_line_offset)
+        except EOFError:
+            pass
+
+    def no_match(self, context, transitions):
+        """
+        Override `StateWS.no_match` to generate a system message.
+
+        This code should never be run.
+        """
+        self.reporter.severe(
+            'Internal error: no transition pattern match.  State: "%s"; '
+            'transitions: %s; context: %s; current line: %r.'
+            % (self.__class__.__name__, transitions, context,
+               self.state_machine.line))
+        return context, None, []
+
+    def bof(self, context):
+        """Called at beginning of file."""
+        return [], []
+
+    def nested_parse(self, block, input_offset, node, match_titles=False,
+                     state_machine_class=None, state_machine_kwargs=None):
+        """
+        Create a new StateMachine rooted at `node` and run it over the input
+        `block`.
+        """
+        use_default = 0
+        if state_machine_class is None:
+            state_machine_class = self.nested_sm
+            use_default += 1
+        if state_machine_kwargs is None:
+            state_machine_kwargs = self.nested_sm_kwargs
+            use_default += 1
+        block_length = len(block)
+
+        state_machine = None
+        if use_default == 2:
+            try:
+                state_machine = self.nested_sm_cache.pop()
+            except IndexError:
+                pass
+        if not state_machine:
+            state_machine = state_machine_class(debug=self.debug,
+                                                **state_machine_kwargs)
+        state_machine.run(block, input_offset, memo=self.memo,
+                          node=node, match_titles=match_titles)
+        if use_default == 2:
+            self.nested_sm_cache.append(state_machine)
+        else:
+            state_machine.unlink()
+        new_offset = state_machine.abs_line_offset()
+        # No `block.parent` implies disconnected -- lines aren't in sync:
+        if block.parent and (len(block) - block_length) != 0:
+            # Adjustment for block if modified in nested parse:
+            self.state_machine.next_line(len(block) - block_length)
+        return new_offset
+
+    def nested_list_parse(self, block, input_offset, node, initial_state,
+                          blank_finish,
+                          blank_finish_state=None,
+                          extra_settings={},
+                          match_titles=False,
+                          state_machine_class=None,
+                          state_machine_kwargs=None):
+        """
+        Create a new StateMachine rooted at `node` and run it over the input
+        `block`. Also keep track of optional intermediate blank lines and the
+        required final one.
+        """
+        if state_machine_class is None:
+            state_machine_class = self.nested_sm
+        if state_machine_kwargs is None:
+            state_machine_kwargs = self.nested_sm_kwargs.copy()
+        state_machine_kwargs['initial_state'] = initial_state
+        state_machine = state_machine_class(debug=self.debug,
+                                            **state_machine_kwargs)
+        if blank_finish_state is None:
+            blank_finish_state = initial_state
+        state_machine.states[blank_finish_state].blank_finish = blank_finish
+        for key, value in extra_settings.items():
+            setattr(state_machine.states[initial_state], key, value)
+        state_machine.run(block, input_offset, memo=self.memo,
+                          node=node, match_titles=match_titles)
+        blank_finish = state_machine.states[blank_finish_state].blank_finish
+        state_machine.unlink()
+        return state_machine.abs_line_offset(), blank_finish
+
+    def section(self, title, source, style, lineno, messages):
+        """Check for a valid subsection and create one if it checks out."""
+        if self.check_subsection(source, style, lineno):
+            self.new_subsection(title, lineno, messages)
+
+    def check_subsection(self, source, style, lineno):
+        """
+        Check for a valid subsection header.  Return True or False.
+
+        When a new section is reached that isn't a subsection of the current
+        section, back up the line count (use ``previous_line(-x)``), then
+        ``raise EOFError``.  The current StateMachine will finish, then the
+        calling StateMachine can re-examine the title.  This will work its way
+        back up the calling chain until the correct section level isreached.
+
+        @@@ Alternative: Evaluate the title, store the title info & level, and
+        back up the chain until that level is reached.  Store in memo? Or
+        return in results?
+
+        :Exception: `EOFError` when a sibling or supersection encountered.
+        """
+        memo = self.memo
+        title_styles = memo.title_styles
+        mylevel = memo.section_level
+        try:                            # check for existing title style
+            level = title_styles.index(style) + 1
+        except ValueError:              # new title style
+            if len(title_styles) == memo.section_level:  # new subsection
+                title_styles.append(style)
+                return True
+            else:                       # not at lowest level
+                self.parent += self.title_inconsistent(source, lineno)
+                return False
+        if level <= mylevel:            # sibling or supersection
+            memo.section_level = level   # bubble up to parent section
+            if len(style) == 2:
+                memo.section_bubble_up_kludge = True
+            # back up 2 lines for underline title, 3 for overline title
+            self.state_machine.previous_line(len(style) + 1)
+            raise EOFError              # let parent section re-evaluate
+        if level == mylevel + 1:        # immediate subsection
+            return True
+        else:                           # invalid subsection
+            self.parent += self.title_inconsistent(source, lineno)
+            return False
+
+    def title_inconsistent(self, sourcetext, lineno):
+        error = self.reporter.severe(
+            'Title level inconsistent:', nodes.literal_block('', sourcetext),
+            line=lineno)
+        return error
+
+    def new_subsection(self, title, lineno, messages):
+        """Append new subsection to document tree. On return, check level."""
+        memo = self.memo
+        mylevel = memo.section_level
+        memo.section_level += 1
+        section_node = nodes.section()
+        self.parent += section_node
+        textnodes, title_messages = self.inline_text(title, lineno)
+        titlenode = nodes.title(title, '', *textnodes)
+        name = normalize_name(titlenode.astext())
+        section_node['names'].append(name)
+        section_node += titlenode
+        section_node += messages
+        section_node += title_messages
+        self.document.note_implicit_target(section_node, section_node)
+        offset = self.state_machine.line_offset + 1
+        absoffset = self.state_machine.abs_line_offset() + 1
+        newabsoffset = self.nested_parse(
+              self.state_machine.input_lines[offset:], input_offset=absoffset,
+              node=section_node, match_titles=True)
+        self.goto_line(newabsoffset)
+        if memo.section_level <= mylevel:  # can't handle next section?
+            raise EOFError                 # bubble up to supersection
+        # reset section_level; next pass will detect it properly
+        memo.section_level = mylevel
+
+    def paragraph(self, lines, lineno):
+        """
+        Return a list (paragraph & messages) & a boolean: literal_block next?
+        """
+        data = '\n'.join(lines).rstrip()
+        if re.search(r'(?<!\\)(\\\\)*::$', data):
+            if len(data) == 2:
+                return [], 1
+            elif data[-3] in ' \n':
+                text = data[:-3].rstrip()
+            else:
+                text = data[:-1]
+            literalnext = 1
+        else:
+            text = data
+            literalnext = 0
+        textnodes, messages = self.inline_text(text, lineno)
+        p = nodes.paragraph(data, '', *textnodes)
+        p.source, p.line = self.state_machine.get_source_and_line(lineno)
+        return [p] + messages, literalnext
+
+    def inline_text(self, text, lineno):
+        """
+        Return 2 lists: nodes (text and inline elements), and system_messages.
+        """
+        nodes, messages = self.inliner.parse(text, lineno,
+                                             self.memo, self.parent)
+        return nodes, messages
+
+    def unindent_warning(self, node_name):
+        # the actual problem is one line below the current line
+        lineno = self.state_machine.abs_line_number() + 1
+        return self.reporter.warning('%s ends without a blank line; '
+                                     'unexpected unindent.' % node_name,
+                                     line=lineno)
+
+
+def build_regexp(definition, compile=True):
+    """
+    Build, compile and return a regular expression based on `definition`.
+
+    :Parameter: `definition`: a 4-tuple (group name, prefix, suffix, parts),
+        where "parts" is a list of regular expressions and/or regular
+        expression definitions to be joined into an or-group.
+    """
+    name, prefix, suffix, parts = definition
+    part_strings = []
+    for part in parts:
+        if isinstance(part, tuple):
+            part_strings.append(build_regexp(part, None))
+        else:
+            part_strings.append(part)
+    or_group = '|'.join(part_strings)
+    regexp = '%(prefix)s(?P<%(name)s>%(or_group)s)%(suffix)s' % locals()
+    if compile:
+        return re.compile(regexp)
+    else:
+        return regexp
+
+
+class Inliner:
+
+    """
+    Parse inline markup; call the `parse()` method.
+    """
+
+    def __init__(self):
+        self.implicit_dispatch = []
+        """List of (pattern, bound method) tuples, used by
+        `self.implicit_inline`."""
+
+    def init_customizations(self, settings):
+        # lookahead and look-behind expressions for inline markup rules
+        if getattr(settings, 'character_level_inline_markup', False):
+            start_string_prefix = '(^|(?<!\x00))'
+            end_string_suffix = ''
+        else:
+            start_string_prefix = ('(^|(?<=\\s|[%s%s]))' %
+                                   (punctuation_chars.openers,
+                                    punctuation_chars.delimiters))
+            end_string_suffix = ('($|(?=\\s|[\x00%s%s%s]))' %
+                                 (punctuation_chars.closing_delimiters,
+                                  punctuation_chars.delimiters,
+                                  punctuation_chars.closers))
+        args = locals().copy()
+        args.update(vars(self.__class__))
+
+        parts = ('initial_inline', start_string_prefix, '',
+           [
+            ('start', '', self.non_whitespace_after,  # simple start-strings
+             [r'\*\*',                # strong
+              r'\*(?!\*)',            # emphasis but not strong
+              r'``',                  # literal
+              r'_`',                  # inline internal target
+              r'\|(?!\|)']            # substitution reference
+             ),
+            ('whole', '', end_string_suffix,  # whole constructs
+             [  # reference name & end-string
+              r'(?P<refname>%s)(?P<refend>__?)' % self.simplename,
+              ('footnotelabel', r'\[', r'(?P<fnend>\]_)',
+               [r'[0-9]+',                     # manually numbered
+                r'\#(%s)?' % self.simplename,  # auto-numbered (w/ label?)
+                r'\*',                         # auto-symbol
+                r'(?P<citationlabel>%s)' % self.simplename,  # citation ref
+                ]
+               )
+              ]
+             ),
+            ('backquote',             # interpreted text or phrase reference
+             '(?P<role>(:%s:)?)' % self.simplename,  # optional role
+             self.non_whitespace_after,
+             ['`(?!`)']               # but not literal
+             )
+            ]
+        )
+        self.start_string_prefix = start_string_prefix
+        self.end_string_suffix = end_string_suffix
+        self.parts = parts
+
+        self.patterns = Struct(
+          initial=build_regexp(parts),
+          emphasis=re.compile(self.non_whitespace_escape_before
+                              + r'(\*)' + end_string_suffix),
+          strong=re.compile(self.non_whitespace_escape_before
+                            + r'(\*\*)' + end_string_suffix),
+          interpreted_or_phrase_ref=re.compile(
+              r"""
+              %(non_unescaped_whitespace_escape_before)s
+              (
+                `
+                (?P<suffix>
+                  (?P<role>:%(simplename)s:)?
+                  (?P<refend>__?)?
+                )
+              )
+              %(end_string_suffix)s
+              """ % args, re.VERBOSE),
+          embedded_link=re.compile(
+              r"""
+              (
+                (?:[ \n]+|^)            # spaces or beginning of line/string
+                <                       # open bracket
+                %(non_whitespace_after)s
+                (([^<>]|\x00[<>])+)     # anything but unescaped angle brackets
+                %(non_whitespace_escape_before)s
+                >                       # close bracket
+              )
+              $                         # end of string
+              """ % args, re.VERBOSE),
+          literal=re.compile(self.non_whitespace_before + '(``)'
+                             + end_string_suffix),
+          target=re.compile(self.non_whitespace_escape_before
+                            + r'(`)' + end_string_suffix),
+          substitution_ref=re.compile(self.non_whitespace_escape_before
+                                      + r'(\|_{0,2})'
+                                      + end_string_suffix),
+          email=re.compile(self.email_pattern % args + '$',
+                           re.VERBOSE),
+          uri=re.compile(
+                (r"""
+                %(start_string_prefix)s
+                (?P<whole>
+                  (?P<absolute>           # absolute URI
+                    (?P<scheme>             # scheme (http, ftp, mailto)
+                      [a-zA-Z][a-zA-Z0-9.+-]*
+                    )
+                    :
+                    (
+                      (                       # either:
+                        (//?)?                  # hierarchical URI
+                        %(uric)s*               # URI characters
+                        %(uri_end)s             # final URI char
+                      )
+                      (                       # optional query
+                        \?%(uric)s*
+                        %(uri_end)s
+                      )?
+                      (                       # optional fragment
+                        \#%(uric)s*
+                        %(uri_end)s
+                      )?
+                    )
+                  )
+                |                       # *OR*
+                  (?P<email>              # email address
+                    """ + self.email_pattern + r"""
+                  )
+                )
+                %(end_string_suffix)s
+                """) % args, re.VERBOSE),
+          pep=re.compile(
+                r"""
+                %(start_string_prefix)s
+                (
+                  (pep-(?P<pepnum1>\d+)(.txt)?) # reference to source file
+                |
+                  (PEP\s+(?P<pepnum2>\d+))      # reference by name
+                )
+                %(end_string_suffix)s""" % args, re.VERBOSE),
+          rfc=re.compile(
+                r"""
+                %(start_string_prefix)s
+                (RFC(-|\s+)?(?P<rfcnum>\d+))
+                %(end_string_suffix)s""" % args, re.VERBOSE))
+
+        self.implicit_dispatch.append((self.patterns.uri,
+                                       self.standalone_uri))
+        if settings.pep_references:
+            self.implicit_dispatch.append((self.patterns.pep,
+                                           self.pep_reference))
+        if settings.rfc_references:
+            self.implicit_dispatch.append((self.patterns.rfc,
+                                           self.rfc_reference))
+
+    def parse(self, text, lineno, memo, parent):
+        # Needs to be refactored for nested inline markup.
+        # Add nested_parse() method?
+        """
+        Return 2 lists: nodes (text and inline elements), and system_messages.
+
+        Using `self.patterns.initial`, a pattern which matches start-strings
+        (emphasis, strong, interpreted, phrase reference, literal,
+        substitution reference, and inline target) and complete constructs
+        (simple reference, footnote reference), search for a candidate.  When
+        one is found, check for validity (e.g., not a quoted '*' character).
+        If valid, search for the corresponding end string if applicable, and
+        check it for validity.  If not found or invalid, generate a warning
+        and ignore the start-string.  Implicit inline markup (e.g. standalone
+        URIs) is found last.
+
+        :text: source string
+        :lineno: absolute line number (cf. statemachine.get_source_and_line())
+        """
+        self.reporter = memo.reporter
+        self.document = memo.document
+        self.language = memo.language
+        self.parent = parent
+        pattern_search = self.patterns.initial.search
+        dispatch = self.dispatch
+        remaining = escape2null(text)
+        processed = []
+        unprocessed = []
+        messages = []
+        while remaining:
+            match = pattern_search(remaining)
+            if match:
+                groups = match.groupdict()
+                method = dispatch[groups['start'] or groups['backquote']
+                                  or groups['refend'] or groups['fnend']]
+                before, inlines, remaining, sysmessages = method(self, match,
+                                                                 lineno)
+                unprocessed.append(before)
+                messages += sysmessages
+                if inlines:
+                    processed += self.implicit_inline(''.join(unprocessed),
+                                                      lineno)
+                    processed += inlines
+                    unprocessed = []
+            else:
+                break
+        remaining = ''.join(unprocessed) + remaining
+        if remaining:
+            processed += self.implicit_inline(remaining, lineno)
+        return processed, messages
+
+    # Inline object recognition
+    # -------------------------
+    # See also init_customizations().
+    non_whitespace_before = r'(?<!\s)'
+    non_whitespace_escape_before = r'(?<![\s\x00])'
+    non_unescaped_whitespace_escape_before = r'(?<!(?<!\x00)[\s\x00])'
+    non_whitespace_after = r'(?!\s)'
+    # Alphanumerics with isolated internal [-._+:] chars (i.e. not 2 together):
+    simplename = r'(?:(?!_)\w)+(?:[-._+:](?:(?!_)\w)+)*'
+    # Valid URI characters (see RFC 2396 & RFC 2732);
+    # final \x00 allows backslash escapes in URIs:
+    uric = r"""[-_.!~*'()[\];/:@&=+$,%a-zA-Z0-9\x00]"""
+    # Delimiter indicating the end of a URI (not part of the URI):
+    uri_end_delim = r"""[>]"""
+    # Last URI character; same as uric but no punctuation:
+    urilast = r"""[_~*/=+a-zA-Z0-9]"""
+    # End of a URI (either 'urilast' or 'uric followed by a
+    # uri_end_delim'):
+    uri_end = r"""(?:%(urilast)s|%(uric)s(?=%(uri_end_delim)s))""" % locals()
+    emailc = r"""[-_!~*'{|}/#?^`&=+$%a-zA-Z0-9\x00]"""
+    email_pattern = r"""
+          %(emailc)s+(?:\.%(emailc)s+)*   # name
+          (?<!\x00)@                      # at
+          %(emailc)s+(?:\.%(emailc)s*)*   # host
+          %(uri_end)s                     # final URI char
+          """
+
+    def quoted_start(self, match):
+        """Test if inline markup start-string is 'quoted'.
+
+        'Quoted' in this context means the start-string is enclosed in a pair
+        of matching opening/closing delimiters (not necessarily quotes)
+        or at the end of the match.
+        """
+        string = match.string
+        start = match.start()
+        if start == 0:                  # start-string at beginning of text
+            return False
+        prestart = string[start - 1]
+        try:
+            poststart = string[match.end()]
+        except IndexError:          # start-string at end of text
+            return True  # not "quoted" but no markup start-string either
+        return punctuation_chars.match_chars(prestart, poststart)
+
+    def inline_obj(self, match, lineno, end_pattern, nodeclass,
+                   restore_backslashes=False):
+        string = match.string
+        matchstart = match.start('start')
+        matchend = match.end('start')
+        if self.quoted_start(match):
+            return string[:matchend], [], string[matchend:], [], ''
+        endmatch = end_pattern.search(string[matchend:])
+        if endmatch and endmatch.start(1):  # 1 or more chars
+            text = endmatch.string[:endmatch.start(1)]
+            if restore_backslashes:
+                text = unescape(text, True)
+            textend = matchend + endmatch.end(1)
+            rawsource = unescape(string[matchstart:textend], True)
+            node = nodeclass(rawsource, text)
+            return (string[:matchstart], [node],
+                    string[textend:], [], endmatch.group(1))
+        msg = self.reporter.warning(
+              'Inline %s start-string without end-string.'
+              % nodeclass.__name__, line=lineno)
+        text = unescape(string[matchstart:matchend], True)
+        prb = self.problematic(text, text, msg)
+        return string[:matchstart], [prb], string[matchend:], [msg], ''
+
+    def problematic(self, text, rawsource, message):
+        msgid = self.document.set_id(message, self.parent)
+        problematic = nodes.problematic(rawsource, text, refid=msgid)
+        prbid = self.document.set_id(problematic)
+        message.add_backref(prbid)
+        return problematic
+
+    def emphasis(self, match, lineno):
+        before, inlines, remaining, sysmessages, endstring = self.inline_obj(
+              match, lineno, self.patterns.emphasis, nodes.emphasis)
+        return before, inlines, remaining, sysmessages
+
+    def strong(self, match, lineno):
+        before, inlines, remaining, sysmessages, endstring = self.inline_obj(
+              match, lineno, self.patterns.strong, nodes.strong)
+        return before, inlines, remaining, sysmessages
+
+    def interpreted_or_phrase_ref(self, match, lineno):
+        end_pattern = self.patterns.interpreted_or_phrase_ref
+        string = match.string
+        matchstart = match.start('backquote')
+        matchend = match.end('backquote')
+        rolestart = match.start('role')
+        role = match.group('role')
+        position = ''
+        if role:
+            role = role[1:-1]
+            position = 'prefix'
+        elif self.quoted_start(match):
+            return string[:matchend], [], string[matchend:], []
+        endmatch = end_pattern.search(string[matchend:])
+        if endmatch and endmatch.start(1):  # 1 or more chars
+            textend = matchend + endmatch.end()
+            if endmatch.group('role'):
+                if role:
+                    msg = self.reporter.warning(
+                        'Multiple roles in interpreted text (both '
+                        'prefix and suffix present; only one allowed).',
+                        line=lineno)
+                    text = unescape(string[rolestart:textend], True)
+                    prb = self.problematic(text, text, msg)
+                    return string[:rolestart], [prb], string[textend:], [msg]
+                role = endmatch.group('suffix')[1:-1]
+                position = 'suffix'
+            escaped = endmatch.string[:endmatch.start(1)]
+            rawsource = unescape(string[matchstart:textend], True)
+            if rawsource[-1:] == '_':
+                if role:
+                    msg = self.reporter.warning(
+                          'Mismatch: both interpreted text role %s and '
+                          'reference suffix.' % position, line=lineno)
+                    text = unescape(string[rolestart:textend], True)
+                    prb = self.problematic(text, text, msg)
+                    return string[:rolestart], [prb], string[textend:], [msg]
+                return self.phrase_ref(string[:matchstart], string[textend:],
+                                       rawsource, escaped)
+            else:
+                rawsource = unescape(string[rolestart:textend], True)
+                nodelist, messages = self.interpreted(rawsource, escaped, role,
+                                                      lineno)
+                return (string[:rolestart], nodelist,
+                        string[textend:], messages)
+        msg = self.reporter.warning(
+              'Inline interpreted text or phrase reference start-string '
+              'without end-string.', line=lineno)
+        text = unescape(string[matchstart:matchend], True)
+        prb = self.problematic(text, text, msg)
+        return string[:matchstart], [prb], string[matchend:], [msg]
+
+    def phrase_ref(self, before, after, rawsource, escaped, text=None):
+        # `text` is ignored (since 0.16)
+        match = self.patterns.embedded_link.search(escaped)
+        if match:  # embedded <URI> or <alias_>
+            text = escaped[:match.start(0)]
+            unescaped = unescape(text)
+            rawtext = unescape(text, True)
+            aliastext = match.group(2)
+            rawaliastext = unescape(aliastext, True)
+            underscore_escaped = rawaliastext.endswith(r'\_')
+            if (aliastext.endswith('_')
+                and not (underscore_escaped
+                         or self.patterns.uri.match(aliastext))):
+                aliastype = 'name'
+                alias = normalize_name(unescape(aliastext[:-1]))
+                target = nodes.target(match.group(1), refname=alias)
+                target.indirect_reference_name = whitespace_normalize_name(
+                                                    unescape(aliastext[:-1]))
+            else:
+                aliastype = 'uri'
+                # remove unescaped whitespace
+                alias_parts = split_escaped_whitespace(match.group(2))
+                alias = ' '.join(''.join(part.split())
+                                 for part in alias_parts)
+                alias = self.adjust_uri(unescape(alias))
+                if alias.endswith(r'\_'):
+                    alias = alias[:-2] + '_'
+                target = nodes.target(match.group(1), refuri=alias)
+                target.referenced = 1
+            if not aliastext:
+                raise ApplicationError('problem with embedded link: %r'
+                                       % aliastext)
+            if not text:
+                text = alias
+                unescaped = unescape(text)
+                rawtext = rawaliastext
+        else:
+            text = escaped
+            unescaped = unescape(text)
+            target = None
+            rawtext = unescape(escaped, True)
+
+        refname = normalize_name(unescaped)
+        reference = nodes.reference(rawsource, text,
+                                    name=whitespace_normalize_name(unescaped))
+        reference[0].rawsource = rawtext
+
+        node_list = [reference]
+
+        if rawsource[-2:] == '__':
+            if target and (aliastype == 'name'):
+                reference['refname'] = alias
+                self.document.note_refname(reference)
+                # self.document.note_indirect_target(target) # required?
+            elif target and (aliastype == 'uri'):
+                reference['refuri'] = alias
+            else:
+                reference['anonymous'] = 1
+        else:
+            if target:
+                target['names'].append(refname)
+                if aliastype == 'name':
+                    reference['refname'] = alias
+                    self.document.note_indirect_target(target)
+                    self.document.note_refname(reference)
+                else:
+                    reference['refuri'] = alias
+                    self.document.note_explicit_target(target, self.parent)
+                # target.note_referenced_by(name=refname)
+                node_list.append(target)
+            else:
+                reference['refname'] = refname
+                self.document.note_refname(reference)
+        return before, node_list, after, []
+
+    def adjust_uri(self, uri):
+        match = self.patterns.email.match(uri)
+        if match:
+            return 'mailto:' + uri
+        else:
+            return uri
+
+    def interpreted(self, rawsource, text, role, lineno):
+        role_fn, messages = roles.role(role, self.language, lineno,
+                                       self.reporter)
+        if role_fn:
+            nodes, messages2 = role_fn(role, rawsource, text, lineno, self)
+            return nodes, messages + messages2
+        else:
+            msg = self.reporter.error(
+                'Unknown interpreted text role "%s".' % role,
+                line=lineno)
+            return ([self.problematic(rawsource, rawsource, msg)],
+                    messages + [msg])
+
+    def literal(self, match, lineno):
+        before, inlines, remaining, sysmessages, endstring = self.inline_obj(
+              match, lineno, self.patterns.literal, nodes.literal,
+              restore_backslashes=True)
+        return before, inlines, remaining, sysmessages
+
+    def inline_internal_target(self, match, lineno):
+        before, inlines, remaining, sysmessages, endstring = self.inline_obj(
+              match, lineno, self.patterns.target, nodes.target)
+        if inlines and isinstance(inlines[0], nodes.target):
+            assert len(inlines) == 1
+            target = inlines[0]
+            name = normalize_name(target.astext())
+            target['names'].append(name)
+            self.document.note_explicit_target(target, self.parent)
+        return before, inlines, remaining, sysmessages
+
+    def substitution_reference(self, match, lineno):
+        before, inlines, remaining, sysmessages, endstring = self.inline_obj(
+              match, lineno, self.patterns.substitution_ref,
+              nodes.substitution_reference)
+        if len(inlines) == 1:
+            subref_node = inlines[0]
+            if isinstance(subref_node, nodes.substitution_reference):
+                subref_text = subref_node.astext()
+                self.document.note_substitution_ref(subref_node, subref_text)
+                if endstring[-1:] == '_':
+                    reference_node = nodes.reference(
+                        '|%s%s' % (subref_text, endstring), '')
+                    if endstring[-2:] == '__':
+                        reference_node['anonymous'] = 1
+                    else:
+                        reference_node['refname'] = normalize_name(subref_text)
+                        self.document.note_refname(reference_node)
+                    reference_node += subref_node
+                    inlines = [reference_node]
+        return before, inlines, remaining, sysmessages
+
+    def footnote_reference(self, match, lineno):
+        """
+        Handles `nodes.footnote_reference` and `nodes.citation_reference`
+        elements.
+        """
+        label = match.group('footnotelabel')
+        refname = normalize_name(label)
+        string = match.string
+        before = string[:match.start('whole')]
+        remaining = string[match.end('whole'):]
+        if match.group('citationlabel'):
+            refnode = nodes.citation_reference('[%s]_' % label,
+                                               refname=refname)
+            refnode += nodes.Text(label)
+            self.document.note_citation_ref(refnode)
+        else:
+            refnode = nodes.footnote_reference('[%s]_' % label)
+            if refname[0] == '#':
+                refname = refname[1:]
+                refnode['auto'] = 1
+                self.document.note_autofootnote_ref(refnode)
+            elif refname == '*':
+                refname = ''
+                refnode['auto'] = '*'
+                self.document.note_symbol_footnote_ref(
+                      refnode)
+            else:
+                refnode += nodes.Text(label)
+            if refname:
+                refnode['refname'] = refname
+                self.document.note_footnote_ref(refnode)
+            if utils.get_trim_footnote_ref_space(self.document.settings):
+                before = before.rstrip()
+        return before, [refnode], remaining, []
+
+    def reference(self, match, lineno, anonymous=False):
+        referencename = match.group('refname')
+        refname = normalize_name(referencename)
+        referencenode = nodes.reference(
+            referencename + match.group('refend'), referencename,
+            name=whitespace_normalize_name(referencename))
+        referencenode[0].rawsource = referencename
+        if anonymous:
+            referencenode['anonymous'] = 1
+        else:
+            referencenode['refname'] = refname
+            self.document.note_refname(referencenode)
+        string = match.string
+        matchstart = match.start('whole')
+        matchend = match.end('whole')
+        return string[:matchstart], [referencenode], string[matchend:], []
+
+    def anonymous_reference(self, match, lineno):
+        return self.reference(match, lineno, anonymous=True)
+
+    def standalone_uri(self, match, lineno):
+        if (not match.group('scheme')
+                or match.group('scheme').lower() in urischemes.schemes):
+            if match.group('email'):
+                addscheme = 'mailto:'
+            else:
+                addscheme = ''
+            text = match.group('whole')
+            refuri = addscheme + unescape(text)
+            reference = nodes.reference(unescape(text, True), text,
+                                        refuri=refuri)
+            return [reference]
+        else:                   # not a valid scheme
+            raise MarkupMismatch
+
+    def pep_reference(self, match, lineno):
+        text = match.group(0)
+        if text.startswith('pep-'):
+            pepnum = int(unescape(match.group('pepnum1')))
+        elif text.startswith('PEP'):
+            pepnum = int(unescape(match.group('pepnum2')))
+        else:
+            raise MarkupMismatch
+        ref = (self.document.settings.pep_base_url
+               + self.document.settings.pep_file_url_template % pepnum)
+        return [nodes.reference(unescape(text, True), text, refuri=ref)]
+
+    rfc_url = 'rfc%d.html'
+
+    def rfc_reference(self, match, lineno):
+        text = match.group(0)
+        if text.startswith('RFC'):
+            rfcnum = int(unescape(match.group('rfcnum')))
+            ref = self.document.settings.rfc_base_url + self.rfc_url % rfcnum
+        else:
+            raise MarkupMismatch
+        return [nodes.reference(unescape(text, True), text, refuri=ref)]
+
+    def implicit_inline(self, text, lineno):
+        """
+        Check each of the patterns in `self.implicit_dispatch` for a match,
+        and dispatch to the stored method for the pattern.  Recursively check
+        the text before and after the match.  Return a list of `nodes.Text`
+        and inline element nodes.
+        """
+        if not text:
+            return []
+        for pattern, method in self.implicit_dispatch:
+            match = pattern.search(text)
+            if match:
+                try:
+                    # Must recurse on strings before *and* after the match;
+                    # there may be multiple patterns.
+                    return (self.implicit_inline(text[:match.start()], lineno)
+                            + method(match, lineno)
+                            + self.implicit_inline(text[match.end():], lineno))
+                except MarkupMismatch:
+                    pass
+        return [nodes.Text(text)]
+
+    dispatch = {'*': emphasis,
+                '**': strong,
+                '`': interpreted_or_phrase_ref,
+                '``': literal,
+                '_`': inline_internal_target,
+                ']_': footnote_reference,
+                '|': substitution_reference,
+                '_': reference,
+                '__': anonymous_reference}
+
+
+def _loweralpha_to_int(s, _zero=(ord('a')-1)):
+    return ord(s) - _zero
+
+
+def _upperalpha_to_int(s, _zero=(ord('A')-1)):
+    return ord(s) - _zero
+
+
+def _lowerroman_to_int(s):
+    return roman.fromRoman(s.upper())
+
+
+class Body(RSTState):
+
+    """
+    Generic classifier of the first line of a block.
+    """
+
+    double_width_pad_char = tableparser.TableParser.double_width_pad_char
+    """Padding character for East Asian double-width text."""
+
+    enum = Struct()
+    """Enumerated list parsing information."""
+
+    enum.formatinfo = {
+          'parens': Struct(prefix='(', suffix=')', start=1, end=-1),
+          'rparen': Struct(prefix='', suffix=')', start=0, end=-1),
+          'period': Struct(prefix='', suffix='.', start=0, end=-1)}
+    enum.formats = enum.formatinfo.keys()
+    enum.sequences = ['arabic', 'loweralpha', 'upperalpha',
+                      'lowerroman', 'upperroman']  # ORDERED!
+    enum.sequencepats = {'arabic': '[0-9]+',
+                         'loweralpha': '[a-z]',
+                         'upperalpha': '[A-Z]',
+                         'lowerroman': '[ivxlcdm]+',
+                         'upperroman': '[IVXLCDM]+'}
+    enum.converters = {'arabic': int,
+                       'loweralpha': _loweralpha_to_int,
+                       'upperalpha': _upperalpha_to_int,
+                       'lowerroman': _lowerroman_to_int,
+                       'upperroman': roman.fromRoman}
+
+    enum.sequenceregexps = {}
+    for sequence in enum.sequences:
+        enum.sequenceregexps[sequence] = re.compile(
+              enum.sequencepats[sequence] + '$')
+
+    grid_table_top_pat = re.compile(r'\+-[-+]+-\+ *$')
+    """Matches the top (& bottom) of a full table)."""
+
+    simple_table_top_pat = re.compile('=+( +=+)+ *$')
+    """Matches the top of a simple table."""
+
+    simple_table_border_pat = re.compile('=+[ =]*$')
+    """Matches the bottom & header bottom of a simple table."""
+
+    pats = {}
+    """Fragments of patterns used by transitions."""
+
+    pats['nonalphanum7bit'] = '[!-/:-@[-`{-~]'
+    pats['alpha'] = '[a-zA-Z]'
+    pats['alphanum'] = '[a-zA-Z0-9]'
+    pats['alphanumplus'] = '[a-zA-Z0-9_-]'
+    pats['enum'] = ('(%(arabic)s|%(loweralpha)s|%(upperalpha)s|%(lowerroman)s'
+                    '|%(upperroman)s|#)' % enum.sequencepats)
+    pats['optname'] = '%(alphanum)s%(alphanumplus)s*' % pats
+    # @@@ Loosen up the pattern?  Allow Unicode?
+    pats['optarg'] = '(%(alpha)s%(alphanumplus)s*|<[^<>]+>)' % pats
+    pats['shortopt'] = r'(-|\+)%(alphanum)s( ?%(optarg)s)?' % pats
+    pats['longopt'] = r'(--|/)%(optname)s([ =]%(optarg)s)?' % pats
+    pats['option'] = r'(%(shortopt)s|%(longopt)s)' % pats
+
+    for format in enum.formats:
+        pats[format] = '(?P<%s>%s%s%s)' % (
+              format, re.escape(enum.formatinfo[format].prefix),
+              pats['enum'], re.escape(enum.formatinfo[format].suffix))
+
+    patterns = {
+          'bullet': '[-+*\u2022\u2023\u2043]( +|$)',
+          'enumerator': r'(%(parens)s|%(rparen)s|%(period)s)( +|$)' % pats,
+          'field_marker': r':(?![: ])([^:\\]|\\.|:(?!([ `]|$)))*(?<! ):( +|$)',
+          'option_marker': r'%(option)s(, %(option)s)*(  +| ?$)' % pats,
+          'doctest': r'>>>( +|$)',
+          'line_block': r'\|( +|$)',
+          'grid_table_top': grid_table_top_pat,
+          'simple_table_top': simple_table_top_pat,
+          'explicit_markup': r'\.\.( +|$)',
+          'anonymous': r'__( +|$)',
+          'line': r'(%(nonalphanum7bit)s)\1* *$' % pats,
+          'text': r''}
+    initial_transitions = (
+          'bullet',
+          'enumerator',
+          'field_marker',
+          'option_marker',
+          'doctest',
+          'line_block',
+          'grid_table_top',
+          'simple_table_top',
+          'explicit_markup',
+          'anonymous',
+          'line',
+          'text')
+
+    def indent(self, match, context, next_state):
+        """Block quote."""
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_indented()
+        elements = self.block_quote(indented, line_offset)
+        self.parent += elements
+        if not blank_finish:
+            self.parent += self.unindent_warning('Block quote')
+        return context, next_state, []
+
+    def block_quote(self, indented, line_offset):
+        elements = []
+        while indented:
+            blockquote = nodes.block_quote(rawsource='\n'.join(indented))
+            (blockquote.source, blockquote.line
+             ) = self.state_machine.get_source_and_line(line_offset+1)
+            (blockquote_lines,
+             attribution_lines,
+             attribution_offset,
+             indented,
+             new_line_offset) = self.split_attribution(indented, line_offset)
+            self.nested_parse(blockquote_lines, line_offset, blockquote)
+            elements.append(blockquote)
+            if attribution_lines:
+                attribution, messages = self.parse_attribution(
+                    attribution_lines, line_offset+attribution_offset)
+                blockquote += attribution
+                elements += messages
+            line_offset = new_line_offset
+            while indented and not indented[0]:
+                indented = indented[1:]
+                line_offset += 1
+        return elements
+
+    # U+2014 is an em-dash:
+    attribution_pattern = re.compile('(---?(?!-)|\u2014) *(?=[^ \\n])')
+
+    def split_attribution(self, indented, line_offset):
+        """
+        Check for a block quote attribution and split it off:
+
+        * First line after a blank line must begin with a dash ("--", "---",
+          em-dash; matches `self.attribution_pattern`).
+        * Every line after that must have consistent indentation.
+        * Attributions must be preceded by block quote content.
+
+        Return a tuple of: (block quote content lines, attribution lines,
+        attribution offset, remaining indented lines, remaining lines offset).
+        """
+        blank = None
+        nonblank_seen = False
+        for i in range(len(indented)):
+            line = indented[i].rstrip()
+            if line:
+                if nonblank_seen and blank == i - 1:  # last line blank
+                    match = self.attribution_pattern.match(line)
+                    if match:
+                        attribution_end, indent = self.check_attribution(
+                            indented, i)
+                        if attribution_end:
+                            a_lines = indented[i:attribution_end]
+                            a_lines.trim_left(match.end(), end=1)
+                            a_lines.trim_left(indent, start=1)
+                            return (indented[:i], a_lines,
+                                    i, indented[attribution_end:],
+                                    line_offset + attribution_end)
+                nonblank_seen = True
+            else:
+                blank = i
+        else:
+            return indented, None, None, None, None
+
+    def check_attribution(self, indented, attribution_start):
+        """
+        Check attribution shape.
+        Return the index past the end of the attribution, and the indent.
+        """
+        indent = None
+        i = attribution_start + 1
+        for i in range(attribution_start + 1, len(indented)):
+            line = indented[i].rstrip()
+            if not line:
+                break
+            if indent is None:
+                indent = len(line) - len(line.lstrip())
+            elif len(line) - len(line.lstrip()) != indent:
+                return None, None       # bad shape; not an attribution
+        else:
+            # return index of line after last attribution line:
+            i += 1
+        return i, (indent or 0)
+
+    def parse_attribution(self, indented, line_offset):
+        text = '\n'.join(indented).rstrip()
+        lineno = 1 + line_offset  # line_offset is zero-based
+        textnodes, messages = self.inline_text(text, lineno)
+        node = nodes.attribution(text, '', *textnodes)
+        node.source, node.line = self.state_machine.get_source_and_line(lineno)
+        return node, messages
+
+    def bullet(self, match, context, next_state):
+        """Bullet list item."""
+        ul = nodes.bullet_list()
+        ul.source, ul.line = self.state_machine.get_source_and_line()
+        self.parent += ul
+        ul['bullet'] = match.string[0]
+        i, blank_finish = self.list_item(match.end())
+        ul += i
+        offset = self.state_machine.line_offset + 1   # next line
+        new_line_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=ul, initial_state='BulletList',
+              blank_finish=blank_finish)
+        self.goto_line(new_line_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning('Bullet list')
+        return [], next_state, []
+
+    def list_item(self, indent):
+        src, srcline = self.state_machine.get_source_and_line()
+        if self.state_machine.line[indent:]:
+            indented, line_offset, blank_finish = (
+                self.state_machine.get_known_indented(indent))
+        else:
+            indented, indent, line_offset, blank_finish = (
+                self.state_machine.get_first_known_indented(indent))
+        listitem = nodes.list_item('\n'.join(indented))
+        listitem.source, listitem.line = src, srcline
+        if indented:
+            self.nested_parse(indented, input_offset=line_offset,
+                              node=listitem)
+        return listitem, blank_finish
+
+    def enumerator(self, match, context, next_state):
+        """Enumerated List Item"""
+        format, sequence, text, ordinal = self.parse_enumerator(match)
+        if not self.is_enumerated_list_item(ordinal, sequence, format):
+            raise statemachine.TransitionCorrection('text')
+        enumlist = nodes.enumerated_list()
+        self.parent += enumlist
+        if sequence == '#':
+            enumlist['enumtype'] = 'arabic'
+        else:
+            enumlist['enumtype'] = sequence
+        enumlist['prefix'] = self.enum.formatinfo[format].prefix
+        enumlist['suffix'] = self.enum.formatinfo[format].suffix
+        if ordinal != 1:
+            enumlist['start'] = ordinal
+            msg = self.reporter.info(
+                'Enumerated list start value not ordinal-1: "%s" (ordinal %s)'
+                % (text, ordinal))
+            self.parent += msg
+        listitem, blank_finish = self.list_item(match.end())
+        enumlist += listitem
+        offset = self.state_machine.line_offset + 1   # next line
+        newline_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=enumlist, initial_state='EnumeratedList',
+              blank_finish=blank_finish,
+              extra_settings={'lastordinal': ordinal,
+                              'format': format,
+                              'auto': sequence == '#'})
+        self.goto_line(newline_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning('Enumerated list')
+        return [], next_state, []
+
+    def parse_enumerator(self, match, expected_sequence=None):
+        """
+        Analyze an enumerator and return the results.
+
+        :Return:
+            - the enumerator format ('period', 'parens', or 'rparen'),
+            - the sequence used ('arabic', 'loweralpha', 'upperroman', etc.),
+            - the text of the enumerator, stripped of formatting, and
+            - the ordinal value of the enumerator ('a' -> 1, 'ii' -> 2, etc.;
+              ``None`` is returned for invalid enumerator text).
+
+        The enumerator format has already been determined by the regular
+        expression match. If `expected_sequence` is given, that sequence is
+        tried first. If not, we check for Roman numeral 1. This way,
+        single-character Roman numerals (which are also alphabetical) can be
+        matched. If no sequence has been matched, all sequences are checked in
+        order.
+        """
+        groupdict = match.groupdict()
+        sequence = ''
+        for format in self.enum.formats:
+            if groupdict[format]:       # was this the format matched?
+                break                   # yes; keep `format`
+        else:                           # shouldn't happen
+            raise ParserError('enumerator format not matched')
+        text = groupdict[format][self.enum.formatinfo[format].start     # noqa: E203,E501
+                                 : self.enum.formatinfo[format].end]
+        if text == '#':
+            sequence = '#'
+        elif expected_sequence:
+            try:
+                if self.enum.sequenceregexps[expected_sequence].match(text):
+                    sequence = expected_sequence
+            except KeyError:            # shouldn't happen
+                raise ParserError('unknown enumerator sequence: %s'
+                                  % sequence)
+        elif text == 'i':
+            sequence = 'lowerroman'
+        elif text == 'I':
+            sequence = 'upperroman'
+        if not sequence:
+            for sequence in self.enum.sequences:
+                if self.enum.sequenceregexps[sequence].match(text):
+                    break
+            else:                       # shouldn't happen
+                raise ParserError('enumerator sequence not matched')
+        if sequence == '#':
+            ordinal = 1
+        else:
+            try:
+                ordinal = self.enum.converters[sequence](text)
+            except roman.InvalidRomanNumeralError:
+                ordinal = None
+        return format, sequence, text, ordinal
+
+    def is_enumerated_list_item(self, ordinal, sequence, format):
+        """
+        Check validity based on the ordinal value and the second line.
+
+        Return true if the ordinal is valid and the second line is blank,
+        indented, or starts with the next enumerator or an auto-enumerator.
+        """
+        if ordinal is None:
+            return None
+        try:
+            next_line = self.state_machine.next_line()
+        except EOFError:              # end of input lines
+            self.state_machine.previous_line()
+            return 1
+        else:
+            self.state_machine.previous_line()
+        if not next_line[:1].strip():   # blank or indented
+            return 1
+        result = self.make_enumerator(ordinal + 1, sequence, format)
+        if result:
+            next_enumerator, auto_enumerator = result
+            try:
+                if (next_line.startswith(next_enumerator)
+                    or next_line.startswith(auto_enumerator)):
+                    return 1
+            except TypeError:
+                pass
+        return None
+
+    def make_enumerator(self, ordinal, sequence, format):
+        """
+        Construct and return the next enumerated list item marker, and an
+        auto-enumerator ("#" instead of the regular enumerator).
+
+        Return ``None`` for invalid (out of range) ordinals.
+        """
+        if sequence == '#':
+            enumerator = '#'
+        elif sequence == 'arabic':
+            enumerator = str(ordinal)
+        else:
+            if sequence.endswith('alpha'):
+                if ordinal > 26:
+                    return None
+                enumerator = chr(ordinal + ord('a') - 1)
+            elif sequence.endswith('roman'):
+                try:
+                    enumerator = roman.toRoman(ordinal)
+                except roman.RomanError:
+                    return None
+            else:                       # shouldn't happen
+                raise ParserError('unknown enumerator sequence: "%s"'
+                                  % sequence)
+            if sequence.startswith('lower'):
+                enumerator = enumerator.lower()
+            elif sequence.startswith('upper'):
+                enumerator = enumerator.upper()
+            else:                       # shouldn't happen
+                raise ParserError('unknown enumerator sequence: "%s"'
+                                  % sequence)
+        formatinfo = self.enum.formatinfo[format]
+        next_enumerator = (formatinfo.prefix + enumerator + formatinfo.suffix
+                           + ' ')
+        auto_enumerator = formatinfo.prefix + '#' + formatinfo.suffix + ' '
+        return next_enumerator, auto_enumerator
+
+    def field_marker(self, match, context, next_state):
+        """Field list item."""
+        field_list = nodes.field_list()
+        self.parent += field_list
+        field, blank_finish = self.field(match)
+        field_list += field
+        offset = self.state_machine.line_offset + 1   # next line
+        newline_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=field_list, initial_state='FieldList',
+              blank_finish=blank_finish)
+        self.goto_line(newline_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning('Field list')
+        return [], next_state, []
+
+    def field(self, match):
+        name = self.parse_field_marker(match)
+        src, srcline = self.state_machine.get_source_and_line()
+        lineno = self.state_machine.abs_line_number()
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end())
+        field_node = nodes.field()
+        field_node.source = src
+        field_node.line = srcline
+        name_nodes, name_messages = self.inline_text(name, lineno)
+        field_node += nodes.field_name(name, '', *name_nodes)
+        field_body = nodes.field_body('\n'.join(indented), *name_messages)
+        field_node += field_body
+        if indented:
+            self.parse_field_body(indented, line_offset, field_body)
+        return field_node, blank_finish
+
+    def parse_field_marker(self, match):
+        """Extract & return field name from a field marker match."""
+        field = match.group()[1:]         # strip off leading ':'
+        field = field[:field.rfind(':')]  # strip off trailing ':' etc.
+        return field
+
+    def parse_field_body(self, indented, offset, node):
+        self.nested_parse(indented, input_offset=offset, node=node)
+
+    def option_marker(self, match, context, next_state):
+        """Option list item."""
+        optionlist = nodes.option_list()
+        (optionlist.source, optionlist.line
+         ) = self.state_machine.get_source_and_line()
+        try:
+            listitem, blank_finish = self.option_list_item(match)
+        except MarkupError as error:
+            # This shouldn't happen; pattern won't match.
+            msg = self.reporter.error('Invalid option list marker: %s'
+                                      % error)
+            self.parent += msg
+            (indented, indent, line_offset, blank_finish
+             ) = self.state_machine.get_first_known_indented(match.end())
+            elements = self.block_quote(indented, line_offset)
+            self.parent += elements
+            if not blank_finish:
+                self.parent += self.unindent_warning('Option list')
+            return [], next_state, []
+        self.parent += optionlist
+        optionlist += listitem
+        offset = self.state_machine.line_offset + 1   # next line
+        newline_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=optionlist, initial_state='OptionList',
+              blank_finish=blank_finish)
+        self.goto_line(newline_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning('Option list')
+        return [], next_state, []
+
+    def option_list_item(self, match):
+        offset = self.state_machine.abs_line_offset()
+        options = self.parse_option_marker(match)
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end())
+        if not indented:                # not an option list item
+            self.goto_line(offset)
+            raise statemachine.TransitionCorrection('text')
+        option_group = nodes.option_group('', *options)
+        description = nodes.description('\n'.join(indented))
+        option_list_item = nodes.option_list_item('', option_group,
+                                                  description)
+        if indented:
+            self.nested_parse(indented, input_offset=line_offset,
+                              node=description)
+        return option_list_item, blank_finish
+
+    def parse_option_marker(self, match):
+        """
+        Return a list of `node.option` and `node.option_argument` objects,
+        parsed from an option marker match.
+
+        :Exception: `MarkupError` for invalid option markers.
+        """
+        optlist = []
+        # split at ", ", except inside < > (complex arguments)
+        optionstrings = re.split(r', (?![^<]*>)', match.group().rstrip())
+        for optionstring in optionstrings:
+            tokens = optionstring.split()
+            delimiter = ' '
+            firstopt = tokens[0].split('=', 1)
+            if len(firstopt) > 1:
+                # "--opt=value" form
+                tokens[:1] = firstopt
+                delimiter = '='
+            elif (len(tokens[0]) > 2
+                  and ((tokens[0].startswith('-')
+                        and not tokens[0].startswith('--'))
+                       or tokens[0].startswith('+'))):
+                # "-ovalue" form
+                tokens[:1] = [tokens[0][:2], tokens[0][2:]]
+                delimiter = ''
+            if len(tokens) > 1 and (tokens[1].startswith('<')
+                                    and tokens[-1].endswith('>')):
+                # "-o <value1 value2>" form; join all values into one token
+                tokens[1:] = [' '.join(tokens[1:])]
+            if 0 < len(tokens) <= 2:
+                option = nodes.option(optionstring)
+                option += nodes.option_string(tokens[0], tokens[0])
+                if len(tokens) > 1:
+                    option += nodes.option_argument(tokens[1], tokens[1],
+                                                    delimiter=delimiter)
+                optlist.append(option)
+            else:
+                raise MarkupError(
+                    'wrong number of option tokens (=%s), should be 1 or 2: '
+                    '"%s"' % (len(tokens), optionstring))
+        return optlist
+
+    def doctest(self, match, context, next_state):
+        data = '\n'.join(self.state_machine.get_text_block())
+        # TODO: prepend class value ['pycon'] (Python Console)
+        # parse with `directives.body.CodeBlock` (returns literal-block
+        # with class "code" and syntax highlight markup).
+        self.parent += nodes.doctest_block(data, data)
+        return [], next_state, []
+
+    def line_block(self, match, context, next_state):
+        """First line of a line block."""
+        block = nodes.line_block()
+        self.parent += block
+        lineno = self.state_machine.abs_line_number()
+        line, messages, blank_finish = self.line_block_line(match, lineno)
+        block += line
+        self.parent += messages
+        if not blank_finish:
+            offset = self.state_machine.line_offset + 1   # next line
+            new_line_offset, blank_finish = self.nested_list_parse(
+                  self.state_machine.input_lines[offset:],
+                  input_offset=self.state_machine.abs_line_offset() + 1,
+                  node=block, initial_state='LineBlock',
+                  blank_finish=0)
+            self.goto_line(new_line_offset)
+        if not blank_finish:
+            self.parent += self.reporter.warning(
+                'Line block ends without a blank line.',
+                line=lineno+1)
+        if len(block):
+            if block[0].indent is None:
+                block[0].indent = 0
+            self.nest_line_block_lines(block)
+        return [], next_state, []
+
+    def line_block_line(self, match, lineno):
+        """Return one line element of a line_block."""
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end(),
+                                                         until_blank=True)
+        text = '\n'.join(indented)
+        text_nodes, messages = self.inline_text(text, lineno)
+        line = nodes.line(text, '', *text_nodes)
+        if match.string.rstrip() != '|':  # not empty
+            line.indent = len(match.group(1)) - 1
+        return line, messages, blank_finish
+
+    def nest_line_block_lines(self, block):
+        for index in range(1, len(block)):
+            if getattr(block[index], 'indent', None) is None:
+                block[index].indent = block[index - 1].indent
+        self.nest_line_block_segment(block)
+
+    def nest_line_block_segment(self, block):
+        indents = [item.indent for item in block]
+        least = min(indents)
+        new_items = []
+        new_block = nodes.line_block()
+        for item in block:
+            if item.indent > least:
+                new_block.append(item)
+            else:
+                if len(new_block):
+                    self.nest_line_block_segment(new_block)
+                    new_items.append(new_block)
+                    new_block = nodes.line_block()
+                new_items.append(item)
+        if len(new_block):
+            self.nest_line_block_segment(new_block)
+            new_items.append(new_block)
+        block[:] = new_items
+
+    def grid_table_top(self, match, context, next_state):
+        """Top border of a full table."""
+        return self.table_top(match, context, next_state,
+                              self.isolate_grid_table,
+                              tableparser.GridTableParser)
+
+    def simple_table_top(self, match, context, next_state):
+        """Top border of a simple table."""
+        return self.table_top(match, context, next_state,
+                              self.isolate_simple_table,
+                              tableparser.SimpleTableParser)
+
+    def table_top(self, match, context, next_state,
+                  isolate_function, parser_class):
+        """Top border of a generic table."""
+        nodelist, blank_finish = self.table(isolate_function, parser_class)
+        self.parent += nodelist
+        if not blank_finish:
+            msg = self.reporter.warning(
+                'Blank line required after table.',
+                line=self.state_machine.abs_line_number()+1)
+            self.parent += msg
+        return [], next_state, []
+
+    def table(self, isolate_function, parser_class):
+        """Parse a table."""
+        block, messages, blank_finish = isolate_function()
+        if block:
+            try:
+                parser = parser_class()
+                tabledata = parser.parse(block)
+                tableline = (self.state_machine.abs_line_number() - len(block)
+                             + 1)
+                table = self.build_table(tabledata, tableline)
+                nodelist = [table] + messages
+            except tableparser.TableMarkupError as err:
+                nodelist = self.malformed_table(block, ' '.join(err.args),
+                                                offset=err.offset) + messages
+        else:
+            nodelist = messages
+        return nodelist, blank_finish
+
+    def isolate_grid_table(self):
+        messages = []
+        blank_finish = 1
+        try:
+            block = self.state_machine.get_text_block(flush_left=True)
+        except statemachine.UnexpectedIndentationError as err:
+            block, src, srcline = err.args
+            messages.append(self.reporter.error('Unexpected indentation.',
+                                                source=src, line=srcline))
+            blank_finish = 0
+        block.disconnect()
+        # for East Asian chars:
+        block.pad_double_width(self.double_width_pad_char)
+        width = len(block[0].strip())
+        for i in range(len(block)):
+            block[i] = block[i].strip()
+            if block[i][0] not in '+|':  # check left edge
+                blank_finish = 0
+                self.state_machine.previous_line(len(block) - i)
+                del block[i:]
+                break
+        if not self.grid_table_top_pat.match(block[-1]):  # find bottom
+            blank_finish = 0
+            # from second-last to third line of table:
+            for i in range(len(block) - 2, 1, -1):
+                if self.grid_table_top_pat.match(block[i]):
+                    self.state_machine.previous_line(len(block) - i + 1)
+                    del block[i+1:]
+                    break
+            else:
+                messages.extend(self.malformed_table(block))
+                return [], messages, blank_finish
+        for i in range(len(block)):     # check right edge
+            if len(block[i]) != width or block[i][-1] not in '+|':
+                messages.extend(self.malformed_table(block))
+                return [], messages, blank_finish
+        return block, messages, blank_finish
+
+    def isolate_simple_table(self):
+        start = self.state_machine.line_offset
+        lines = self.state_machine.input_lines
+        limit = len(lines) - 1
+        toplen = len(lines[start].strip())
+        pattern_match = self.simple_table_border_pat.match
+        found = 0
+        found_at = None
+        i = start + 1
+        while i <= limit:
+            line = lines[i]
+            match = pattern_match(line)
+            if match:
+                if len(line.strip()) != toplen:
+                    self.state_machine.next_line(i - start)
+                    messages = self.malformed_table(
+                        lines[start:i+1], 'Bottom/header table border does '
+                        'not match top border.')
+                    return [], messages, i == limit or not lines[i+1].strip()
+                found += 1
+                found_at = i
+                if found == 2 or i == limit or not lines[i+1].strip():
+                    end = i
+                    break
+            i += 1
+        else:                           # reached end of input_lines
+            if found:
+                extra = ' or no blank line after table bottom'
+                self.state_machine.next_line(found_at - start)
+                block = lines[start:found_at+1]
+            else:
+                extra = ''
+                self.state_machine.next_line(i - start - 1)
+                block = lines[start:]
+            messages = self.malformed_table(
+                block, 'No bottom table border found%s.' % extra)
+            return [], messages, not extra
+        self.state_machine.next_line(end - start)
+        block = lines[start:end+1]
+        # for East Asian chars:
+        block.pad_double_width(self.double_width_pad_char)
+        return block, [], end == limit or not lines[end+1].strip()
+
+    def malformed_table(self, block, detail='', offset=0):
+        block.replace(self.double_width_pad_char, '')
+        data = '\n'.join(block)
+        message = 'Malformed table.'
+        startline = self.state_machine.abs_line_number() - len(block) + 1
+        if detail:
+            message += '\n' + detail
+        error = self.reporter.error(message, nodes.literal_block(data, data),
+                                    line=startline+offset)
+        return [error]
+
+    def build_table(self, tabledata, tableline, stub_columns=0, widths=None):
+        colwidths, headrows, bodyrows = tabledata
+        table = nodes.table()
+        if widths == 'auto':
+            table['classes'] += ['colwidths-auto']
+        elif widths:  # "grid" or list of integers
+            table['classes'] += ['colwidths-given']
+        tgroup = nodes.tgroup(cols=len(colwidths))
+        table += tgroup
+        for colwidth in colwidths:
+            colspec = nodes.colspec(colwidth=colwidth)
+            if stub_columns:
+                colspec.attributes['stub'] = 1
+                stub_columns -= 1
+            tgroup += colspec
+        if headrows:
+            thead = nodes.thead()
+            tgroup += thead
+            for row in headrows:
+                thead += self.build_table_row(row, tableline)
+        tbody = nodes.tbody()
+        tgroup += tbody
+        for row in bodyrows:
+            tbody += self.build_table_row(row, tableline)
+        return table
+
+    def build_table_row(self, rowdata, tableline):
+        row = nodes.row()
+        for cell in rowdata:
+            if cell is None:
+                continue
+            morerows, morecols, offset, cellblock = cell
+            attributes = {}
+            if morerows:
+                attributes['morerows'] = morerows
+            if morecols:
+                attributes['morecols'] = morecols
+            entry = nodes.entry(**attributes)
+            row += entry
+            if ''.join(cellblock):
+                self.nested_parse(cellblock, input_offset=tableline+offset,
+                                  node=entry)
+        return row
+
+    explicit = Struct()
+    """Patterns and constants used for explicit markup recognition."""
+
+    explicit.patterns = Struct(
+          target=re.compile(r"""
+                            (
+                              _               # anonymous target
+                            |               # *OR*
+                              (?!_)           # no underscore at the beginning
+                              (?P<quote>`?)   # optional open quote
+                              (?![ `])        # first char. not space or
+                                              # backquote
+                              (?P<name>       # reference name
+                                .+?
+                              )
+                              %(non_whitespace_escape_before)s
+                              (?P=quote)      # close quote if open quote used
+                            )
+                            (?<!(?<!\x00):) # no unescaped colon at end
+                            %(non_whitespace_escape_before)s
+                            [ ]?            # optional space
+                            :               # end of reference name
+                            ([ ]+|$)        # followed by whitespace
+                            """ % vars(Inliner), re.VERBOSE),
+          reference=re.compile(r"""
+                               (
+                                 (?P<simple>%(simplename)s)_
+                               |                  # *OR*
+                                 `                  # open backquote
+                                 (?![ ])            # not space
+                                 (?P<phrase>.+?)    # hyperlink phrase
+                                 %(non_whitespace_escape_before)s
+                                 `_                 # close backquote,
+                                                    # reference mark
+                               )
+                               $                  # end of string
+                               """ % vars(Inliner), re.VERBOSE),
+          substitution=re.compile(r"""
+                                  (
+                                    (?![ ])          # first char. not space
+                                    (?P<name>.+?)    # substitution text
+                                    %(non_whitespace_escape_before)s
+                                    \|               # close delimiter
+                                  )
+                                  ([ ]+|$)           # followed by whitespace
+                                  """ % vars(Inliner),
+                                  re.VERBOSE),)
+
+    def footnote(self, match):
+        src, srcline = self.state_machine.get_source_and_line()
+        (indented, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end())
+        label = match.group(1)
+        name = normalize_name(label)
+        footnote = nodes.footnote('\n'.join(indented))
+        footnote.source = src
+        footnote.line = srcline
+        if name[0] == '#':              # auto-numbered
+            name = name[1:]             # autonumber label
+            footnote['auto'] = 1
+            if name:
+                footnote['names'].append(name)
+            self.document.note_autofootnote(footnote)
+        elif name == '*':               # auto-symbol
+            name = ''
+            footnote['auto'] = '*'
+            self.document.note_symbol_footnote(footnote)
+        else:                           # manually numbered
+            footnote += nodes.label('', label)
+            footnote['names'].append(name)
+            self.document.note_footnote(footnote)
+        if name:
+            self.document.note_explicit_target(footnote, footnote)
+        else:
+            self.document.set_id(footnote, footnote)
+        if indented:
+            self.nested_parse(indented, input_offset=offset, node=footnote)
+        return [footnote], blank_finish
+
+    def citation(self, match):
+        src, srcline = self.state_machine.get_source_and_line()
+        (indented, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end())
+        label = match.group(1)
+        name = normalize_name(label)
+        citation = nodes.citation('\n'.join(indented))
+        citation.source = src
+        citation.line = srcline
+        citation += nodes.label('', label)
+        citation['names'].append(name)
+        self.document.note_citation(citation)
+        self.document.note_explicit_target(citation, citation)
+        if indented:
+            self.nested_parse(indented, input_offset=offset, node=citation)
+        return [citation], blank_finish
+
+    def hyperlink_target(self, match):
+        pattern = self.explicit.patterns.target
+        lineno = self.state_machine.abs_line_number()
+        (block, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(
+                 match.end(), until_blank=True, strip_indent=False)
+        blocktext = match.string[:match.end()] + '\n'.join(block)
+        block = [escape2null(line) for line in block]
+        escaped = block[0]
+        blockindex = 0
+        while True:
+            targetmatch = pattern.match(escaped)
+            if targetmatch:
+                break
+            blockindex += 1
+            try:
+                escaped += block[blockindex]
+            except IndexError:
+                raise MarkupError('malformed hyperlink target.')
+        del block[:blockindex]
+        block[0] = (block[0] + ' ')[targetmatch.end()-len(escaped)-1:].strip()
+        target = self.make_target(block, blocktext, lineno,
+                                  targetmatch.group('name'))
+        return [target], blank_finish
+
+    def make_target(self, block, block_text, lineno, target_name):
+        target_type, data = self.parse_target(block, block_text, lineno)
+        if target_type == 'refname':
+            target = nodes.target(block_text, '', refname=normalize_name(data))
+            target.indirect_reference_name = data
+            self.add_target(target_name, '', target, lineno)
+            self.document.note_indirect_target(target)
+            return target
+        elif target_type == 'refuri':
+            target = nodes.target(block_text, '')
+            self.add_target(target_name, data, target, lineno)
+            return target
+        else:
+            return data
+
+    def parse_target(self, block, block_text, lineno):
+        """
+        Determine the type of reference of a target.
+
+        :Return: A 2-tuple, one of:
+
+            - 'refname' and the indirect reference name
+            - 'refuri' and the URI
+            - 'malformed' and a system_message node
+        """
+        if block and block[-1].strip()[-1:] == '_':  # possible indirect target
+            reference = ' '.join(line.strip() for line in block)
+            refname = self.is_reference(reference)
+            if refname:
+                return 'refname', refname
+        ref_parts = split_escaped_whitespace(' '.join(block))
+        reference = ' '.join(''.join(unescape(part).split())
+                             for part in ref_parts)
+        return 'refuri', reference
+
+    def is_reference(self, reference):
+        match = self.explicit.patterns.reference.match(
+            whitespace_normalize_name(reference))
+        if not match:
+            return None
+        return unescape(match.group('simple') or match.group('phrase'))
+
+    def add_target(self, targetname, refuri, target, lineno):
+        target.line = lineno
+        if targetname:
+            name = normalize_name(unescape(targetname))
+            target['names'].append(name)
+            if refuri:
+                uri = self.inliner.adjust_uri(refuri)
+                if uri:
+                    target['refuri'] = uri
+                else:
+                    raise ApplicationError('problem with URI: %r' % refuri)
+            self.document.note_explicit_target(target, self.parent)
+        else:                       # anonymous target
+            if refuri:
+                target['refuri'] = refuri
+            target['anonymous'] = 1
+            self.document.note_anonymous_target(target)
+
+    def substitution_def(self, match):
+        pattern = self.explicit.patterns.substitution
+        src, srcline = self.state_machine.get_source_and_line()
+        (block, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end(),
+                                                         strip_indent=False)
+        blocktext = (match.string[:match.end()] + '\n'.join(block))
+        block.disconnect()
+        escaped = escape2null(block[0].rstrip())
+        blockindex = 0
+        while True:
+            subdefmatch = pattern.match(escaped)
+            if subdefmatch:
+                break
+            blockindex += 1
+            try:
+                escaped = escaped + ' ' + escape2null(
+                                              block[blockindex].strip())
+            except IndexError:
+                raise MarkupError('malformed substitution definition.')
+        del block[:blockindex]          # strip out the substitution marker
+        start = subdefmatch.end()-len(escaped)-1
+        block[0] = (block[0].strip() + ' ')[start:-1]
+        if not block[0]:
+            del block[0]
+            offset += 1
+        while block and not block[-1].strip():
+            block.pop()
+        subname = subdefmatch.group('name')
+        substitution_node = nodes.substitution_definition(blocktext)
+        substitution_node.source = src
+        substitution_node.line = srcline
+        if not block:
+            msg = self.reporter.warning(
+                'Substitution definition "%s" missing contents.' % subname,
+                nodes.literal_block(blocktext, blocktext),
+                source=src, line=srcline)
+            return [msg], blank_finish
+        block[0] = block[0].strip()
+        substitution_node['names'].append(
+            nodes.whitespace_normalize_name(subname))
+        new_abs_offset, blank_finish = self.nested_list_parse(
+              block, input_offset=offset, node=substitution_node,
+              initial_state='SubstitutionDef', blank_finish=blank_finish)
+        i = 0
+        for node in substitution_node[:]:
+            if not (isinstance(node, nodes.Inline)
+                    or isinstance(node, nodes.Text)):
+                self.parent += substitution_node[i]
+                del substitution_node[i]
+            else:
+                i += 1
+        for node in substitution_node.findall(nodes.Element):
+            if self.disallowed_inside_substitution_definitions(node):
+                pformat = nodes.literal_block('', node.pformat().rstrip())
+                msg = self.reporter.error(
+                    'Substitution definition contains illegal element <%s>:'
+                    % node.tagname,
+                    pformat, nodes.literal_block(blocktext, blocktext),
+                    source=src, line=srcline)
+                return [msg], blank_finish
+        if len(substitution_node) == 0:
+            msg = self.reporter.warning(
+                  'Substitution definition "%s" empty or invalid.' % subname,
+                  nodes.literal_block(blocktext, blocktext),
+                  source=src, line=srcline)
+            return [msg], blank_finish
+        self.document.note_substitution_def(
+            substitution_node, subname, self.parent)
+        return [substitution_node], blank_finish
+
+    def disallowed_inside_substitution_definitions(self, node):
+        if (node['ids']
+            or isinstance(node, nodes.reference) and node.get('anonymous')
+            or isinstance(node, nodes.footnote_reference) and node.get('auto')):  # noqa: E501
+            return True
+        else:
+            return False
+
+    def directive(self, match, **option_presets):
+        """Returns a 2-tuple: list of nodes, and a "blank finish" boolean."""
+        type_name = match.group(1)
+        directive_class, messages = directives.directive(
+            type_name, self.memo.language, self.document)
+        self.parent += messages
+        if directive_class:
+            return self.run_directive(
+                directive_class, match, type_name, option_presets)
+        else:
+            return self.unknown_directive(type_name)
+
+    def run_directive(self, directive, match, type_name, option_presets):
+        """
+        Parse a directive then run its directive function.
+
+        Parameters:
+
+        - `directive`: The class implementing the directive.  Must be
+          a subclass of `rst.Directive`.
+
+        - `match`: A regular expression match object which matched the first
+          line of the directive.
+
+        - `type_name`: The directive name, as used in the source text.
+
+        - `option_presets`: A dictionary of preset options, defaults for the
+          directive options.  Currently, only an "alt" option is passed by
+          substitution definitions (value: the substitution name), which may
+          be used by an embedded image directive.
+
+        Returns a 2-tuple: list of nodes, and a "blank finish" boolean.
+        """
+        if isinstance(directive, (FunctionType, MethodType)):
+            from docutils.parsers.rst import convert_directive_function
+            directive = convert_directive_function(directive)
+        lineno = self.state_machine.abs_line_number()
+        initial_line_offset = self.state_machine.line_offset
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end(),
+                                                         strip_top=0)
+        block_text = '\n'.join(self.state_machine.input_lines[
+            initial_line_offset : self.state_machine.line_offset + 1])  # noqa: E203,E501
+        try:
+            arguments, options, content, content_offset = (
+                self.parse_directive_block(indented, line_offset,
+                                           directive, option_presets))
+        except MarkupError as detail:
+            error = self.reporter.error(
+                'Error in "%s" directive:\n%s.' % (type_name,
+                                                   ' '.join(detail.args)),
+                nodes.literal_block(block_text, block_text), line=lineno)
+            return [error], blank_finish
+        directive_instance = directive(
+            type_name, arguments, options, content, lineno,
+            content_offset, block_text, self, self.state_machine)
+        try:
+            result = directive_instance.run()
+        except docutils.parsers.rst.DirectiveError as error:
+            msg_node = self.reporter.system_message(error.level, error.msg,
+                                                    line=lineno)
+            msg_node += nodes.literal_block(block_text, block_text)
+            result = [msg_node]
+        assert isinstance(result, list), \
+               'Directive "%s" must return a list of nodes.' % type_name
+        for i in range(len(result)):
+            assert isinstance(result[i], nodes.Node), \
+                   ('Directive "%s" returned non-Node object (index %s): %r'
+                    % (type_name, i, result[i]))
+        return (result,
+                blank_finish or self.state_machine.is_next_line_blank())
+
+    def parse_directive_block(self, indented, line_offset, directive,
+                              option_presets):
+        option_spec = directive.option_spec
+        has_content = directive.has_content
+        if indented and not indented[0].strip():
+            indented.trim_start()
+            line_offset += 1
+        while indented and not indented[-1].strip():
+            indented.trim_end()
+        if indented and (directive.required_arguments
+                         or directive.optional_arguments
+                         or option_spec):
+            for i, line in enumerate(indented):
+                if not line.strip():
+                    break
+            else:
+                i += 1
+            arg_block = indented[:i]
+            content = indented[i+1:]
+            content_offset = line_offset + i + 1
+        else:
+            content = indented
+            content_offset = line_offset
+            arg_block = []
+        if option_spec:
+            options, arg_block = self.parse_directive_options(
+                option_presets, option_spec, arg_block)
+        else:
+            options = {}
+        if arg_block and not (directive.required_arguments
+                              or directive.optional_arguments):
+            content = arg_block + indented[i:]
+            content_offset = line_offset
+            arg_block = []
+        while content and not content[0].strip():
+            content.trim_start()
+            content_offset += 1
+        if directive.required_arguments or directive.optional_arguments:
+            arguments = self.parse_directive_arguments(
+                directive, arg_block)
+        else:
+            arguments = []
+        if content and not has_content:
+            raise MarkupError('no content permitted')
+        return arguments, options, content, content_offset
+
+    def parse_directive_options(self, option_presets, option_spec, arg_block):
+        options = option_presets.copy()
+        for i, line in enumerate(arg_block):
+            if re.match(Body.patterns['field_marker'], line):
+                opt_block = arg_block[i:]
+                arg_block = arg_block[:i]
+                break
+        else:
+            opt_block = []
+        if opt_block:
+            success, data = self.parse_extension_options(option_spec,
+                                                         opt_block)
+            if success:                 # data is a dict of options
+                options.update(data)
+            else:                       # data is an error string
+                raise MarkupError(data)
+        return options, arg_block
+
+    def parse_directive_arguments(self, directive, arg_block):
+        required = directive.required_arguments
+        optional = directive.optional_arguments
+        arg_text = '\n'.join(arg_block)
+        arguments = arg_text.split()
+        if len(arguments) < required:
+            raise MarkupError('%s argument(s) required, %s supplied'
+                              % (required, len(arguments)))
+        elif len(arguments) > required + optional:
+            if directive.final_argument_whitespace:
+                arguments = arg_text.split(None, required + optional - 1)
+            else:
+                raise MarkupError(
+                    'maximum %s argument(s) allowed, %s supplied'
+                    % (required + optional, len(arguments)))
+        return arguments
+
+    def parse_extension_options(self, option_spec, datalines):
+        """
+        Parse `datalines` for a field list containing extension options
+        matching `option_spec`.
+
+        :Parameters:
+            - `option_spec`: a mapping of option name to conversion
+              function, which should raise an exception on bad input.
+            - `datalines`: a list of input strings.
+
+        :Return:
+            - Success value, 1 or 0.
+            - An option dictionary on success, an error string on failure.
+        """
+        node = nodes.field_list()
+        newline_offset, blank_finish = self.nested_list_parse(
+              datalines, 0, node, initial_state='ExtensionOptions',
+              blank_finish=True)
+        if newline_offset != len(datalines):  # incomplete parse of block
+            return 0, 'invalid option block'
+        try:
+            options = utils.extract_extension_options(node, option_spec)
+        except KeyError as detail:
+            return 0, 'unknown option: "%s"' % detail.args[0]
+        except (ValueError, TypeError) as detail:
+            return 0, 'invalid option value: %s' % ' '.join(detail.args)
+        except utils.ExtensionOptionError as detail:
+            return 0, 'invalid option data: %s' % ' '.join(detail.args)
+        if blank_finish:
+            return 1, options
+        else:
+            return 0, 'option data incompletely parsed'
+
+    def unknown_directive(self, type_name):
+        lineno = self.state_machine.abs_line_number()
+        (indented, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(0, strip_indent=False)
+        text = '\n'.join(indented)
+        error = self.reporter.error('Unknown directive type "%s".' % type_name,
+                                    nodes.literal_block(text, text),
+                                    line=lineno)
+        return [error], blank_finish
+
+    def comment(self, match):
+        if self.state_machine.is_next_line_blank():
+            first_comment_line = match.string[match.end():]
+            if not first_comment_line.strip():  # empty comment
+                return [nodes.comment()], True  # "A tiny but practical wart."
+            if first_comment_line.startswith('end of inclusion from "'):
+                # cf. parsers.rst.directives.misc.Include
+                self.document.include_log.pop()
+                return [], True
+        (indented, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end())
+        while indented and not indented[-1].strip():
+            indented.trim_end()
+        text = '\n'.join(indented)
+        return [nodes.comment(text, text)], blank_finish
+
+    explicit.constructs = [
+          (footnote,
+           re.compile(r"""
+                      \.\.[ ]+          # explicit markup start
+                      \[
+                      (                 # footnote label:
+                          [0-9]+          # manually numbered footnote
+                        |               # *OR*
+                          \#              # anonymous auto-numbered footnote
+                        |               # *OR*
+                          \#%s            # auto-number ed?) footnote label
+                        |               # *OR*
+                          \*              # auto-symbol footnote
+                      )
+                      \]
+                      ([ ]+|$)          # whitespace or end of line
+                      """ % Inliner.simplename, re.VERBOSE)),
+          (citation,
+           re.compile(r"""
+                      \.\.[ ]+          # explicit markup start
+                      \[(%s)\]          # citation label
+                      ([ ]+|$)          # whitespace or end of line
+                      """ % Inliner.simplename, re.VERBOSE)),
+          (hyperlink_target,
+           re.compile(r"""
+                      \.\.[ ]+          # explicit markup start
+                      _                 # target indicator
+                      (?![ ]|$)         # first char. not space or EOL
+                      """, re.VERBOSE)),
+          (substitution_def,
+           re.compile(r"""
+                      \.\.[ ]+          # explicit markup start
+                      \|                # substitution indicator
+                      (?![ ]|$)         # first char. not space or EOL
+                      """, re.VERBOSE)),
+          (directive,
+           re.compile(r"""
+                      \.\.[ ]+          # explicit markup start
+                      (%s)              # directive name
+                      [ ]?              # optional space
+                      ::                # directive delimiter
+                      ([ ]+|$)          # whitespace or end of line
+                      """ % Inliner.simplename, re.VERBOSE))]
+
+    def explicit_markup(self, match, context, next_state):
+        """Footnotes, hyperlink targets, directives, comments."""
+        nodelist, blank_finish = self.explicit_construct(match)
+        self.parent += nodelist
+        self.explicit_list(blank_finish)
+        return [], next_state, []
+
+    def explicit_construct(self, match):
+        """Determine which explicit construct this is, parse & return it."""
+        errors = []
+        for method, pattern in self.explicit.constructs:
+            expmatch = pattern.match(match.string)
+            if expmatch:
+                try:
+                    return method(self, expmatch)
+                except MarkupError as error:
+                    lineno = self.state_machine.abs_line_number()
+                    message = ' '.join(error.args)
+                    errors.append(self.reporter.warning(message, line=lineno))
+                    break
+        nodelist, blank_finish = self.comment(match)
+        return nodelist + errors, blank_finish
+
+    def explicit_list(self, blank_finish):
+        """
+        Create a nested state machine for a series of explicit markup
+        constructs (including anonymous hyperlink targets).
+        """
+        offset = self.state_machine.line_offset + 1   # next line
+        newline_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=self.parent, initial_state='Explicit',
+              blank_finish=blank_finish,
+              match_titles=self.state_machine.match_titles)
+        self.goto_line(newline_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning('Explicit markup')
+
+    def anonymous(self, match, context, next_state):
+        """Anonymous hyperlink targets."""
+        nodelist, blank_finish = self.anonymous_target(match)
+        self.parent += nodelist
+        self.explicit_list(blank_finish)
+        return [], next_state, []
+
+    def anonymous_target(self, match):
+        lineno = self.state_machine.abs_line_number()
+        (block, indent, offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end(),
+                                                         until_blank=True)
+        blocktext = match.string[:match.end()] + '\n'.join(block)
+        block = [escape2null(line) for line in block]
+        target = self.make_target(block, blocktext, lineno, '')
+        return [target], blank_finish
+
+    def line(self, match, context, next_state):
+        """Section title overline or transition marker."""
+        if self.state_machine.match_titles:
+            return [match.string], 'Line', []
+        elif match.string.strip() == '::':
+            raise statemachine.TransitionCorrection('text')
+        elif len(match.string.strip()) < 4:
+            msg = self.reporter.info(
+                'Unexpected possible title overline or transition.\n'
+                "Treating it as ordinary text because it's so short.",
+                line=self.state_machine.abs_line_number())
+            self.parent += msg
+            raise statemachine.TransitionCorrection('text')
+        else:
+            blocktext = self.state_machine.line
+            msg = self.reporter.severe(
+                  'Unexpected section title or transition.',
+                  nodes.literal_block(blocktext, blocktext),
+                  line=self.state_machine.abs_line_number())
+            self.parent += msg
+            return [], next_state, []
+
+    def text(self, match, context, next_state):
+        """Titles, definition lists, paragraphs."""
+        return [match.string], 'Text', []
+
+
+class RFC2822Body(Body):
+
+    """
+    RFC2822 headers are only valid as the first constructs in documents.  As
+    soon as anything else appears, the `Body` state should take over.
+    """
+
+    patterns = Body.patterns.copy()     # can't modify the original
+    patterns['rfc2822'] = r'[!-9;-~]+:( +|$)'
+    initial_transitions = [(name, 'Body')
+                           for name in Body.initial_transitions]
+    initial_transitions.insert(-1, ('rfc2822', 'Body'))  # just before 'text'
+
+    def rfc2822(self, match, context, next_state):
+        """RFC2822-style field list item."""
+        fieldlist = nodes.field_list(classes=['rfc2822'])
+        self.parent += fieldlist
+        field, blank_finish = self.rfc2822_field(match)
+        fieldlist += field
+        offset = self.state_machine.line_offset + 1  # next line
+        newline_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=fieldlist, initial_state='RFC2822List',
+              blank_finish=blank_finish)
+        self.goto_line(newline_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning(
+                  'RFC2822-style field list')
+        return [], next_state, []
+
+    def rfc2822_field(self, match):
+        name = match.string[:match.string.find(':')]
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_first_known_indented(match.end(),
+                                                         until_blank=True)
+        fieldnode = nodes.field()
+        fieldnode += nodes.field_name(name, name)
+        fieldbody = nodes.field_body('\n'.join(indented))
+        fieldnode += fieldbody
+        if indented:
+            self.nested_parse(indented, input_offset=line_offset,
+                              node=fieldbody)
+        return fieldnode, blank_finish
+
+
+class SpecializedBody(Body):
+
+    """
+    Superclass for second and subsequent compound element members.  Compound
+    elements are lists and list-like constructs.
+
+    All transition methods are disabled (redefined as `invalid_input`).
+    Override individual methods in subclasses to re-enable.
+
+    For example, once an initial bullet list item, say, is recognized, the
+    `BulletList` subclass takes over, with a "bullet_list" node as its
+    container.  Upon encountering the initial bullet list item, `Body.bullet`
+    calls its ``self.nested_list_parse`` (`RSTState.nested_list_parse`), which
+    starts up a nested parsing session with `BulletList` as the initial state.
+    Only the ``bullet`` transition method is enabled in `BulletList`; as long
+    as only bullet list items are encountered, they are parsed and inserted
+    into the container.  The first construct which is *not* a bullet list item
+    triggers the `invalid_input` method, which ends the nested parse and
+    closes the container.  `BulletList` needs to recognize input that is
+    invalid in the context of a bullet list, which means everything *other
+    than* bullet list items, so it inherits the transition list created in
+    `Body`.
+    """
+
+    def invalid_input(self, match=None, context=None, next_state=None):
+        """Not a compound element member. Abort this state machine."""
+        self.state_machine.previous_line()  # back up so parent SM can reassess
+        raise EOFError
+
+    indent = invalid_input
+    bullet = invalid_input
+    enumerator = invalid_input
+    field_marker = invalid_input
+    option_marker = invalid_input
+    doctest = invalid_input
+    line_block = invalid_input
+    grid_table_top = invalid_input
+    simple_table_top = invalid_input
+    explicit_markup = invalid_input
+    anonymous = invalid_input
+    line = invalid_input
+    text = invalid_input
+
+
+class BulletList(SpecializedBody):
+
+    """Second and subsequent bullet_list list_items."""
+
+    def bullet(self, match, context, next_state):
+        """Bullet list item."""
+        if match.string[0] != self.parent['bullet']:
+            # different bullet: new list
+            self.invalid_input()
+        listitem, blank_finish = self.list_item(match.end())
+        self.parent += listitem
+        self.blank_finish = blank_finish
+        return [], next_state, []
+
+
+class DefinitionList(SpecializedBody):
+
+    """Second and subsequent definition_list_items."""
+
+    def text(self, match, context, next_state):
+        """Definition lists."""
+        return [match.string], 'Definition', []
+
+
+class EnumeratedList(SpecializedBody):
+
+    """Second and subsequent enumerated_list list_items."""
+
+    def enumerator(self, match, context, next_state):
+        """Enumerated list item."""
+        format, sequence, text, ordinal = self.parse_enumerator(
+              match, self.parent['enumtype'])
+        if (format != self.format
+            or (sequence != '#' and (sequence != self.parent['enumtype']
+                                     or self.auto
+                                     or ordinal != (self.lastordinal + 1)))
+            or not self.is_enumerated_list_item(ordinal, sequence, format)):
+            # different enumeration: new list
+            self.invalid_input()
+        if sequence == '#':
+            self.auto = 1
+        listitem, blank_finish = self.list_item(match.end())
+        self.parent += listitem
+        self.blank_finish = blank_finish
+        self.lastordinal = ordinal
+        return [], next_state, []
+
+
+class FieldList(SpecializedBody):
+
+    """Second and subsequent field_list fields."""
+
+    def field_marker(self, match, context, next_state):
+        """Field list field."""
+        field, blank_finish = self.field(match)
+        self.parent += field
+        self.blank_finish = blank_finish
+        return [], next_state, []
+
+
+class OptionList(SpecializedBody):
+
+    """Second and subsequent option_list option_list_items."""
+
+    def option_marker(self, match, context, next_state):
+        """Option list item."""
+        try:
+            option_list_item, blank_finish = self.option_list_item(match)
+        except MarkupError:
+            self.invalid_input()
+        self.parent += option_list_item
+        self.blank_finish = blank_finish
+        return [], next_state, []
+
+
+class RFC2822List(SpecializedBody, RFC2822Body):
+
+    """Second and subsequent RFC2822-style field_list fields."""
+
+    patterns = RFC2822Body.patterns
+    initial_transitions = RFC2822Body.initial_transitions
+
+    def rfc2822(self, match, context, next_state):
+        """RFC2822-style field list item."""
+        field, blank_finish = self.rfc2822_field(match)
+        self.parent += field
+        self.blank_finish = blank_finish
+        return [], 'RFC2822List', []
+
+    blank = SpecializedBody.invalid_input
+
+
+class ExtensionOptions(FieldList):
+
+    """
+    Parse field_list fields for extension options.
+
+    No nested parsing is done (including inline markup parsing).
+    """
+
+    def parse_field_body(self, indented, offset, node):
+        """Override `Body.parse_field_body` for simpler parsing."""
+        lines = []
+        for line in list(indented) + ['']:
+            if line.strip():
+                lines.append(line)
+            elif lines:
+                text = '\n'.join(lines)
+                node += nodes.paragraph(text, text)
+                lines = []
+
+
+class LineBlock(SpecializedBody):
+
+    """Second and subsequent lines of a line_block."""
+
+    blank = SpecializedBody.invalid_input
+
+    def line_block(self, match, context, next_state):
+        """New line of line block."""
+        lineno = self.state_machine.abs_line_number()
+        line, messages, blank_finish = self.line_block_line(match, lineno)
+        self.parent += line
+        self.parent.parent += messages
+        self.blank_finish = blank_finish
+        return [], next_state, []
+
+
+class Explicit(SpecializedBody):
+
+    """Second and subsequent explicit markup construct."""
+
+    def explicit_markup(self, match, context, next_state):
+        """Footnotes, hyperlink targets, directives, comments."""
+        nodelist, blank_finish = self.explicit_construct(match)
+        self.parent += nodelist
+        self.blank_finish = blank_finish
+        return [], next_state, []
+
+    def anonymous(self, match, context, next_state):
+        """Anonymous hyperlink targets."""
+        nodelist, blank_finish = self.anonymous_target(match)
+        self.parent += nodelist
+        self.blank_finish = blank_finish
+        return [], next_state, []
+
+    blank = SpecializedBody.invalid_input
+
+
+class SubstitutionDef(Body):
+
+    """
+    Parser for the contents of a substitution_definition element.
+    """
+
+    patterns = {
+          'embedded_directive': re.compile(r'(%s)::( +|$)'
+                                           % Inliner.simplename),
+          'text': r''}
+    initial_transitions = ['embedded_directive', 'text']
+
+    def embedded_directive(self, match, context, next_state):
+        nodelist, blank_finish = self.directive(match,
+                                                alt=self.parent['names'][0])
+        self.parent += nodelist
+        if not self.state_machine.at_eof():
+            self.blank_finish = blank_finish
+        raise EOFError
+
+    def text(self, match, context, next_state):
+        if not self.state_machine.at_eof():
+            self.blank_finish = self.state_machine.is_next_line_blank()
+        raise EOFError
+
+
+class Text(RSTState):
+
+    """
+    Classifier of second line of a text block.
+
+    Could be a paragraph, a definition list item, or a title.
+    """
+
+    patterns = {'underline': Body.patterns['line'],
+                'text': r''}
+    initial_transitions = [('underline', 'Body'), ('text', 'Body')]
+
+    def blank(self, match, context, next_state):
+        """End of paragraph."""
+        # NOTE: self.paragraph returns [node, system_message(s)], literalnext
+        paragraph, literalnext = self.paragraph(
+              context, self.state_machine.abs_line_number() - 1)
+        self.parent += paragraph
+        if literalnext:
+            self.parent += self.literal_block()
+        return [], 'Body', []
+
+    def eof(self, context):
+        if context:
+            self.blank(None, context, None)
+        return []
+
+    def indent(self, match, context, next_state):
+        """Definition list item."""
+        dl = nodes.definition_list()
+        # the definition list starts on the line before the indent:
+        lineno = self.state_machine.abs_line_number() - 1
+        dl.source, dl.line = self.state_machine.get_source_and_line(lineno)
+        dl_item, blank_finish = self.definition_list_item(context)
+        dl += dl_item
+        self.parent += dl
+        offset = self.state_machine.line_offset + 1   # next line
+        newline_offset, blank_finish = self.nested_list_parse(
+              self.state_machine.input_lines[offset:],
+              input_offset=self.state_machine.abs_line_offset() + 1,
+              node=dl, initial_state='DefinitionList',
+              blank_finish=blank_finish, blank_finish_state='Definition')
+        self.goto_line(newline_offset)
+        if not blank_finish:
+            self.parent += self.unindent_warning('Definition list')
+        return [], 'Body', []
+
+    def underline(self, match, context, next_state):
+        """Section title."""
+        lineno = self.state_machine.abs_line_number()
+        title = context[0].rstrip()
+        underline = match.string.rstrip()
+        source = title + '\n' + underline
+        messages = []
+        if column_width(title) > len(underline):
+            if len(underline) < 4:
+                if self.state_machine.match_titles:
+                    msg = self.reporter.info(
+                        'Possible title underline, too short for the title.\n'
+                        "Treating it as ordinary text because it's so short.",
+                        line=lineno)
+                    self.parent += msg
+                raise statemachine.TransitionCorrection('text')
+            else:
+                blocktext = context[0] + '\n' + self.state_machine.line
+                msg = self.reporter.warning(
+                    'Title underline too short.',
+                    nodes.literal_block(blocktext, blocktext),
+                    line=lineno)
+                messages.append(msg)
+        if not self.state_machine.match_titles:
+            blocktext = context[0] + '\n' + self.state_machine.line
+            # We need get_source_and_line() here to report correctly
+            src, srcline = self.state_machine.get_source_and_line()
+            # TODO: why is abs_line_number() == srcline+1
+            # if the error is in a table (try with test_tables.py)?
+            # print("get_source_and_line", srcline)
+            # print("abs_line_number", self.state_machine.abs_line_number())
+            msg = self.reporter.severe(
+                'Unexpected section title.',
+                nodes.literal_block(blocktext, blocktext),
+                source=src, line=srcline)
+            self.parent += messages
+            self.parent += msg
+            return [], next_state, []
+        style = underline[0]
+        context[:] = []
+        self.section(title, source, style, lineno - 1, messages)
+        return [], next_state, []
+
+    def text(self, match, context, next_state):
+        """Paragraph."""
+        startline = self.state_machine.abs_line_number() - 1
+        msg = None
+        try:
+            block = self.state_machine.get_text_block(flush_left=True)
+        except statemachine.UnexpectedIndentationError as err:
+            block, src, srcline = err.args
+            msg = self.reporter.error('Unexpected indentation.',
+                                      source=src, line=srcline)
+        lines = context + list(block)
+        paragraph, literalnext = self.paragraph(lines, startline)
+        self.parent += paragraph
+        self.parent += msg
+        if literalnext:
+            try:
+                self.state_machine.next_line()
+            except EOFError:
+                pass
+            self.parent += self.literal_block()
+        return [], next_state, []
+
+    def literal_block(self):
+        """Return a list of nodes."""
+        (indented, indent, offset, blank_finish
+         ) = self.state_machine.get_indented()
+        while indented and not indented[-1].strip():
+            indented.trim_end()
+        if not indented:
+            return self.quoted_literal_block()
+        data = '\n'.join(indented)
+        literal_block = nodes.literal_block(data, data)
+        (literal_block.source,
+         literal_block.line) = self.state_machine.get_source_and_line(offset+1)
+        nodelist = [literal_block]
+        if not blank_finish:
+            nodelist.append(self.unindent_warning('Literal block'))
+        return nodelist
+
+    def quoted_literal_block(self):
+        abs_line_offset = self.state_machine.abs_line_offset()
+        offset = self.state_machine.line_offset
+        parent_node = nodes.Element()
+        new_abs_offset = self.nested_parse(
+            self.state_machine.input_lines[offset:],
+            input_offset=abs_line_offset, node=parent_node, match_titles=False,
+            state_machine_kwargs={'state_classes': (QuotedLiteralBlock,),
+                                  'initial_state': 'QuotedLiteralBlock'})
+        self.goto_line(new_abs_offset)
+        return parent_node.children
+
+    def definition_list_item(self, termline):
+        # the parser is already on the second (indented) line:
+        dd_lineno = self.state_machine.abs_line_number()
+        dt_lineno = dd_lineno - 1
+        (indented, indent, line_offset, blank_finish
+         ) = self.state_machine.get_indented()
+        dl_item = nodes.definition_list_item(
+                      '\n'.join(termline + list(indented)))
+        (dl_item.source,
+         dl_item.line) = self.state_machine.get_source_and_line(dt_lineno)
+        dt_nodes, messages = self.term(termline, dt_lineno)
+        dl_item += dt_nodes
+        dd = nodes.definition('', *messages)
+        dd.source, dd.line = self.state_machine.get_source_and_line(dd_lineno)
+        dl_item += dd
+        if termline[0][-2:] == '::':
+            dd += self.reporter.info(
+                  'Blank line missing before literal block (after the "::")? '
+                  'Interpreted as a definition list item.',
+                  line=dd_lineno)
+        # TODO: drop a definition if it is an empty comment to allow
+        #       definition list items with several terms?
+        #       https://sourceforge.net/p/docutils/feature-requests/60/
+        self.nested_parse(indented, input_offset=line_offset, node=dd)
+        return dl_item, blank_finish
+
+    classifier_delimiter = re.compile(' +: +')
+
+    def term(self, lines, lineno):
+        """Return a definition_list's term and optional classifiers."""
+        assert len(lines) == 1
+        text_nodes, messages = self.inline_text(lines[0], lineno)
+        dt = nodes.term(lines[0])
+        dt.source, dt.line = self.state_machine.get_source_and_line(lineno)
+        node_list = [dt]
+        for i in range(len(text_nodes)):
+            node = text_nodes[i]
+            if isinstance(node, nodes.Text):
+                parts = self.classifier_delimiter.split(node)
+                if len(parts) == 1:
+                    node_list[-1] += node
+                else:
+                    text = parts[0].rstrip()
+                    textnode = nodes.Text(text)
+                    node_list[-1] += textnode
+                    for part in parts[1:]:
+                        node_list.append(
+                            nodes.classifier(unescape(part, True), part))
+            else:
+                node_list[-1] += node
+        return node_list, messages
+
+
+class SpecializedText(Text):
+
+    """
+    Superclass for second and subsequent lines of Text-variants.
+
+    All transition methods are disabled. Override individual methods in
+    subclasses to re-enable.
+    """
+
+    def eof(self, context):
+        """Incomplete construct."""
+        return []
+
+    def invalid_input(self, match=None, context=None, next_state=None):
+        """Not a compound element member. Abort this state machine."""
+        raise EOFError
+
+    blank = invalid_input
+    indent = invalid_input
+    underline = invalid_input
+    text = invalid_input
+
+
+class Definition(SpecializedText):
+
+    """Second line of potential definition_list_item."""
+
+    def eof(self, context):
+        """Not a definition."""
+        self.state_machine.previous_line(2)  # so parent SM can reassess
+        return []
+
+    def indent(self, match, context, next_state):
+        """Definition list item."""
+        dl_item, blank_finish = self.definition_list_item(context)
+        self.parent += dl_item
+        self.blank_finish = blank_finish
+        return [], 'DefinitionList', []
+
+
+class Line(SpecializedText):
+
+    """
+    Second line of over- & underlined section title or transition marker.
+    """
+
+    eofcheck = 1                        # @@@ ???
+    """Set to 0 while parsing sections, so that we don't catch the EOF."""
+
+    def eof(self, context):
+        """Transition marker at end of section or document."""
+        marker = context[0].strip()
+        if self.memo.section_bubble_up_kludge:
+            self.memo.section_bubble_up_kludge = False
+        elif len(marker) < 4:
+            self.state_correction(context)
+        if self.eofcheck:               # ignore EOFError with sections
+            src, srcline = self.state_machine.get_source_and_line()
+            # lineno = self.state_machine.abs_line_number() - 1
+            transition = nodes.transition(rawsource=context[0])
+            transition.source = src
+            transition.line = srcline - 1
+            # transition.line = lineno
+            self.parent += transition
+        self.eofcheck = 1
+        return []
+
+    def blank(self, match, context, next_state):
+        """Transition marker."""
+        src, srcline = self.state_machine.get_source_and_line()
+        marker = context[0].strip()
+        if len(marker) < 4:
+            self.state_correction(context)
+        transition = nodes.transition(rawsource=marker)
+        transition.source = src
+        transition.line = srcline - 1
+        self.parent += transition
+        return [], 'Body', []
+
+    def text(self, match, context, next_state):
+        """Potential over- & underlined title."""
+        lineno = self.state_machine.abs_line_number() - 1
+        overline = context[0]
+        title = match.string
+        underline = ''
+        try:
+            underline = self.state_machine.next_line()
+        except EOFError:
+            blocktext = overline + '\n' + title
+            if len(overline.rstrip()) < 4:
+                self.short_overline(context, blocktext, lineno, 2)
+            else:
+                msg = self.reporter.severe(
+                    'Incomplete section title.',
+                    nodes.literal_block(blocktext, blocktext),
+                    line=lineno)
+                self.parent += msg
+                return [], 'Body', []
+        source = '%s\n%s\n%s' % (overline, title, underline)
+        overline = overline.rstrip()
+        underline = underline.rstrip()
+        if not self.transitions['underline'][0].match(underline):
+            blocktext = overline + '\n' + title + '\n' + underline
+            if len(overline.rstrip()) < 4:
+                self.short_overline(context, blocktext, lineno, 2)
+            else:
+                msg = self.reporter.severe(
+                    'Missing matching underline for section title overline.',
+                    nodes.literal_block(source, source),
+                    line=lineno)
+                self.parent += msg
+                return [], 'Body', []
+        elif overline != underline:
+            blocktext = overline + '\n' + title + '\n' + underline
+            if len(overline.rstrip()) < 4:
+                self.short_overline(context, blocktext, lineno, 2)
+            else:
+                msg = self.reporter.severe(
+                      'Title overline & underline mismatch.',
+                      nodes.literal_block(source, source),
+                      line=lineno)
+                self.parent += msg
+                return [], 'Body', []
+        title = title.rstrip()
+        messages = []
+        if column_width(title) > len(overline):
+            blocktext = overline + '\n' + title + '\n' + underline
+            if len(overline.rstrip()) < 4:
+                self.short_overline(context, blocktext, lineno, 2)
+            else:
+                msg = self.reporter.warning(
+                      'Title overline too short.',
+                      nodes.literal_block(source, source),
+                      line=lineno)
+                messages.append(msg)
+        style = (overline[0], underline[0])
+        self.eofcheck = 0               # @@@ not sure this is correct
+        self.section(title.lstrip(), source, style, lineno + 1, messages)
+        self.eofcheck = 1
+        return [], 'Body', []
+
+    indent = text                       # indented title
+
+    def underline(self, match, context, next_state):
+        overline = context[0]
+        blocktext = overline + '\n' + self.state_machine.line
+        lineno = self.state_machine.abs_line_number() - 1
+        if len(overline.rstrip()) < 4:
+            self.short_overline(context, blocktext, lineno, 1)
+        msg = self.reporter.error(
+              'Invalid section title or transition marker.',
+              nodes.literal_block(blocktext, blocktext),
+              line=lineno)
+        self.parent += msg
+        return [], 'Body', []
+
+    def short_overline(self, context, blocktext, lineno, lines=1):
+        msg = self.reporter.info(
+            'Possible incomplete section title.\nTreating the overline as '
+            "ordinary text because it's so short.",
+            line=lineno)
+        self.parent += msg
+        self.state_correction(context, lines)
+
+    def state_correction(self, context, lines=1):
+        self.state_machine.previous_line(lines)
+        context[:] = []
+        raise statemachine.StateCorrection('Body', 'text')
+
+
+class QuotedLiteralBlock(RSTState):
+
+    """
+    Nested parse handler for quoted (unindented) literal blocks.
+
+    Special-purpose.  Not for inclusion in `state_classes`.
+    """
+
+    patterns = {'initial_quoted': r'(%(nonalphanum7bit)s)' % Body.pats,
+                'text': r''}
+    initial_transitions = ('initial_quoted', 'text')
+
+    def __init__(self, state_machine, debug=False):
+        RSTState.__init__(self, state_machine, debug)
+        self.messages = []
+        self.initial_lineno = None
+
+    def blank(self, match, context, next_state):
+        if context:
+            raise EOFError
+        else:
+            return context, next_state, []
+
+    def eof(self, context):
+        if context:
+            src, srcline = self.state_machine.get_source_and_line(
+                                                        self.initial_lineno)
+            text = '\n'.join(context)
+            literal_block = nodes.literal_block(text, text)
+            literal_block.source = src
+            literal_block.line = srcline
+            self.parent += literal_block
+        else:
+            self.parent += self.reporter.warning(
+                'Literal block expected; none found.',
+                line=self.state_machine.abs_line_number()
+                )  # src not available, statemachine.input_lines is empty
+            self.state_machine.previous_line()
+        self.parent += self.messages
+        return []
+
+    def indent(self, match, context, next_state):
+        assert context, ('QuotedLiteralBlock.indent: context should not '
+                         'be empty!')
+        self.messages.append(
+            self.reporter.error('Unexpected indentation.',
+                                line=self.state_machine.abs_line_number()))
+        self.state_machine.previous_line()
+        raise EOFError
+
+    def initial_quoted(self, match, context, next_state):
+        """Match arbitrary quote character on the first line only."""
+        self.remove_transition('initial_quoted')
+        quote = match.string[0]
+        pattern = re.compile(re.escape(quote))
+        # New transition matches consistent quotes only:
+        self.add_transition('quoted',
+                            (pattern, self.quoted, self.__class__.__name__))
+        self.initial_lineno = self.state_machine.abs_line_number()
+        return [match.string], next_state, []
+
+    def quoted(self, match, context, next_state):
+        """Match consistent quotes on subsequent lines."""
+        context.append(match.string)
+        return context, next_state, []
+
+    def text(self, match, context, next_state):
+        if context:
+            self.messages.append(
+                self.reporter.error('Inconsistent literal block quoting.',
+                                    line=self.state_machine.abs_line_number()))
+            self.state_machine.previous_line()
+        raise EOFError
+
+
+state_classes = (Body, BulletList, DefinitionList, EnumeratedList, FieldList,
+                 OptionList, LineBlock, ExtensionOptions, Explicit, Text,
+                 Definition, Line, SubstitutionDef, RFC2822Body, RFC2822List)
+"""Standard set of State classes used to start `RSTStateMachine`."""
diff --git a/.venv/lib/python3.12/site-packages/docutils/parsers/rst/tableparser.py b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/tableparser.py
new file mode 100644
index 00000000..1e0e2be2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/docutils/parsers/rst/tableparser.py
@@ -0,0 +1,539 @@
+# $Id: tableparser.py 9038 2022-03-05 23:31:46Z milde $
+# Author: David Goodger <goodger@python.org>
+# Copyright: This module has been placed in the public domain.
+
+"""
+This module defines table parser classes,which parse plaintext-graphic tables
+and produce a well-formed data structure suitable for building a CALS table.
+
+:Classes:
+    - `GridTableParser`: Parse fully-formed tables represented with a grid.
+    - `SimpleTableParser`: Parse simple tables, delimited by top & bottom
+      borders.
+
+:Exception class: `TableMarkupError`
+
+:Function:
+    `update_dict_of_lists()`: Merge two dictionaries containing list values.
+"""
+
+__docformat__ = 'reStructuredText'
+
+
+import re
+import sys
+from docutils import DataError
+from docutils.utils import strip_combining_chars
+
+
+class TableMarkupError(DataError):
+
+    """
+    Raise if there is any problem with table markup.
+
+    The keyword argument `offset` denotes the offset of the problem
+    from the table's start line.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.offset = kwargs.pop('offset', 0)
+        DataError.__init__(self, *args)
+
+
+class TableParser:
+
+    """
+    Abstract superclass for the common parts of the syntax-specific parsers.
+    """
+
+    head_body_separator_pat = None
+    """Matches the row separator between head rows and body rows."""
+
+    double_width_pad_char = '\x00'
+    """Padding character for East Asian double-width text."""
+
+    def parse(self, block):
+        """
+        Analyze the text `block` and return a table data structure.
+
+        Given a plaintext-graphic table in `block` (list of lines of text; no
+        whitespace padding), parse the table, construct and return the data
+        necessary to construct a CALS table or equivalent.
+
+        Raise `TableMarkupError` if there is any problem with the markup.
+        """
+        self.setup(block)
+        self.find_head_body_sep()
+        self.parse_table()
+        return self.structure_from_cells()
+
+    def find_head_body_sep(self):
+        """Look for a head/body row separator line; store the line index."""
+        for i in range(len(self.block)):
+            line = self.block[i]
+            if self.head_body_separator_pat.match(line):
+                if self.head_body_sep:
+                    raise TableMarkupError(
+                        'Multiple head/body row separators '
+                        '(table lines %s and %s); only one allowed.'
+                        % (self.head_body_sep+1, i+1), offset=i)
+                else:
+                    self.head_body_sep = i
+                    self.block[i] = line.replace('=', '-')
+        if self.head_body_sep == 0 or self.head_body_sep == (len(self.block)
+                                                             - 1):
+            raise TableMarkupError('The head/body row separator may not be '
+                                   'the first or last line of the table.',
+                                   offset=i)
+
+
+class GridTableParser(TableParser):
+
+    """
+    Parse a grid table using `parse()`.
+
+    Here's an example of a grid table::
+
+        +------------------------+------------+----------+----------+
+        | Header row, column 1   | Header 2   | Header 3 | Header 4 |
+        +========================+============+==========+==========+
+        | body row 1, column 1   | column 2   | column 3 | column 4 |
+        +------------------------+------------+----------+----------+
+        | body row 2             | Cells may span columns.          |
+        +------------------------+------------+---------------------+
+        | body row 3             | Cells may  | - Table cells       |
+        +------------------------+ span rows. | - contain           |
+        | body row 4             |            | - body elements.    |
+        +------------------------+------------+---------------------+
+
+    Intersections use '+', row separators use '-' (except for one optional
+    head/body row separator, which uses '='), and column separators use '|'.
+
+    Passing the above table to the `parse()` method will result in the
+    following data structure::
+
+        ([24, 12, 10, 10],
+         [[(0, 0, 1, ['Header row, column 1']),
+           (0, 0, 1, ['Header 2']),
+           (0, 0, 1, ['Header 3']),
+           (0, 0, 1, ['Header 4'])]],
+         [[(0, 0, 3, ['body row 1, column 1']),
+           (0, 0, 3, ['column 2']),
+           (0, 0, 3, ['column 3']),
+           (0, 0, 3, ['column 4'])],
+          [(0, 0, 5, ['body row 2']),
+           (0, 2, 5, ['Cells may span columns.']),
+           None,
+           None],
+          [(0, 0, 7, ['body row 3']),
+           (1, 0, 7, ['Cells may', 'span rows.', '']),
+           (1, 1, 7, ['- Table cells', '- contain', '- body elements.']),
+           None],
+          [(0, 0, 9, ['body row 4']), None, None, None]])
+
+    The first item is a list containing column widths (colspecs). The second
+    item is a list of head rows, and the third is a list of body rows. Each
+    row contains a list of cells. Each cell is either None (for a cell unused
+    because of another cell's span), or a tuple. A cell tuple contains four
+    items: the number of extra rows used by the cell in a vertical span
+    (morerows); the number of extra columns used by the cell in a horizontal
+    span (morecols); the line offset of the first line of the cell contents;
+    and the cell contents, a list of lines of text.
+    """
+
+    head_body_separator_pat = re.compile(r'\+=[=+]+=\+ *$')
+
+    def setup(self, block):
+        self.block = block[:]           # make a copy; it may be modified
+        self.block.disconnect()         # don't propagate changes to parent
+        self.bottom = len(block) - 1
+        self.right = len(block[0]) - 1
+        self.head_body_sep = None
+        self.done = [-1] * len(block[0])
+        self.cells = []
+        self.rowseps = {0: [0]}
+        self.colseps = {0: [0]}
+
+    def parse_table(self):
+        """
+        Start with a queue of upper-left corners, containing the upper-left
+        corner of the table itself. Trace out one rectangular cell, remember
+        it, and add its upper-right and lower-left corners to the queue of
+        potential upper-left corners of further cells. Process the queue in
+        top-to-bottom order, keeping track of how much of each text column has
+        been seen.
+
+        We'll end up knowing all the row and column boundaries, cell positions
+        and their dimensions.
+        """
+        corners = [(0, 0)]
+        while corners:
+            top, left = corners.pop(0)
+            if (top == self.bottom
+                or left == self.right
+                or top <= self.done[left]):
+                continue
+            result = self.scan_cell(top, left)
+            if not result:
+                continue
+            bottom, right, rowseps, colseps = result
+            update_dict_of_lists(self.rowseps, rowseps)
+            update_dict_of_lists(self.colseps, colseps)
+            self.mark_done(top, left, bottom, right)
+            cellblock = self.block.get_2D_block(top + 1, left + 1,
+                                                bottom, right)
+            cellblock.disconnect()      # lines in cell can't sync with parent
+            cellblock.replace(self.double_width_pad_char, '')
+            self.cells.append((top, left, bottom, right, cellblock))
+            corners.extend([(top, right), (bottom, left)])
+            corners.sort()
+        if not self.check_parse_complete():
+            raise TableMarkupError('Malformed table; parse incomplete.')
+
+    def mark_done(self, top, left, bottom, right):
+        """For keeping track of how much of each text column has been seen."""
+        before = top - 1
+        after = bottom - 1
+        for col in range(left, right):
+            assert self.done[col] == before
+            self.done[col] = after
+
+    def check_parse_complete(self):
+        """Each text column should have been completely seen."""
+        last = self.bottom - 1
+        for col in range(self.right):
+            if self.done[col] != last:
+                return False
+        return True
+
+    def scan_cell(self, top, left):
+        """Starting at the top-left corner, start tracing out a cell."""
+        assert self.block[top][left] == '+'
+        return self.scan_right(top, left)
+
+    def scan_right(self, top, left):
+        """
+        Look for the top-right corner of the cell, and make note of all column
+        boundaries ('+').
+        """
+        colseps = {}
+        line = self.block[top]
+        for i in range(left + 1, self.right + 1):
+            if line[i] == '+':
+                colseps[i] = [top]
+                result = self.scan_down(top, left, i)
+                if result:
+                    bottom, rowseps, newcolseps = result
+                    update_dict_of_lists(colseps, newcolseps)
+                    return bottom, i, rowseps, colseps
+            elif line[i] != '-':
+                return None
+        return None
+
+    def scan_down(self, top, left, right):
+        """
+        Look for the bottom-right corner of the cell, making note of all row
+        boundaries.
+        """
+        rowseps = {}
+        for i in range(top + 1, self.bottom + 1):
+            if self.block[i][right] == '+':
+                rowseps[i] = [right]
+                result = self.scan_left(top, left, i, right)
+                if result:
+                    newrowseps, colseps = result
+                    update_dict_of_lists(rowseps, newrowseps)
+                    return i, rowseps, colseps
+            elif self.block[i][right] != '|':
+                return None
+        return None
+
+    def scan_left(self, top, left, bottom, right):
+        """
+        Noting column boundaries, look for the bottom-left corner of the cell.
+        It must line up with the starting point.
+        """
+        colseps = {}
+        line = self.block[bottom]
+        for i in range(right - 1, left, -1):
+            if line[i] == '+':
+                colseps[i] = [bottom]
+            elif line[i] != '-':
+                return None
+        if line[left] != '+':
+            return None
+        result = self.scan_up(top, left, bottom, right)
+        if result is not None:
+            rowseps = result
+            return rowseps, colseps
+        return None
+
+    def scan_up(self, top, left, bottom, right):
+        """
+        Noting row boundaries, see if we can return to the starting point.
+        """
+        rowseps = {}
+        for i in range(bottom - 1, top, -1):
+            if self.block[i][left] == '+':
+                rowseps[i] = [left]
+            elif self.block[i][left] != '|':
+                return None
+        return rowseps
+
+    def structure_from_cells(self):
+        """
+        From the data collected by `scan_cell()`, convert to the final data
+        structure.
+        """
+        rowseps = sorted(self.rowseps.keys())   # list of row boundaries
+        rowindex = {}
+        for i in range(len(rowseps)):
+            rowindex[rowseps[i]] = i    # row boundary -> row number mapping
+        colseps = sorted(self.colseps.keys())   # list of column boundaries
+        colindex = {}
+        for i in range(len(colseps)):
+            colindex[colseps[i]] = i    # column boundary -> col number map
+        colspecs = [(colseps[i] - colseps[i - 1] - 1)
+                    for i in range(1, len(colseps))]  # list of column widths
+        # prepare an empty table with the correct number of rows & columns
+        onerow = [None for i in range(len(colseps) - 1)]
+        rows = [onerow[:] for i in range(len(rowseps) - 1)]
+        # keep track of # of cells remaining; should reduce to zero
+        remaining = (len(rowseps) - 1) * (len(colseps) - 1)
+        for top, left, bottom, right, block in self.cells:
+            rownum = rowindex[top]
+            colnum = colindex[left]
+            assert rows[rownum][colnum] is None, (
+                  'Cell (row %s, column %s) already used.'
+                  % (rownum + 1, colnum + 1))
+            morerows = rowindex[bottom] - rownum - 1
+            morecols = colindex[right] - colnum - 1
+            remaining -= (morerows + 1) * (morecols + 1)
+            # write the cell into the table
+            rows[rownum][colnum] = (morerows, morecols, top + 1, block)
+        assert remaining == 0, 'Unused cells remaining.'
+        if self.head_body_sep:          # separate head rows from body rows
+            numheadrows = rowindex[self.head_body_sep]
+            headrows = rows[:numheadrows]
+            bodyrows = rows[numheadrows:]
+        else:
+            headrows = []
+            bodyrows = rows
+        return colspecs, headrows, bodyrows
+
+
+class SimpleTableParser(TableParser):
+
+    """
+    Parse a simple table using `parse()`.
+
+    Here's an example of a simple table::
+
+        =====  =====
+        col 1  col 2
+        =====  =====
+        1      Second column of row 1.
+        2      Second column of row 2.
+               Second line of paragraph.
+        3      - Second column of row 3.
+
+               - Second item in bullet
+                 list (row 3, column 2).
+        4 is a span
+        ------------
+        5
+        =====  =====
+
+    Top and bottom borders use '=', column span underlines use '-', column
+    separation is indicated with spaces.
+
+    Passing the above table to the `parse()` method will result in the
+    following data structure, whose interpretation is the same as for
+    `GridTableParser`::
+
+        ([5, 25],
+         [[(0, 0, 1, ['col 1']),
+           (0, 0, 1, ['col 2'])]],
+         [[(0, 0, 3, ['1']),
+           (0, 0, 3, ['Second column of row 1.'])],
+          [(0, 0, 4, ['2']),
+           (0, 0, 4, ['Second column of row 2.',
+                      'Second line of paragraph.'])],
+          [(0, 0, 6, ['3']),
+           (0, 0, 6, ['- Second column of row 3.',
+                      '',
+                      '- Second item in bullet',
+                      '  list (row 3, column 2).'])],
+          [(0, 1, 10, ['4 is a span'])],
+          [(0, 0, 12, ['5']),
+           (0, 0, 12, [''])]])
+    """
+
+    head_body_separator_pat = re.compile('=[ =]*$')
+    span_pat = re.compile('-[ -]*$')
+
+    def setup(self, block):
+        self.block = block[:]           # make a copy; it will be modified
+        self.block.disconnect()         # don't propagate changes to parent
+        # Convert top & bottom borders to column span underlines:
+        self.block[0] = self.block[0].replace('=', '-')
+        self.block[-1] = self.block[-1].replace('=', '-')
+        self.head_body_sep = None
+        self.columns = []
+        self.border_end = None
+        self.table = []
+        self.done = [-1] * len(block[0])
+        self.rowseps = {0: [0]}
+        self.colseps = {0: [0]}
+
+    def parse_table(self):
+        """
+        First determine the column boundaries from the top border, then
+        process rows.  Each row may consist of multiple lines; accumulate
+        lines until a row is complete.  Call `self.parse_row` to finish the
+        job.
+        """
+        # Top border must fully describe all table columns.
+        self.columns = self.parse_columns(self.block[0], 0)
+        self.border_end = self.columns[-1][1]
+        firststart, firstend = self.columns[0]
+        offset = 1                      # skip top border
+        start = 1
+        text_found = None
+        while offset < len(self.block):
+            line = self.block[offset]
+            if self.span_pat.match(line):
+                # Column span underline or border; row is complete.
+                self.parse_row(self.block[start:offset], start,
+                               (line.rstrip(), offset))
+                start = offset + 1
+                text_found = None
+            elif line[firststart:firstend].strip():
+                # First column not blank, therefore it's a new row.
+                if text_found and offset != start:
+                    self.parse_row(self.block[start:offset], start)
+                start = offset
+                text_found = 1
+            elif not text_found:
+                start = offset + 1
+            offset += 1
+
+    def parse_columns(self, line, offset):
+        """
+        Given a column span underline, return a list of (begin, end) pairs.
+        """
+        cols = []
+        end = 0
+        while True:
+            begin = line.find('-', end)
+            end = line.find(' ', begin)
+            if begin < 0:
+                break
+            if end < 0:
+                end = len(line)
+            cols.append((begin, end))
+        if self.columns:
+            if cols[-1][1] != self.border_end:
+                raise TableMarkupError('Column span incomplete in table '
+                                       'line %s.' % (offset+1),
+                                       offset=offset)
+            # Allow for an unbounded rightmost column:
+            cols[-1] = (cols[-1][0], self.columns[-1][1])
+        return cols
+
+    def init_row(self, colspec, offset):
+        i = 0
+        cells = []
+        for start, end in colspec:
+            morecols = 0
+            try:
+                assert start == self.columns[i][0]
+                while end != self.columns[i][1]:
+                    i += 1
+                    morecols += 1
+            except (AssertionError, IndexError):
+                raise TableMarkupError('Column span alignment problem '
+                                       'in table line %s.' % (offset+2),
+                                       offset=offset+1)
+            cells.append([0, morecols, offset, []])
+            i += 1
+        return cells
+
+    def parse_row(self, lines, start, spanline=None):
+        """
+        Given the text `lines` of a row, parse it and append to `self.table`.
+
+        The row is parsed according to the current column spec (either
+        `spanline` if provided or `self.columns`).  For each column, extract
+        text from each line, and check for text in column margins.  Finally,
+        adjust for insignificant whitespace.
+        """
+        if not (lines or spanline):
+            # No new row, just blank lines.
+            return
+        if spanline:
+            columns = self.parse_columns(*spanline)
+        else:
+            columns = self.columns[:]
+        self.check_columns(lines, start, columns)
+        row = self.init_row(columns, start)
+        for i in range(len(columns)):
+            start, end = columns[i]
+            cellblock = lines.get_2D_block(0, start, len(lines), end)
+            cellblock.disconnect()      # lines in cell can't sync with parent
+            cellblock.replace(self.double_width_pad_char, '')
+            row[i][3] = cellblock
+        self.table.append(row)
+
+    def check_columns(self, lines, first_line, columns):
+        """
+        Check for text in column margins and text overflow in the last column.
+        Raise TableMarkupError if anything but whitespace is in column margins.
+        Adjust the end value for the last column if there is text overflow.
+        """
+        # "Infinite" value for a dummy last column's beginning, used to
+        # check for text overflow:
+        columns.append((sys.maxsize, None))
+        lastcol = len(columns) - 2
+        # combining characters do not contribute to the column width
+        lines = [strip_combining_chars(line) for line in lines]
+
+        for i in range(len(columns) - 1):
+            start, end = columns[i]
+            nextstart = columns[i+1][0]
+            offset = 0
+            for line in lines:
+                if i == lastcol and line[end:].strip():
+                    text = line[start:].rstrip()
+                    new_end = start + len(text)
+                    main_start, main_end = self.columns[-1]
+                    columns[i] = (start, max(main_end, new_end))
+                    if new_end > main_end:
+                        self.columns[-1] = (main_start, new_end)
+                elif line[end:nextstart].strip():
+                    raise TableMarkupError('Text in column margin in table '
+                                           'line %s.' % (first_line+offset+1),
+                                           offset=first_line+offset)
+                offset += 1
+        columns.pop()
+
+    def structure_from_cells(self):
+        colspecs = [end - start for start, end in self.columns]
+        first_body_row = 0
+        if self.head_body_sep:
+            for i in range(len(self.table)):
+                if self.table[i][0][2] > self.head_body_sep:
+                    first_body_row = i
+                    break
+        return (colspecs, self.table[:first_body_row],
+                self.table[first_body_row:])
+
+
+def update_dict_of_lists(master, newdata):
+    """
+    Extend the list values of `master` with those from `newdata`.
+
+    Both parameters must be dictionaries containing list values.
+    """
+    for key, values in newdata.items():
+        master.setdefault(key, []).extend(values)