# $Id: nodes.py 10227 2025-09-05 14:07:30Z milde $
# Author: David Goodger <goodger@python.org>
# Maintainer: docutils-develop@lists.sourceforge.net
# Copyright: This module has been placed in the public domain.

"""
Docutils document tree element class library.

The relationships and semantics of elements and attributes is documented in
`The Docutils Document Tree`__.

Classes in CamelCase are abstract base classes or auxiliary classes. The one
exception is `Text`, for a text (PCDATA) node; uppercase is used to
differentiate from element classes.  Classes in lower_case_with_underscores
are element classes, matching the XML element generic identifiers in the DTD_.

The position of each node (the level at which it can occur) is significant and
is represented by abstract base classes (`Root`, `Structural`, `Body`,
`Inline`, etc.).  Certain transformations will be easier because we can use
``isinstance(node, base_class)`` to determine the position of the node in the
hierarchy.

__ https://docutils.sourceforge.io/docs/ref/doctree.html
.. _DTD: https://docutils.sourceforge.io/docs/ref/docutils.dtd
"""

from __future__ import annotations

__docformat__ = 'reStructuredText'

import os
import re
import sys
import unicodedata
import warnings
from collections import Counter
# import xml.dom.minidom as dom # -> conditional import in Node.asdom()
#                                    and document.asdom()

# import docutils.transforms # -> delayed import in document.__init__()

TYPE_CHECKING = False
if TYPE_CHECKING:
    from collections.abc import (Callable, Iterable, Iterator,
                                 Mapping, Sequence)
    from types import ModuleType
    from typing import Any, ClassVar, Final, Literal, Self, SupportsIndex

    from docutils.utils._typing import TypeAlias

    from xml.dom import minidom

    from docutils.frontend import Values
    from docutils.transforms import Transformer, Transform
    from docutils.utils import Reporter

    _ContentModelCategory: TypeAlias = tuple['Element' | tuple['Element', ...]]
    _ContentModelQuantifier = Literal['.', '?', '+', '*']
    _ContentModelItem: TypeAlias = tuple[_ContentModelCategory,
                                         _ContentModelQuantifier]
    _ContentModelTuple: TypeAlias = tuple[_ContentModelItem, ...]

    StrPath: TypeAlias = str | os.PathLike[str]
    """File system path. No bytes!"""

    _UpdateFun: TypeAlias = Callable[[str, Any, bool], None]


# ==============================
#  Functional Node Base Classes
# ==============================

class Node:
    """Abstract base class of nodes in a document tree."""

    parent: Element | None = None
    """Back-reference to the Node immediately containing this Node."""

    children: Sequence  # defined in subclasses
    """List of child nodes (Elements or Text).

    Override in subclass instances that are not terminal nodes.
    """

    source: StrPath | None = None
    """Path or description of the input source which generated this Node."""

    line: int | None = None
    """The line number (1-based) of the beginning of this Node in `source`."""

    tagname: str  # defined in subclasses
    """The element generic identifier."""

    _document: document | None = None

    @property
    def document(self) -> document | None:
        """Return the `document` root node of the tree containing this Node.
        """
        try:
            return self._document or self.parent.document
        except AttributeError:
            return None

    @document.setter
    def document(self, value: document) -> None:
        self._document = value

    def __bool__(self) -> Literal[True]:
        """
        Node instances are always true, even if they're empty.  A node is more
        than a simple container.  Its boolean "truth" does not depend on
        having one or more subnodes in the doctree.

        Use `len()` to check node length.
        """
        return True

    def asdom(self,
              dom: ModuleType | None = None,
              ) -> minidom.Document | minidom.Element | minidom.Text:
        # TODO: minidom.Document is only returned by document.asdom()
        # (which overwrites this base-class implementation)
        """Return a DOM **fragment** representation of this Node."""
        if dom is None:
            import xml.dom.minidom as dom
        domroot = dom.Document()
        return self._dom_node(domroot)

    def pformat(self, indent: str = '    ', level: int = 0) -> str:
        """
        Return an indented pseudo-XML representation, for test purposes.

        Override in subclasses.
        """
        raise NotImplementedError

    def copy(self) -> Self:
        """Return a copy of self."""
        raise NotImplementedError

    def deepcopy(self) -> Self:
        """Return a deep copy of self (also copying children)."""
        raise NotImplementedError

    def astext(self) -> str:
        """Return a string representation of this Node."""
        raise NotImplementedError

    def setup_child(self, child) -> None:
        child.parent = self
        if self.document:
            child.document = self.document
            if child.source is None:
                child.source = self.document.current_source
            if child.line is None:
                child.line = self.document.current_line

    def walk(self, visitor: NodeVisitor) -> bool:
        """
        Traverse a tree of `Node` objects, calling the
        `dispatch_visit()` method of `visitor` when entering each
        node.  (The `walkabout()` method is similar, except it also
        calls the `dispatch_departure()` method before exiting each
        node.)

        This tree traversal supports limited in-place tree
        modifications.  Replacing one node with one or more nodes is
        OK, as is removing an element.  However, if the node removed
        or replaced occurs after the current node, the old node will
        still be traversed, and any new nodes will not.

        Within ``visit`` methods (and ``depart`` methods for
        `walkabout()`), `TreePruningException` subclasses may be raised
        (`SkipChildren`, `SkipSiblings`, `SkipNode`, `SkipDeparture`).

        Parameter `visitor`: A `NodeVisitor` object, containing a
        ``visit`` implementation for each `Node` subclass encountered.

        Return true if we should stop the traversal.
        """
        stop = False
        visitor.document.reporter.debug(
            'docutils.nodes.Node.walk calling dispatch_visit for %s'
            % self.__class__.__name__)
        try:
            try:
                visitor.dispatch_visit(self)
            except (SkipChildren, SkipNode):
                return stop
            except SkipDeparture:           # not applicable; ignore
                pass
            children = self.children
            try:
                for child in children[:]:
                    if child.walk(visitor):
                        stop = True
                        break
            except SkipSiblings:
                pass
        except StopTraversal:
            stop = True
        return stop

    def walkabout(self, visitor: NodeVisitor) -> bool:
        """
        Perform a tree traversal similarly to `Node.walk()` (which
        see), except also call the `dispatch_departure()` method
        before exiting each node.

        Parameter `visitor`: A `NodeVisitor` object, containing a
        ``visit`` and ``depart`` implementation for each `Node`
        subclass encountered.

        Return true if we should stop the traversal.
        """
        call_depart = True
        stop = False
        visitor.document.reporter.debug(
            'docutils.nodes.Node.walkabout calling dispatch_visit for %s'
            % self.__class__.__name__)
        try:
            try:
                visitor.dispatch_visit(self)
            except SkipNode:
                return stop
            except SkipDeparture:
                call_depart = False
            children = self.children
            try:
                for child in children[:]:
                    if child.walkabout(visitor):
                        stop = True
                        break
            except SkipSiblings:
                pass
        except SkipChildren:
            pass
        except StopTraversal:
            stop = True
        if call_depart:
            visitor.document.reporter.debug(
                'docutils.nodes.Node.walkabout calling dispatch_departure '
                'for %s' % self.__class__.__name__)
            visitor.dispatch_departure(self)
        return stop

    def _fast_findall(self, cls: type) -> Iterator:
        """Return iterator that only supports instance checks."""
        if isinstance(self, cls):
            yield self
        for child in self.children:
            yield from child._fast_findall(cls)

    def _superfast_findall(self) -> Iterator:
        """Return iterator that doesn't check for a condition."""
        # This is different from ``iter(self)`` implemented via
        # __getitem__() and __len__() in the Element subclass,
        # which yields only the direct children.
        yield self
        for child in self.children:
            yield from child._superfast_findall()

    def findall(self,
                condition: type | Callable[[Node], bool] | None = None,
                include_self: bool = True,
                descend: bool = True,
                siblings: bool = False,
                ascend: bool = False,
                ) -> Iterator:
        """
        Return an iterator yielding nodes following `self`:

        * self (if `include_self` is true)
        * all descendants in tree traversal order (if `descend` is true)
        * the following siblings (if `siblings` is true) and their
          descendants (if also `descend` is true)
        * the following siblings of the parent (if `ascend` is true) and
          their descendants (if also `descend` is true), and so on.

        If `condition` is not None, the iterator yields only nodes
        for which ``condition(node)`` is true.  If `condition` is a
        type ``cls``, it is equivalent to a function consisting
        of ``return isinstance(node, cls)``.

        If `ascend` is true, assume `siblings` to be true as well.

        If the tree structure is modified during iteration, the result
        is undefined.

        For example, given the following tree::

            <paragraph>
                <emphasis>      <--- emphasis.traverse() and
                    <strong>    <--- strong.traverse() are called.
                        Foo
                    Bar
                <reference name="Baz" refid="baz">
                    Baz

        Then tuple(emphasis.traverse()) equals ::

            (<emphasis>, <strong>, <#text: Foo>, <#text: Bar>)

        and list(strong.traverse(ascend=True) equals ::

            [<strong>, <#text: Foo>, <#text: Bar>, <reference>, <#text: Baz>]
        """
        if ascend:
            siblings = True
        # Check for special argument combinations that allow using an
        # optimized version of traverse()
        if include_self and descend and not siblings:
            if condition is None:
                yield from self._superfast_findall()
                return
            elif isinstance(condition, type):
                yield from self._fast_findall(condition)
                return
        # Check if `condition` is a class (check for TypeType for Python
        # implementations that use only new-style classes, like PyPy).
        if isinstance(condition, type):
            node_class = condition

            def condition(node, node_class=node_class):
                return isinstance(node, node_class)

        if include_self and (condition is None or condition(self)):
            yield self
        if descend and len(self.children):
            for child in self:
                yield from child.findall(condition=condition,
                                         include_self=True, descend=True,
                                         siblings=False, ascend=False)
        if siblings or ascend:
            node = self
            while node.parent:
                index = node.parent.index(node)
                # extra check since Text nodes have value-equality
                while node.parent[index] is not node:
                    index = node.parent.index(node, index + 1)
                for sibling in node.parent[index+1:]:
                    yield from sibling.findall(
                        condition=condition,
                        include_self=True, descend=descend,
                        siblings=False, ascend=False)
                if not ascend:
                    break
                else:
                    node = node.parent

    def traverse(self,
                 condition: type | Callable[[Node], bool] | None = None,
                 include_self: bool = True,
                 descend: bool = True,
                 siblings: bool = False,
                 ascend: bool = False,
                 ) -> list:
        """Return list of nodes following `self`.

        For looping, Node.findall() is faster and more memory efficient.
        """
        # traverse() may be eventually removed:
        warnings.warn('nodes.Node.traverse() is obsoleted by Node.findall().',
                      DeprecationWarning, stacklevel=2)
        return list(self.findall(condition, include_self, descend,
                                 siblings, ascend))

    def next_node(self,
                  condition: type | Callable[[Node], bool] | None = None,
                  include_self: bool = False,
                  descend: bool = True,
                  siblings: bool = False,
                  ascend: bool = False,
                  ) -> Node | None:
        """
        Return the first node in the iterator returned by findall(),
        or None if the iterable is empty.

        Parameter list is the same as of `findall()`.  Note that `include_self`
        defaults to False, though.
        """
        try:
            return next(self.findall(condition, include_self,
                                     descend, siblings, ascend))
        except StopIteration:
            return None

    def validate(self, recursive: bool = True) -> None:
        """Raise ValidationError if this node is not valid.

        Override in subclasses that define validity constraints.
        """

    def validate_position(self) -> None:
        """Hook for additional checks of the parent's content model.

        Raise ValidationError, if `self` is at an invalid position.

        Override in subclasses with complex validity constraints. See
        `subtitle.validate_position()` and `transition.validate_position()`.
        """


class Text(Node, str):  # NoQA: SLOT000 (Node doesn't define __slots__)
    """
    Instances are terminal nodes (leaves) containing text only; no child
    nodes or attributes.  Initialize by passing a string to the constructor.

    Access the raw (null-escaped) text with ``str(<instance>)``
    and unescaped text with ``<instance>.astext()``.
    """

    tagname: Final = '#text'

    children: Final = ()
    """Text nodes have no children, and cannot have children."""

    def __new__(cls, data: str, rawsource: None = None) -> Self:
        """Assert that `data` is not an array of bytes
        and warn if the deprecated `rawsource` argument is used.
        """
        if isinstance(data, bytes):
            raise TypeError('expecting str data, not bytes')
        if rawsource is not None:
            warnings.warn('nodes.Text: initialization argument "rawsource" '
                          'is ignored and will be removed in Docutils 2.0.',
                          DeprecationWarning, stacklevel=2)
        return str.__new__(cls, data)

    def shortrepr(self, maxlen: int = 18) -> str:
        data = self
        if len(data) > maxlen:
            data = data[:maxlen-4] + ' ...'
        return '<%s: %r>' % (self.tagname, str(data))

    def __repr__(self) -> str:
        return self.shortrepr(maxlen=68)

    def astext(self) -> str:
        return str(unescape(self))

    def _dom_node(self, domroot: minidom.Document) -> minidom.Text:
        return domroot.createTextNode(str(self))

    def copy(self) -> Self:
        return self.__class__(str(self))

    def deepcopy(self) -> Self:
        return self.copy()

    def pformat(self, indent: str = '    ', level: int = 0) -> str:
        try:
            if self.document.settings.detailed:
                tag = '%s%s' % (indent*level, '<#text>')
                lines = (indent*(level+1) + repr(line)
                         for line in self.splitlines(True))
                return '\n'.join((tag, *lines)) + '\n'
        except AttributeError:
            pass
        indent = indent * level
        lines = [indent+line for line in self.astext().splitlines()]
        if not lines:
            return ''
        return '\n'.join(lines) + '\n'

    # rstrip and lstrip are used by substitution definitions where
    # they are expected to return a Text instance, this was formerly
    # taken care of by UserString.

    def rstrip(self, chars: str | None = None) -> Self:
        return self.__class__(str.rstrip(self, chars))

    def lstrip(self, chars: str | None = None) -> Self:
        return self.__class__(str.lstrip(self, chars))


class Element(Node):
    """
    `Element` is the superclass to all specific elements.

    Elements contain attributes and child nodes.
    They can be described as a cross between a list and a dictionary.

    Elements emulate dictionaries for external [#]_ attributes, indexing by
    attribute name (a string). To set the attribute 'att' to 'value', do::

        element['att'] = 'value'

    .. [#] External attributes correspond to the XML element attributes.
       From its `Node` superclass, Element also inherits "internal"
       class attributes that are accessed using the standard syntax, e.g.
       ``element.parent``.

    There are two special attributes: 'ids' and 'names'.  Both are
    lists of unique identifiers: 'ids' conform to the regular expression
    ``[a-z](-?[a-z0-9]+)*`` (see the make_id() function for rationale and
    details). 'names' serve as user-friendly interfaces to IDs; they are
    case- and whitespace-normalized (see the fully_normalize_name() function).

    Elements emulate lists for child nodes (element nodes and/or text
    nodes), indexing by integer.  To get the first child node, use::

        element[0]

    to iterate over the child nodes (without descending), use::

        for child in element:
            ...

    Elements may be constructed using the ``+=`` operator.  To add one new
    child node to element, do::

        element += node

    This is equivalent to ``element.append(node)``.

    To add a list of multiple child nodes at once, use the same ``+=``
    operator::

        element += [node1, node2]

    This is equivalent to ``element.extend([node1, node2])``.
    """

    list_attributes: Final = ('ids', 'classes', 'names', 'dupnames')
    """Tuple of attributes that are initialized to empty lists.

    NOTE: Derived classes should update this value when supporting
          additional list attributes.
    """

    valid_attributes: Final = list_attributes + ('source',)
    """Tuple of attributes that are valid for elements of this class.

    NOTE: Derived classes should update this value when supporting
          additional attributes.
    """

    common_attributes: Final = valid_attributes
    """Tuple of `common attributes`__  known to all Doctree Element classes.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#common-attributes
    """

    known_attributes: Final = common_attributes
    """Alias for `common_attributes`. Will be removed in Docutils 2.0."""

    basic_attributes: Final = list_attributes
    """Common list attributes. Deprecated. Will be removed in Docutils 2.0."""

    local_attributes: Final = ('backrefs',)
    """Obsolete. Will be removed in Docutils 2.0."""

    content_model: ClassVar[_ContentModelTuple] = ()
    """Python representation of the element's content model (cf. docutils.dtd).

    A tuple of ``(category, quantifier)`` tuples with

    :category:   class or tuple of classes that are expected at this place(s)
                 in the list of children
    :quantifier: string representation stating how many elements
                 of `category` are expected. Value is one of:
                 '.' (exactly one), '?' (zero or one),
                 '+' (one or more), '*' (zero or more).

    NOTE: The default describes the empty element. Derived classes should
    update this value to match their content model.

    Provisional.
    """

    tagname: str | None = None
    """The element generic identifier.

    If None, it is set as an instance attribute to the name of the class.
    """

    child_text_separator: Final = '\n\n'
    """Separator for child nodes, used by `astext()` method."""

    def __init__(self,
                 rawsource: str = '',
                 *children,
                 **attributes: Any,
                 ) -> None:
        self.rawsource = rawsource
        """The raw text from which this element was constructed.

        For informative and debugging purposes. Don't rely on its value!

        NOTE: some elements do not set this value (default '').
        """
        if isinstance(rawsource, Element):
            raise TypeError('First argument "rawsource" must be a string.')

        self.children: list = []
        """List of child nodes (elements and/or `Text`)."""

        self.extend(children)           # maintain parent info

        self.attributes: dict[str, Any] = {}
        """Dictionary of attribute {name: value}."""

        # Initialize list attributes.
        for att in self.list_attributes:
            self.attributes[att] = []

        for att, value in attributes.items():
            att = att.lower()  # normalize attribute name
            if att in self.list_attributes:
                # lists are mutable; make a copy for this node
                self.attributes[att] = value[:]
            else:
                self.attributes[att] = value

        if self.tagname is None:
            self.tagname: str = self.__class__.__name__

    def _dom_node(self, domroot: minidom.Document) -> minidom.Element:
        element = domroot.createElement(self.tagname)
        for attribute, value in self.attlist():
            if isinstance(value, list):
                value = ' '.join(serial_escape('%s' % (v,)) for v in value)
            element.setAttribute(attribute, '%s' % value)
        for child in self.children:
            element.appendChild(child._dom_node(domroot))
        return element

    def __repr__(self) -> str:
        data = ''
        for c in self.children:
            data += c.shortrepr()
            if len(data) > 60:
                data = data[:56] + ' ...'
                break
        if self['names']:
            return '<%s "%s": %s>' % (self.tagname,
                                      '; '.join(self['names']), data)
        else:
            return '<%s: %s>' % (self.tagname, data)

    def shortrepr(self) -> str:
        if self['names']:
            return '<%s "%s"...>' % (self.tagname, '; '.join(self['names']))
        else:
            return '<%s...>' % self.tagname

    def __str__(self) -> str:
        if self.children:
            return '%s%s%s' % (self.starttag(),
                               ''.join(str(c) for c in self.children),
                               self.endtag())
        else:
            return self.emptytag()

    def starttag(self, quoteattr: Callable[[str], str] | None = None) -> str:
        # the optional arg is used by the docutils_xml writer
        if quoteattr is None:
            quoteattr = pseudo_quoteattr
        parts = [self.tagname]
        for name, value in self.attlist():
            if value is None:           # boolean attribute
                parts.append('%s="True"' % name)
                continue
            if isinstance(value, bool):
                value = str(int(value))
            if isinstance(value, list):
                values = [serial_escape('%s' % (v,)) for v in value]
                value = ' '.join(values)
            else:
                value = str(value)
            value = quoteattr(value)
            parts.append('%s=%s' % (name, value))
        return '<%s>' % ' '.join(parts)

    def endtag(self) -> str:
        return '</%s>' % self.tagname

    def emptytag(self) -> str:
        attributes = ('%s="%s"' % (n, v) for n, v in self.attlist())
        return '<%s/>' % ' '.join((self.tagname, *attributes))

    def __len__(self) -> int:
        return len(self.children)

    def __contains__(self, key) -> bool:
        # Test for both, children and attributes with operator ``in``.
        if isinstance(key, str):
            return key in self.attributes
        return key in self.children

    def __getitem__(self, key: str | int | slice) -> Any:
        if isinstance(key, str):
            return self.attributes[key]
        elif isinstance(key, int):
            return self.children[key]
        elif isinstance(key, slice):
            assert key.step in (None, 1), 'cannot handle slice with stride'
            return self.children[key.start:key.stop]
        else:
            raise TypeError('element index must be an integer, a slice, or '
                            'an attribute name string')

    def __setitem__(self, key, item) -> None:
        if isinstance(key, str):
            self.attributes[str(key)] = item
        elif isinstance(key, int):
            self.setup_child(item)
            self.children[key] = item
        elif isinstance(key, slice):
            assert key.step in (None, 1), 'cannot handle slice with stride'
            for node in item:
                self.setup_child(node)
            self.children[key.start:key.stop] = item
        else:
            raise TypeError('element index must be an integer, a slice, or '
                            'an attribute name string')

    def __delitem__(self, key: str | int | slice) -> None:
        if isinstance(key, str):
            del self.attributes[key]
        elif isinstance(key, int):
            del self.children[key]
        elif isinstance(key, slice):
            assert key.step in (None, 1), 'cannot handle slice with stride'
            del self.children[key.start:key.stop]
        else:
            raise TypeError('element index must be an integer, a simple '
                            'slice, or an attribute name string')

    def __add__(self, other: list) -> list:
        return self.children + other

    def __radd__(self, other: list) -> list:
        return other + self.children

    def __iadd__(self, other) -> Self:
        """Append a node or a list of nodes to `self.children`."""
        if isinstance(other, Node):
            self.append(other)
        elif other is not None:
            self.extend(other)
        return self

    def astext(self) -> str:
        return self.child_text_separator.join(
                   [child.astext() for child in self.children])

    def non_default_attributes(self) -> dict[str, Any]:
        atts = {key: value for key, value in self.attributes.items()
                if self.is_not_default(key)}
        return atts

    def attlist(self) -> list[tuple[str, Any]]:
        return sorted(self.non_default_attributes().items())

    def get(self, key: str, failobj: Any | None = None) -> Any:
        return self.attributes.get(key, failobj)

    def hasattr(self, attr: str) -> bool:
        return attr in self.attributes

    def delattr(self, attr: str) -> None:
        if attr in self.attributes:
            del self.attributes[attr]

    def setdefault(self, key: str, failobj: Any | None = None) -> Any:
        return self.attributes.setdefault(key, failobj)

    has_key = hasattr

    def get_language_code(self, fallback: str = '') -> str:
        """Return node's language tag.

        Look iteratively in self and parents for a class argument
        starting with ``language-`` and return the remainder of it
        (which should be a `BCP49` language tag) or the `fallback`.
        """
        for cls in self.get('classes', []):
            if cls.startswith('language-'):
                return cls.removeprefix('language-')
        try:
            return self.parent.get_language_code(fallback)
        except AttributeError:
            return fallback

    def append(self, item) -> None:
        self.setup_child(item)
        self.children.append(item)

    def extend(self, item: Iterable) -> None:
        for node in item:
            self.append(node)

    def insert(self, index: SupportsIndex, item) -> None:
        if isinstance(item, Node):
            self.setup_child(item)
            self.children.insert(index, item)
        elif item is not None:
            self[index:index] = item

    def pop(self, i: int = -1):
        return self.children.pop(i)

    def remove(self, item) -> None:
        self.children.remove(item)

    def index(self, item, start: int = 0, stop: int = sys.maxsize) -> int:
        return self.children.index(item, start, stop)

    def previous_sibling(self):
        """Return preceding sibling node or ``None``."""
        try:
            i = self.parent.index(self)
        except (AttributeError):
            return None
        return self.parent[i-1] if i > 0 else None

    def section_hierarchy(self) -> list[section]:
        """Return the element's section anchestors.

        Return a list of all <section> elements that contain `self`
        (including `self` if it is a <section>) and have a parent node.

        List item ``[i]`` is the parent <section> of level i+1
        (1: section, 2: subsection, 3: subsubsection, ...).
        The length of the list is the element's section level.

        See `docutils.parsers.rst.states.RSTState.check_subsection()`
        for a usage example.

        Provisional. May be changed or removed without warning.
        """
        sections = []
        node = self
        while node.parent is not None:
            if isinstance(node, section):
                sections.append(node)
            node = node.parent
        sections.reverse()
        return sections

    def is_not_default(self, key: str) -> bool:
        if self[key] == [] and key in self.list_attributes:
            return False
        else:
            return True

    def update_basic_atts(self, dict_: Mapping[str, Any] | Element) -> None:
        """
        Update basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') from node or dictionary `dict_`.

        Provisional.
        """
        if isinstance(dict_, Node):
            dict_ = dict_.attributes
        for att in self.basic_attributes:
            self.append_attr_list(att, dict_.get(att, []))

    def append_attr_list(self, attr: str, values: Iterable[Any]) -> None:
        """
        For each element in values, if it does not exist in self[attr], append
        it.

        NOTE: Requires self[attr] and values to be sequence type and the
        former should specifically be a list.
        """
        # List Concatenation
        for value in values:
            if value not in self[attr]:
                self[attr].append(value)

    def coerce_append_attr_list(
            self, attr: str, value: list[Any] | Any) -> None:
        """
        First, convert both self[attr] and value to a non-string sequence
        type; if either is not already a sequence, convert it to a list of one
        element.  Then call append_attr_list.

        NOTE: self[attr] and value both must not be None.
        """
        # List Concatenation
        if not isinstance(self.get(attr), list):
            self[attr] = [self[attr]]
        if not isinstance(value, list):
            value = [value]
        self.append_attr_list(attr, value)

    def replace_attr(self, attr: str, value: Any, force: bool = True) -> None:
        """
        If self[attr] does not exist or force is True or omitted, set
        self[attr] to value, otherwise do nothing.
        """
        # One or the other
        if force or self.get(attr) is None:
            self[attr] = value

    def copy_attr_convert(
            self, attr: str, value: Any, replace: bool = True) -> None:
        """
        If attr is an attribute of self, set self[attr] to
        [self[attr], value], otherwise set self[attr] to value.

        NOTE: replace is not used by this function and is kept only for
              compatibility with the other copy functions.
        """
        if self.get(attr) is not value:
            self.coerce_append_attr_list(attr, value)

    def copy_attr_coerce(self, attr: str, value: Any, replace: bool) -> None:
        """
        If attr is an attribute of self and either self[attr] or value is a
        list, convert all non-sequence values to a sequence of 1 element and
        then concatenate the two sequence, setting the result to self[attr].
        If both self[attr] and value are non-sequences and replace is True or
        self[attr] is None, replace self[attr] with value. Otherwise, do
        nothing.
        """
        if self.get(attr) is not value:
            if isinstance(self.get(attr), list) or \
               isinstance(value, list):
                self.coerce_append_attr_list(attr, value)
            else:
                self.replace_attr(attr, value, replace)

    def copy_attr_concatenate(
            self, attr: str, value: Any, replace: bool) -> None:
        """
        If attr is an attribute of self and both self[attr] and value are
        lists, concatenate the two sequences, setting the result to
        self[attr].  If either self[attr] or value are non-sequences and
        replace is True or self[attr] is None, replace self[attr] with value.
        Otherwise, do nothing.
        """
        if self.get(attr) is not value:
            if isinstance(self.get(attr), list) and \
               isinstance(value, list):
                self.append_attr_list(attr, value)
            else:
                self.replace_attr(attr, value, replace)

    def copy_attr_consistent(
            self, attr: str, value: Any, replace: bool) -> None:
        """
        If replace is True or self[attr] is None, replace self[attr] with
        value.  Otherwise, do nothing.
        """
        if self.get(attr) is not value:
            self.replace_attr(attr, value, replace)

    def update_all_atts(self,
                        dict_: Mapping[str, Any] | Element,
                        update_fun: _UpdateFun = copy_attr_consistent,
                        replace: bool = True,
                        and_source: bool = False,
                        ) -> None:
        """
        Updates all attributes from node or dictionary `dict_`.

        Appends the basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') and then, for all other attributes in
        dict_, updates the same attribute in self.  When attributes with the
        same identifier appear in both self and dict_, the two values are
        merged based on the value of update_fun.  Generally, when replace is
        True, the values in self are replaced or merged with the values in
        dict_; otherwise, the values in self may be preserved or merged.  When
        and_source is True, the 'source' attribute is included in the copy.

        NOTE: When replace is False, and self contains a 'source' attribute,
              'source' is not replaced even when dict_ has a 'source'
              attribute, though it may still be merged into a list depending
              on the value of update_fun.
        NOTE: It is easier to call the update-specific methods then to pass
              the update_fun method to this function.
        """
        if isinstance(dict_, Node):
            dict_ = dict_.attributes

        # Include the source attribute when copying?
        if and_source:
            filter_fun = self.is_not_list_attribute
        else:
            filter_fun = self.is_not_known_attribute

        # Copy the basic attributes
        self.update_basic_atts(dict_)

        # Grab other attributes in dict_ not in self except the
        # (All basic attributes should be copied already)
        for att in filter(filter_fun, dict_):
            update_fun(self, att, dict_[att], replace)

    def update_all_atts_consistantly(self,
                                     dict_: Mapping[str, Any] | Element,
                                     replace: bool = True,
                                     and_source: bool = False,
                                     ) -> None:
        """
        Updates all attributes from node or dictionary `dict_`.

        Appends the basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') and then, for all other attributes in
        dict_, updates the same attribute in self.  When attributes with the
        same identifier appear in both self and dict_ and replace is True, the
        values in self are replaced with the values in dict_; otherwise, the
        values in self are preserved.  When and_source is True, the 'source'
        attribute is included in the copy.

        NOTE: When replace is False, and self contains a 'source' attribute,
              'source' is not replaced even when dict_ has a 'source'
              attribute, though it may still be merged into a list depending
              on the value of update_fun.
        """
        self.update_all_atts(dict_, Element.copy_attr_consistent, replace,
                             and_source)

    def update_all_atts_concatenating(self,
                                      dict_: Mapping[str, Any] | Element,
                                      replace: bool = True,
                                      and_source: bool = False,
                                      ) -> None:
        """
        Updates all attributes from node or dictionary `dict_`.

        Appends the basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') and then, for all other attributes in
        dict_, updates the same attribute in self.  When attributes with the
        same identifier appear in both self and dict_ whose values aren't each
        lists and replace is True, the values in self are replaced with the
        values in dict_; if the values from self and dict_ for the given
        identifier are both of list type, then the two lists are concatenated
        and the result stored in self; otherwise, the values in self are
        preserved.  When and_source is True, the 'source' attribute is
        included in the copy.

        NOTE: When replace is False, and self contains a 'source' attribute,
              'source' is not replaced even when dict_ has a 'source'
              attribute, though it may still be merged into a list depending
              on the value of update_fun.
        """
        self.update_all_atts(dict_, Element.copy_attr_concatenate, replace,
                             and_source)

    def update_all_atts_coercion(self,
                                 dict_: Mapping[str, Any] | Element,
                                 replace: bool = True,
                                 and_source: bool = False,
                                 ) -> None:
        """
        Updates all attributes from node or dictionary `dict_`.

        Appends the basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') and then, for all other attributes in
        dict_, updates the same attribute in self.  When attributes with the
        same identifier appear in both self and dict_ whose values are both
        not lists and replace is True, the values in self are replaced with
        the values in dict_; if either of the values from self and dict_ for
        the given identifier are of list type, then first any non-lists are
        converted to 1-element lists and then the two lists are concatenated
        and the result stored in self; otherwise, the values in self are
        preserved.  When and_source is True, the 'source' attribute is
        included in the copy.

        NOTE: When replace is False, and self contains a 'source' attribute,
              'source' is not replaced even when dict_ has a 'source'
              attribute, though it may still be merged into a list depending
              on the value of update_fun.
        """
        self.update_all_atts(dict_, Element.copy_attr_coerce, replace,
                             and_source)

    def update_all_atts_convert(self,
                                dict_: Mapping[str, Any] | Element,
                                and_source: bool = False,
                                ) -> None:
        """
        Updates all attributes from node or dictionary `dict_`.

        Appends the basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') and then, for all other attributes in
        dict_, updates the same attribute in self.  When attributes with the
        same identifier appear in both self and dict_ then first any non-lists
        are converted to 1-element lists and then the two lists are
        concatenated and the result stored in self; otherwise, the values in
        self are preserved.  When and_source is True, the 'source' attribute
        is included in the copy.

        NOTE: When replace is False, and self contains a 'source' attribute,
              'source' is not replaced even when dict_ has a 'source'
              attribute, though it may still be merged into a list depending
              on the value of update_fun.
        """
        self.update_all_atts(dict_, Element.copy_attr_convert,
                             and_source=and_source)

    def clear(self) -> None:
        self.children = []

    def replace(self, old, new) -> None:
        """Replace one child `Node` with another child or children."""
        index = self.index(old)
        if isinstance(new, Node):
            self.setup_child(new)
            self[index] = new
        elif new is not None:
            self[index:index+1] = new

    def replace_self(self, new) -> None:
        """
        Replace `self` node with `new`, where `new` is a node or a
        list of nodes.

        Provisional: the handling of node attributes will be revised.
        """
        update = new
        if not isinstance(new, Node):
            # `new` is a list; update first child.
            try:
                update = new[0]
            except IndexError:
                update = None
        if isinstance(update, Element):
            update.update_basic_atts(self)
        else:
            # `update` is a Text node or `new` is an empty list.
            # Assert that we aren't losing any attributes.
            for att in self.basic_attributes:
                assert not self[att], \
                       'Losing "%s" attribute: %s' % (att, self[att])
        self.parent.replace(self, new)

    def first_child_matching_class(self,
                                   childclass: type[Element] | type[Text]
                                   | tuple[type[Element] | type[Text], ...],
                                   start: int = 0,
                                   end: int = sys.maxsize,
                                   ) -> int | None:
        """
        Return the index of the first child whose class exactly matches.

        Parameters:

        - `childclass`: A `Node` subclass to search for, or a tuple of `Node`
          classes. If a tuple, any of the classes may match.
        - `start`: Initial index to check.
        - `end`: Initial index to *not* check.
        """
        if not isinstance(childclass, tuple):
            childclass = (childclass,)
        for index in range(start, min(len(self), end)):
            for c in childclass:
                if isinstance(self[index], c):
                    return index
        return None

    def first_child_not_matching_class(
            self,
            childclass: type[Element] | type[Text]
            | tuple[type[Element] | type[Text], ...],
            start: int = 0,
            end: int = sys.maxsize,
            ) -> int | None:
        """
        Return the index of the first child whose class does *not* match.

        Parameters:

        - `childclass`: A `Node` subclass to skip, or a tuple of `Node`
          classes. If a tuple, none of the classes may match.
        - `start`: Initial index to check.
        - `end`: Initial index to *not* check.
        """
        if not isinstance(childclass, tuple):
            childclass = (childclass,)
        for index in range(start, min(len(self), end)):
            for c in childclass:
                if isinstance(self.children[index], c):
                    break
            else:
                return index
        return None

    def pformat(self, indent: str = '    ', level: int = 0) -> str:
        tagline = '%s%s\n' % (indent*level, self.starttag())
        childreps = (c.pformat(indent, level+1) for c in self.children)
        return ''.join((tagline, *childreps))

    def copy(self) -> Self:
        obj = self.__class__(rawsource=self.rawsource, **self.attributes)
        obj._document = self._document
        obj.source = self.source
        obj.line = self.line
        return obj

    def deepcopy(self) -> Self:
        copy = self.copy()
        copy.extend([child.deepcopy() for child in self.children])
        return copy

    def note_referenced_by(self,
                           name: str | None = None,
                           id: str | None = None,
                           ) -> None:
        """Note that this Element has been referenced by its name
        `name` or id `id`."""
        self.referenced = True
        # Element.expect_referenced_by_* dictionaries map names or ids
        # to nodes whose ``referenced`` attribute is set to true as
        # soon as this node is referenced by the given name or id.
        # Needed for target propagation.
        by_name = getattr(self, 'expect_referenced_by_name', {}).get(name)
        by_id = getattr(self, 'expect_referenced_by_id', {}).get(id)
        if by_name:
            assert name is not None
            by_name.referenced = True
        if by_id:
            assert id is not None
            by_id.referenced = True

    @classmethod
    def is_not_list_attribute(cls, attr: str) -> bool:
        """
        Returns True if and only if the given attribute is NOT one of the
        basic list attributes defined for all Elements.
        """
        return attr not in cls.list_attributes

    @classmethod
    def is_not_known_attribute(cls, attr: str) -> bool:
        """
        Return True if `attr` is NOT defined for all Element instances.

        Provisional. May be removed in Docutils 2.0.
        """
        return attr not in cls.common_attributes

    def validate_attributes(self) -> None:
        """Normalize and validate element attributes.

        Convert string values to expected datatype.
        Normalize values.

        Raise `ValidationError` for invalid attributes or attribute values.

        Provisional.
        """
        messages = []
        for key, value in self.attributes.items():
            if key.startswith('internal:'):
                continue  # see docs/user/config.html#expose-internals
            if key not in self.valid_attributes:
                va = '", "'.join(self.valid_attributes)
                messages.append(f'Attribute "{key}" not one of "{va}".')
                continue
            try:
                self.attributes[key] = ATTRIBUTE_VALIDATORS[key](value)
            except (ValueError, TypeError, KeyError) as e:
                messages.append(
                    f'Attribute "{key}" has invalid value "{value}".\n  {e}')
        if messages:
            raise ValidationError(f'Element {self.starttag()} invalid:\n  '
                                  + '\n  '.join(messages),
                                  problematic_element=self)

    def validate_content(self,
                         model: _ContentModelTuple | None = None,
                         elements: Sequence | None = None,
                         ) -> list:
        """Test compliance of `elements` with `model`.

        :model: content model description, default `self.content_model`,
        :elements: list of doctree elements, default `self.children`.

        Return list of children that do not fit in the model or raise
        `ValidationError` if the content does not comply with the `model`.

        Provisional.
        """
        if model is None:
            model = self.content_model
        if elements is None:
            elements = self.children
        ichildren = iter(elements)
        child = next(ichildren, None)
        for category, quantifier in model:
            if not isinstance(child, category):
                if quantifier in ('.', '+'):
                    raise ValidationError(self._report_child(child, category),
                                          problematic_element=child)
                else:  # quantifier in ('?', '*') -> optional child
                    continue  # try same child with next part of content model
            else:
                # Check additional placement constraints (if applicable):
                child.validate_position()
            # advance:
            if quantifier in ('.', '?'):  # go to next element
                child = next(ichildren, None)
            else:  # if quantifier in ('*', '+'):  # pass all matching elements
                for child in ichildren:
                    if not isinstance(child, category):
                        break
                    try:
                        child.validate_position()
                    except AttributeError:
                        pass
                else:
                    child = None
        return [] if child is None else [child, *ichildren]

    def _report_child(self,
                      child,
                      category: Element | Iterable[Element],
                      ) -> str:
        # Return a str reporting a missing child or child of wrong category.
        try:
            _type = category.__name__
        except AttributeError:
            _type = '> or <'.join(c.__name__ for c in category)
        msg = f'Element {self.starttag()} invalid:\n'
        if child is None:
            return f'{msg}  Missing child of type <{_type}>.'
        if isinstance(child, Text):
            return (f'{msg}  Expecting child of type <{_type}>, '
                    f'not text data "{child.astext()}".')
        return (f'{msg}  Expecting child of type <{_type}>, '
                f'not {child.starttag()}.')

    def validate(self, recursive: bool = True) -> None:
        """Validate Docutils Document Tree element ("doctree").

        Raise ValidationError if there are violations.
        If `recursive` is True, validate also the element's descendants.

        See `The Docutils Document Tree`__ for details of the
        Docutils Document Model.

        __ https://docutils.sourceforge.io/docs/ref/doctree.html

        Provisional (work in progress).
        """
        self.validate_attributes()

        leftover_childs = self.validate_content()
        for child in leftover_childs:
            if isinstance(child, Text):
                raise ValidationError(f'Element {self.starttag()} invalid:\n'
                                      f'  Spurious text: "{child.astext()}".',
                                      problematic_element=self)
            else:
                raise ValidationError(f'Element {self.starttag()} invalid:\n'
                                      f'  Child element {child.starttag()} '
                                      'not allowed at this position.',
                                      problematic_element=child)

        if recursive:
            for child in self:
                child.validate(recursive=recursive)


# ====================
#  Element Categories
# ====================
#
# See https://docutils.sourceforge.io/docs/ref/doctree.html#element-hierarchy.

class Root:
    """Element at the root of a document tree."""


class Structural:
    """`Structural elements`__.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html
       #structural-elements
    """


class SubStructural:
    """`Structural subelements`__ are children of `Structural` elements.

    Most Structural elements accept only specific `SubStructural` elements.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html
       #structural-subelements
    """


class Bibliographic:
    """`Bibliographic Elements`__ (displayed document meta-data).

    __ https://docutils.sourceforge.io/docs/ref/doctree.html
       #bibliographic-elements
    """


class Body:
    """`Body elements`__.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#body-elements
    """


class Admonition(Body):
    """Admonitions (distinctive and self-contained notices)."""
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class Sequential(Body):
    """List-like body elements."""


class General(Body):
    """Miscellaneous body elements."""


class Special(Body):
    """Special internal body elements."""


class Part:
    """`Body Subelements`__ always occur within specific parent elements.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#body-subelements
    """


class Decorative:
    """Decorative elements (`header` and `footer`).

    Children of `decoration`.
    """
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class Inline:
    """Inline elements contain text data and possibly other inline elements.
    """


# Orthogonal categories and Mixins
# ================================

class PreBibliographic:
    """Elements which may occur before Bibliographic Elements."""


class Invisible(Special, PreBibliographic):
    """Internal elements that don't appear in output."""


class Labeled:
    """Contains a `label` as its first element."""


class Resolvable:
    resolved: bool = False


class BackLinkable:
    """Mixin for Elements that accept a "backrefs" attribute."""

    list_attributes: Final = Element.list_attributes + ('backrefs',)
    valid_attributes: Final = Element.valid_attributes + ('backrefs',)

    def add_backref(self: Element, refid: str) -> None:
        self['backrefs'].append(refid)


class Referential(Resolvable):
    """Elements holding a cross-reference (outgoing hyperlink)."""


class Targetable(Resolvable):
    """Cross-reference targets (incoming hyperlink)."""
    referenced: int = 0

    indirect_reference_name: str | None = None
    """Holds the whitespace_normalized_name (contains mixed case) of a target.

    This was required for MoinMoin <= 1.9 compatibility.

    Deprecated, will be removed in Docutils 1.0.
    """


class Titular:
    """Title, sub-title, or informal heading (rubric)."""


class TextElement(Element):
    """
    An element which directly contains text.

    Its children are all `Text` or `Inline` subclass nodes.  You can
    check whether an element's context is inline simply by checking whether
    its immediate parent is a `TextElement` instance (including subclasses).
    This is handy for nodes like `image` that can appear both inline and as
    standalone body elements.

    If passing children to `__init__()`, make sure to set `text` to
    ``''`` or some other suitable value.
    """
    content_model: Final = (((Text, Inline), '*'),)
    # (#PCDATA | %inline.elements;)*

    child_text_separator: Final = ''
    """Separator for child nodes, used by `astext()` method."""

    def __init__(self,
                 rawsource: str = '',
                 text: str = '',
                 *children,
                 **attributes: Any,
                 ) -> None:
        if text:
            textnode = Text(text)
            Element.__init__(self, rawsource, textnode, *children,
                             **attributes)
        else:
            Element.__init__(self, rawsource, *children, **attributes)


class FixedTextElement(TextElement):
    """An element which directly contains preformatted text."""

    valid_attributes: Final = Element.valid_attributes + ('xml:space',)

    def __init__(self,
                 rawsource: str = '',
                 text: str = '',
                 *children,
                 **attributes: Any,
                 ) -> None:
        super().__init__(rawsource, text, *children, **attributes)
        self.attributes['xml:space'] = 'preserve'


class PureTextElement(TextElement):
    """An element which only contains text, no children."""
    content_model: Final = ((Text, '?'),)  # (#PCDATA)


# =================================
#  Concrete Document Tree Elements
# =================================
#
# See https://docutils.sourceforge.io/docs/ref/doctree.html#element-reference

# Decorative Elements
# ===================

class header(Decorative, Element): pass
class footer(Decorative, Element): pass


# Structural Subelements
# ======================

class title(Titular, PreBibliographic, SubStructural, TextElement):
    """Title of `document`, `section`, `topic` and generic `admonition`.
    """
    valid_attributes: Final = Element.valid_attributes + ('auto', 'refid')


class subtitle(Titular, PreBibliographic, SubStructural, TextElement):
    """Sub-title of `document`, `section` and `sidebar`."""

    def validate_position(self) -> None:
        """Check position of subtitle: must follow a title."""
        if self.parent and self.parent.index(self) == 0:
            raise ValidationError(f'Element {self.parent.starttag()} invalid:'
                                  '\n  <subtitle> only allowed after <title>.',
                                  problematic_element=self)


class meta(PreBibliographic, SubStructural, Element):
    """Container for "invisible" bibliographic data, or meta-data."""
    valid_attributes: Final = Element.valid_attributes + (
        'content', 'dir', 'http-equiv', 'lang', 'media', 'name', 'scheme')


class docinfo(SubStructural, Element):
    """Container for displayed document meta-data."""
    content_model: Final = ((Bibliographic, '+'),)
    # (%bibliographic.elements;)+


class decoration(PreBibliographic, SubStructural, Element):
    """Container for `header` and `footer`."""
    content_model: Final = ((header, '?'),  # Empty element doesn't make sense,
                            (footer, '?'),  # but is simpler to define.
                            )
    # (header?, footer?)

    def get_header(self) -> header:
        if not len(self.children) or not isinstance(self.children[0], header):
            self.insert(0, header())
        return self.children[0]

    def get_footer(self) -> footer:
        if not len(self.children) or not isinstance(self.children[-1], footer):
            self.append(footer())
        return self.children[-1]


class transition(SubStructural, Element):
    """Transitions__ are breaks between untitled text parts.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#transition
    """

    def validate_position(self) -> None:
        """Check additional constraints on `transition` placement.

        A transition may not begin or end a section or document,
        nor may two transitions be immediately adjacent.
        """
        messages = [f'Element {self.parent.starttag()} invalid:']
        predecessor = self.previous_sibling()
        if (predecessor is None  # index == 0
            or isinstance(predecessor, (title, subtitle, meta, decoration))
            # A transition following these elements still counts as
            # "at the beginning of a document or section".
            ):
            messages.append(
                '<transition> may not begin a section or document.')
        if self.parent.index(self) == len(self.parent) - 1:
            messages.append('<transition> may not end a section or document.')
        if isinstance(predecessor, transition):
            messages.append(
                '<transition> may not directly follow another transition.')
        if len(messages) > 1:
            raise ValidationError('\n  '.join(messages),
                                  problematic_element=self)


# Structural Elements
# ===================

class topic(Structural, Element):
    """
    Topics__ are non-recursive, mini-sections.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#topic
    """
    content_model: Final = ((title, '?'), (Body, '+'))
    # (title?, (%body.elements;)+)


class sidebar(Structural, Element):
    """
    Sidebars__ are like parallel documents providing related material.

    A sidebar is typically offset by a border and "floats" to the side
    of the page

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#sidebar
    """
    content_model: Final = ((title, '?'),
                            (subtitle, '?'),
                            ((topic, Body), '+'),
                            )
    # ((title, subtitle?)?, (%body.elements; | topic)+)
    # "subtitle only after title" is ensured in `subtitle.validate_position()`.


class section(Structural, Element):
    """Document section__. The main unit of hierarchy.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#section
    """
    # recursive content model, see below


section.content_model = ((title, '.'),
                         (subtitle, '?'),
                         ((Body, topic, sidebar, transition), '*'),
                         ((section, transition), '*'),
                         )
# (title, subtitle?, %structure.model;)
# Correct transition placement is ensured in `transition.validate_position()`.


# Root Element
# ============

class document(Root, Element):
    """
    The document root element.

    Do not instantiate this class directly; use
    `docutils.utils.new_document()` instead.
    """
    valid_attributes: Final = Element.valid_attributes + ('title',)
    content_model: Final = ((title, '?'),
                            (subtitle, '?'),
                            (meta, '*'),
                            (decoration, '?'),
                            (docinfo, '?'),
                            (transition, '?'),
                            ((Body, topic, sidebar, transition), '*'),
                            ((section, transition), '*'),
                            )
    # ( (title, subtitle?)?,
    #    meta*,
    #    decoration?,
    #    (docinfo, transition?)?,
    #    %structure.model; )
    # Additional restrictions for `subtitle` and `transition` are tested
    # with the respective `validate_position()` methods.

    def __init__(self,
                 settings: Values,
                 reporter: Reporter,
                 *args,
                 **kwargs: Any,
                 ) -> None:
        Element.__init__(self, *args, **kwargs)

        self.current_source: StrPath | None = None
        """Path to or description of the input source being processed."""

        self.current_line: int | None = None
        """Line number (1-based) of `current_source`."""

        self.settings: Values = settings
        """Runtime settings data record."""

        self.reporter: Reporter = reporter
        """System message generator."""

        self.indirect_targets: list[target] = []
        """List of indirect target nodes."""

        self.substitution_defs: dict[str, substitution_definition] = {}
        """Mapping of substitution names to substitution_definition nodes."""

        self.substitution_names: dict[str, str] = {}
        """Mapping of case-normalized to case-sensitive substitution names."""

        self.refnames: dict[str, list[Element]] = {}
        """Mapping of names to lists of referencing nodes."""

        self.refids: dict[str, list[Element]] = {}
        """Mapping of ids to lists of referencing nodes."""

        self.nameids: dict[str, str] = {}
        """Mapping of names to unique id's."""

        self.nametypes: dict[str, bool] = {}
        """Mapping of names to hyperlink type. True: explicit, False: implicit.
        """

        self.ids: dict[str, Element] = {}
        """Mapping of ids to nodes."""

        self.footnote_refs: dict[str, list[footnote_reference]] = {}
        """Mapping of footnote labels to lists of footnote_reference nodes."""

        self.citation_refs: dict[str, list[citation_reference]] = {}
        """Mapping of citation labels to lists of citation_reference nodes."""

        self.autofootnotes: list[footnote] = []
        """List of auto-numbered footnote nodes."""

        self.autofootnote_refs: list[footnote_reference] = []
        """List of auto-numbered footnote_reference nodes."""

        self.symbol_footnotes: list[footnote] = []
        """List of symbol footnote nodes."""

        self.symbol_footnote_refs: list[footnote_reference] = []
        """List of symbol footnote_reference nodes."""

        self.footnotes: list[footnote] = []
        """List of manually-numbered footnote nodes."""

        self.citations: list[citation] = []
        """List of citation nodes."""

        self.autofootnote_start: int = 1
        """Initial auto-numbered footnote number."""

        self.symbol_footnote_start: int = 0
        """Initial symbol footnote symbol index."""

        self.id_counter: Counter[int] = Counter()
        """Numbers added to otherwise identical IDs."""

        self.parse_messages: list[system_message] = []
        """System messages generated while parsing."""

        self.transform_messages: list[system_message] = []
        """System messages generated while applying transforms."""

        import docutils.transforms
        self.transformer: Transformer = docutils.transforms.Transformer(self)
        """Storage for transforms to be applied to this document."""

        self.include_log: list[tuple[StrPath, tuple]] = []
        """The current source's parents (to detect inclusion loops)."""

        self.decoration: decoration | None = None
        """Document's `decoration` node."""

        self._document: document = self

    def __getstate__(self) -> dict[str, Any]:
        """
        Return dict with unpicklable references removed.
        """
        state = self.__dict__.copy()
        state['reporter'] = None
        state['transformer'] = None
        return state

    def asdom(self, dom: ModuleType | None = None) -> minidom.Document:
        """Return a DOM representation of this document."""
        if dom is None:
            import xml.dom.minidom as dom
        domroot = dom.Document()
        domroot.appendChild(self._dom_node(domroot))
        return domroot

    def set_id(self,
               node: Element,
               msgnode: Element | None = None,
               suggested_prefix: str = '',
               ) -> str:
        if node['ids']:
            # register and check for duplicates
            for id in node['ids']:
                self.ids.setdefault(id, node)
                if self.ids[id] is not node:
                    msg = self.reporter.error(f'Duplicate ID: "{id}" used by '
                                              f'{self.ids[id].starttag()} '
                                              f'and {node.starttag()}',
                                              base_node=node)
                    if msgnode is not None:
                        msgnode += msg
            return id
        # generate and set id
        id_prefix = self.settings.id_prefix
        auto_id_prefix = self.settings.auto_id_prefix
        base_id = ''
        id = ''
        for name in node['names']:
            if id_prefix:  # allow names starting with numbers
                base_id = make_id('x'+name)[1:]
            else:
                base_id = make_id(name)
            # TODO: normalize id-prefix? (would make code simpler)
            id = id_prefix + base_id
            if base_id and id not in self.ids:
                break
        else:
            if base_id and auto_id_prefix.endswith('%'):
                # disambiguate name-derived ID
                # TODO: remove second condition after announcing change
                prefix = id + '-'
            else:
                prefix = id_prefix + auto_id_prefix
                if prefix.endswith('%'):
                    prefix = f"""{prefix[:-1]}{suggested_prefix
                                               or make_id(node.tagname)}-"""
            while True:
                self.id_counter[prefix] += 1
                id = f'{prefix}{self.id_counter[prefix]}'
                if id not in self.ids:
                    break
        node['ids'].append(id)
        self.ids[id] = node
        return id

    def set_name_id_map(self,
                        node: Element,
                        id: str,
                        msgnode: Element | None = None,
                        explicit: bool = False,
                        ) -> None:
        """
        Update the name/id mappings.

        `self.nameids` maps names to IDs. The value ``None`` indicates
        that the name is a "dupname" (i.e. there are already at least
        two targets with the same name and type).

        `self.nametypes` maps names to booleans representing
        hyperlink target type (True==explicit, False==implicit).

        The following state transition table shows how `self.nameids` items
        ("id") and `self.nametypes` items ("type") change with new input
        (a call to this method), and what actions are performed:

        ========  ====  ========  ====  ========  ======== =======  ======
         Input      Old State      New State            Action      Notes
        --------  --------------  --------------  ----------------  ------
        type      id    type      id    type      dupname  report
        ========  ====  ========  ====  ========  ======== =======  ======
        explicit                  new   explicit
        implicit                  new   implicit
        explicit  old   explicit  None  explicit  new,old  WARNING  [#ex]_
        implicit  old   explicit  old   explicit  new      INFO     [#ex]_
        explicit  old   implicit  new   explicit  old      INFO     [#ex]_
        implicit  old   implicit  None  implicit  new,old  INFO     [#ex]_
        explicit  None  explicit  None  explicit  new      WARNING
        implicit  None  explicit  None  explicit  new      INFO
        explicit  None  implicit  new   explicit
        implicit  None  implicit  None  implicit  new      INFO
        ========  ====  ========  ====  ========  ======== =======  ======

        .. [#] Do not clear the name-to-id map or invalidate the old target if
           both old and new targets refer to identical URIs or reference names.
           The new target is invalidated regardless.

        Provisional. There will be changes to prefer explicit reference names
        as base for an element's ID.
        """
        for name in tuple(node['names']):
            if name in self.nameids:
                self.set_duplicate_name_id(node, id, name, msgnode, explicit)
                # attention: modifies node['names']
            else:
                self.nameids[name] = id
                self.nametypes[name] = explicit

    def set_duplicate_name_id(self,
                              node: Element,
                              id: str,
                              name: str,
                              msgnode: Element,
                              explicit: bool,
                              ) -> None:
        old_id = self.nameids[name]  # None if name is only dupname
        old_explicit = self.nametypes[name]
        old_node = self.ids.get(old_id)
        level = 0  # system message level: 1-info, 2-warning

        self.nametypes[name] = old_explicit or explicit

        if old_id is not None and (
            'refname' in node and node['refname'] == old_node.get('refname')
            or 'refuri' in node and node['refuri'] == old_node.get('refuri')
            ):
            # indirect targets with same reference -> keep old target
            level = 1
            ref = node.get('refuri') or node.get('refname')
            s = f'Duplicate name "{name}" for external target "{ref}".'
            dupname(node, name)
        elif explicit:
            if old_explicit:
                level = 2
                s = f'Duplicate explicit target name: "{name}".'
                dupname(node, name)
                if old_id is not None:
                    dupname(old_node, name)
                    self.nameids[name] = None
            else:  # new explicit, old implicit -> override
                self.nameids[name] = id
                if old_id is not None:
                    level = 1
                    s = f'Target name overrides implicit target name "{name}".'
                    dupname(old_node, name)
        else:  # new name is implicit
            level = 1
            s = f'Duplicate implicit target name: "{name}".'
            dupname(node, name)
            if old_id is not None and not old_explicit:
                dupname(old_node, name)
                self.nameids[name] = None

        if level:
            backrefs = [id]
            # don't add backref id for empty targets (not shown in output)
            if isinstance(node, target) and 'refuri' in node:
                backrefs = []
            msg = self.reporter.system_message(level, s,
                                               backrefs=backrefs,
                                               base_node=node)
            # try appending near to the problem:
            if msgnode is not None:
                msgnode += msg
                try:
                    msgnode.validate(recursive=False)
                except ValidationError:
                    # detach -> will be handled by `Messages` transform
                    msgnode.pop()
                    msg.parent = None

    def has_name(self, name: str) -> bool:
        return name in self.nameids

    # "note" here is an imperative verb: "take note of".
    def note_implicit_target(
            self, target: Element, msgnode: Element | None = None) -> None:
        # TODO: Postpone ID creation.  Register reference name instead of ID
        # to allow for IDs based on explicit target pointing to the same
        # element.  https://github.com/sphinx-doc/sphinx/issues/1961
        id = self.set_id(target, msgnode)
        self.set_name_id_map(target, id, msgnode, explicit=False)

    def note_explicit_target(
            self, target: Element, msgnode: Element | None = None) -> None:
        id = self.set_id(target, msgnode)
        self.set_name_id_map(target, id, msgnode, explicit=True)

    def note_refname(self, node: Element) -> None:
        self.refnames.setdefault(node['refname'], []).append(node)

    def note_refid(self, node: Element) -> None:
        self.refids.setdefault(node['refid'], []).append(node)

    def note_indirect_target(self, target: target) -> None:
        self.indirect_targets.append(target)
        if target['names']:
            self.note_refname(target)

    def note_anonymous_target(self, target: target) -> None:
        self.set_id(target)

    def note_autofootnote(self, footnote: footnote) -> None:
        self.set_id(footnote)
        self.autofootnotes.append(footnote)

    def note_autofootnote_ref(self, ref: footnote_reference) -> None:
        self.set_id(ref)
        self.autofootnote_refs.append(ref)

    def note_symbol_footnote(self, footnote: footnote) -> None:
        self.set_id(footnote)
        self.symbol_footnotes.append(footnote)

    def note_symbol_footnote_ref(self, ref: footnote_reference) -> None:
        self.set_id(ref)
        self.symbol_footnote_refs.append(ref)

    def note_footnote(self, footnote: footnote) -> None:
        self.set_id(footnote)
        self.footnotes.append(footnote)

    def note_footnote_ref(self, ref: footnote_reference) -> None:
        self.set_id(ref)
        self.footnote_refs.setdefault(ref['refname'], []).append(ref)
        self.note_refname(ref)

    def note_citation(self, citation: citation) -> None:
        self.citations.append(citation)

    def note_citation_ref(self, ref: citation_reference) -> None:
        self.set_id(ref)
        self.citation_refs.setdefault(ref['refname'], []).append(ref)
        self.note_refname(ref)

    def note_substitution_def(self,
                              subdef: substitution_definition,
                              def_name: str,
                              msgnode: Element | None = None,
                              ) -> None:
        name = whitespace_normalize_name(def_name)
        if name in self.substitution_defs:
            msg = self.reporter.error(
                      'Duplicate substitution definition name: "%s".' % name,
                      base_node=subdef)
            if msgnode is not None:
                msgnode += msg
            oldnode = self.substitution_defs[name]
            dupname(oldnode, name)
        # keep only the last definition:
        self.substitution_defs[name] = subdef
        # case-insensitive mapping:
        self.substitution_names[fully_normalize_name(name)] = name

    def note_substitution_ref(self,
                              subref: substitution_reference,
                              refname: str,
                              ) -> None:
        subref['refname'] = whitespace_normalize_name(refname)

    def note_pending(
            self, pending: pending, priority: int | None = None) -> None:
        self.transformer.add_pending(pending, priority)

    def note_parse_message(self, message: system_message) -> None:
        self.parse_messages.append(message)

    def note_transform_message(self, message: system_message) -> None:
        self.transform_messages.append(message)

    def note_source(self,
                    source: StrPath | None,
                    offset: int | None,
                    ) -> None:
        self.current_source = source and os.fspath(source)
        if offset is None:
            self.current_line = offset
        else:
            self.current_line = offset + 1

    def copy(self) -> Self:
        obj = self.__class__(self.settings, self.reporter,
                             **self.attributes)
        obj.source = self.source
        obj.line = self.line
        return obj

    def get_decoration(self) -> decoration:
        if not self.decoration:
            self.decoration: decoration = decoration()
            index = self.first_child_not_matching_class((Titular, meta))
            if index is None:
                self.append(self.decoration)
            else:
                self.insert(index, self.decoration)
        return self.decoration


# Bibliographic Elements
# ======================

class author(Bibliographic, TextElement): pass
class organization(Bibliographic, TextElement): pass
class address(Bibliographic, FixedTextElement): pass
class contact(Bibliographic, TextElement): pass
class version(Bibliographic, TextElement): pass
class revision(Bibliographic, TextElement): pass
class status(Bibliographic, TextElement): pass
class date(Bibliographic, TextElement): pass
class copyright(Bibliographic, TextElement): pass  # NoQA: A001 (builtin name)


class authors(Bibliographic, Element):
    """Container for author information for documents with multiple authors.
    """
    content_model: Final = ((author, '+'),
                            (organization, '?'),
                            (address, '?'),
                            (contact, '?'),
                            )
    # (author, organization?, address?, contact?)+

    def validate_content(self,
                         model: _ContentModelTuple | None = None,
                         elements: Sequence | None = None,
                         ) -> list:
        """Repeatedly test for children matching the content model.

        Provisional.
        """
        relics = super().validate_content()
        while relics:
            relics = super().validate_content(elements=relics)
        return relics


# Body Elements
# =============
#
# General
# -------
#
# Miscellaneous Body Elements and related Body Subelements (Part)

class paragraph(General, TextElement): pass
class rubric(Titular, General, TextElement): pass


class compound(General, Element):
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class container(General, Element):
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class attribution(Part, TextElement):
    """Visible reference to the source of a `block_quote`."""


class block_quote(General, Element):
    """An extended quotation, set off from the main text."""
    content_model: Final = ((Body, '+'), (attribution, '?'))
    # ((%body.elements;)+, attribution?)


class reference(General, Inline, Referential, TextElement):
    valid_attributes: Final = Element.valid_attributes + (
        'anonymous', 'name', 'refid', 'refname', 'refuri')


# Lists
# -----
#
# Lists (Sequential) and related Body Subelements (Part)

class list_item(Part, Element):
    content_model: Final = ((Body, '*'),)  # (%body.elements;)*


class bullet_list(Sequential, Element):
    valid_attributes: Final = Element.valid_attributes + ('bullet',)
    content_model: Final = ((list_item, '+'),)  # (list_item+)


class enumerated_list(Sequential, Element):
    valid_attributes: Final = Element.valid_attributes + (
        'enumtype', 'prefix', 'suffix', 'start')
    content_model: Final = ((list_item, '+'),)  # (list_item+)


class term(Part, TextElement): pass
class classifier(Part, TextElement): pass


class definition(Part, Element):
    """Definition of a `term` in a `definition_list`."""
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class definition_list_item(Part, Element):
    content_model: Final = ((term, '.'),
                            ((classifier, term), '*'),
                            (definition, '.'),
                            )
    # ((term, classifier*)+, definition)


class definition_list(Sequential, Element):
    """List of terms and their definitions.

    Can be used for glossaries or dictionaries, to describe or
    classify things, for dialogues, or to itemize subtopics.
    """
    content_model: Final = ((definition_list_item, '+'),)
    # (definition_list_item+)


class field_name(Part, TextElement): pass


class field_body(Part, Element):
    content_model: Final = ((Body, '*'),)  # (%body.elements;)*


class field(Part, Bibliographic, Element):
    content_model: Final = ((field_name, '.'), (field_body, '.'))
    # (field_name, field_body)


class field_list(Sequential, Element):
    """List of label & data pairs.

    Typically rendered as a two-column list.
    Also used for extension syntax or special processing.
    """
    content_model: Final = ((field, '+'),)  # (field+)


class option_string(Part, PureTextElement):
    """A literal command-line option. Typically monospaced."""


class option_argument(Part, PureTextElement):
    """Placeholder text for option arguments."""
    valid_attributes: Final = Element.valid_attributes + ('delimiter',)

    def astext(self) -> str:
        return self.get('delimiter', ' ') + TextElement.astext(self)


class option(Part, Element):
    """Option element in an `option_list_item`.

    Groups an option string with zero or more option argument placeholders.
    """
    child_text_separator: Final = ''
    content_model: Final = ((option_string, '.'), (option_argument, '*'))
    # (option_string, option_argument*)


class option_group(Part, Element):
    """Groups together one or more `option` elements, all synonyms."""
    child_text_separator: Final = ', '
    content_model: Final = ((option, '+'),)  # (option+)


class description(Part, Element):
    """Describtion of a command-line option."""
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class option_list_item(Part, Element):
    """Container for a pair of `option_group` and `description` elements.
    """
    child_text_separator: Final = '  '
    content_model: Final = ((option_group, '.'), (description, '.'))
    # (option_group, description)


class option_list(Sequential, Element):
    """Two-column list of command-line options and descriptions."""
    content_model: Final = ((option_list_item, '+'),)  # (option_list_item+)


# Pre-formatted text blocks
# -------------------------

class literal_block(General, FixedTextElement): pass
class doctest_block(General, FixedTextElement): pass


class math_block(General, FixedTextElement, PureTextElement):
    """Mathematical notation (display formula)."""


class line(Part, TextElement):
    """Single line of text in a `line_block`."""
    indent: str | None = None


class line_block(General, Element):
    """Sequence of lines and nested line blocks.
    """
    # recursive content model: (line | line_block)+


line_block.content_model = (((line, line_block), '+'),)


# Admonitions
# -----------
# distinctive and self-contained notices

class attention(Admonition, Element): pass
class caution(Admonition, Element): pass
class danger(Admonition, Element): pass
class error(Admonition, Element): pass
class important(Admonition, Element): pass
class note(Admonition, Element): pass
class tip(Admonition, Element): pass
class hint(Admonition, Element): pass
class warning(Admonition, Element): pass


class admonition(Admonition, Element):
    content_model: Final = ((title, '.'), (Body, '+'))
    # (title, (%body.elements;)+)


# Footnote and citation
# ---------------------

class label(Part, PureTextElement):
    """Visible identifier for footnotes and citations."""


class footnote(General, BackLinkable, Element, Labeled, Targetable):
    """Labelled note providing additional context (footnote or endnote)."""
    valid_attributes: Final = Element.valid_attributes + ('auto', 'backrefs')
    content_model: Final = ((label, '?'), (Body, '+'))
    # (label?, (%body.elements;)+)
    # The label will become required in Docutils 1.0.


class citation(General, BackLinkable, Element, Labeled, Targetable):
    content_model: Final = ((label, '.'), (Body, '+'))
    # (label, (%body.elements;)+)


# Graphical elements
# ------------------

class image(General, Inline, Element):
    """Reference to an image resource.

    May be body element or inline element.
    """
    valid_attributes: Final = Element.valid_attributes + (
        'uri', 'alt', 'align', 'height', 'width', 'scale', 'loading')

    def astext(self) -> str:
        return self.get('alt', '')


class caption(Part, TextElement): pass


class legend(Part, Element):
    """A wrapper for text accompanying a `figure` that is not the caption."""
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+


class figure(General, Element):
    """A formal figure, generally an illustration, with a title."""
    valid_attributes: Final = Element.valid_attributes + ('align', 'width')
    content_model: Final = (((image, reference), '.'),
                            (caption, '?'),
                            (legend, '?'),
                            )
    # (image, ((caption, legend?) | legend))
    # TODO: According to the DTD, a caption or legend is required
    # but rST allows "bare" figures which are formatted differently from
    # images (floating in LaTeX, nested in a <figure> in HTML). [bugs: #489]


# Tables
# ------

class entry(Part, Element):
    """An entry in a `row` (a table cell)."""
    valid_attributes: Final = Element.valid_attributes + (
        'align', 'char', 'charoff', 'colname', 'colsep', 'morecols',
        'morerows', 'namest', 'nameend', 'rowsep', 'valign')
    content_model: Final = ((Body, '*'),)
    # %tbl.entry.mdl -> (%body.elements;)*


class row(Part, Element):
    """Row of table cells."""
    valid_attributes: Final = Element.valid_attributes + ('rowsep', 'valign')
    content_model: Final = ((entry, '+'),)  # (%tbl.row.mdl;) -> entry+


class colspec(Part, Element):
    """Specifications for a column in a `tgroup`."""
    valid_attributes: Final = Element.valid_attributes + (
        'align', 'char', 'charoff', 'colname', 'colnum',
        'colsep', 'colwidth', 'rowsep', 'stub')

    def propwidth(self) -> int|float:
        """Return numerical value of "colwidth__" attribute. Default 1.

        Raise ValueError if "colwidth" is zero, negative, or a *fixed value*.

        Provisional.

        __ https://docutils.sourceforge.io/docs/ref/doctree.html#colwidth
        """
        # Move current implementation of validate_colwidth() here
        # in Docutils 1.0
        return validate_colwidth(self.get('colwidth', ''))


class thead(Part, Element):
    """Row(s) that form the head of a `tgroup`."""
    valid_attributes: Final = Element.valid_attributes + ('valign',)
    content_model: Final = ((row, '+'),)  # (row+)


class tbody(Part, Element):
    """Body of a `tgroup`."""
    valid_attributes: Final = Element.valid_attributes + ('valign',)
    content_model: Final = ((row, '+'),)  # (row+)


class tgroup(Part, Element):
    """A portion of a table. Most tables have just one `tgroup`."""
    valid_attributes: Final = Element.valid_attributes + (
        'align', 'cols', 'colsep', 'rowsep')
    content_model: Final = ((colspec, '*'), (thead, '?'), (tbody, '.'))
    # (colspec*, thead?, tbody)


class table(General, Element):
    """A data arrangement with rows and columns."""
    valid_attributes: Final = Element.valid_attributes + (
        'align', 'colsep', 'frame', 'pgwide', 'rowsep', 'width')
    content_model: Final = ((title, '?'), (tgroup, '+'))
    # (title?, tgroup+)


# Special purpose elements
# ------------------------
# Body elements for internal use or special requests.

class comment(Invisible, FixedTextElement, PureTextElement):
    """Author notes, hidden from the output."""


class substitution_definition(Invisible, TextElement):
    valid_attributes: Final = Element.valid_attributes + ('ltrim', 'rtrim')


class target(Invisible, Inline, TextElement, Targetable):
    valid_attributes: Final = Element.valid_attributes + (
        'anonymous', 'refid', 'refname', 'refuri')


class system_message(Special, BackLinkable, PreBibliographic, Element):
    """
    System message element.

    Do not instantiate this class directly; use
    ``document.reporter.info/warning/error/severe()`` instead.
    """
    valid_attributes: Final = BackLinkable.valid_attributes + (
                           'level', 'line', 'type')
    content_model: Final = ((Body, '+'),)  # (%body.elements;)+

    def __init__(self,
                 message: str | None = None,
                 *children,
                 **attributes: Any,
                 ) -> None:
        rawsource = attributes.pop('rawsource', '')
        if message:
            p = paragraph('', message)
            children = (p,) + children
        try:
            Element.__init__(self, rawsource, *children, **attributes)
        except:  # NoQA: E722 (catchall)
            print('system_message: children=%r' % (children,))
            raise

    def astext(self) -> str:
        line = self.get('line', '')
        return '%s:%s: (%s/%s) %s' % (self['source'], line, self['type'],
                                      self['level'], Element.astext(self))


class pending(Invisible, Element):
    """
    Placeholder for pending operations.

    The "pending" element is used to encapsulate a pending operation: the
    operation (transform), the point at which to apply it, and any data it
    requires.  Only the pending operation's location within the document is
    stored in the public document tree (by the "pending" object itself); the
    operation and its data are stored in the "pending" object's internal
    instance attributes.

    For example, say you want a table of contents in your reStructuredText
    document.  The easiest way to specify where to put it is from within the
    document, with a directive::

        .. contents::

    But the "contents" directive can't do its work until the entire document
    has been parsed and possibly transformed to some extent.  So the directive
    code leaves a placeholder behind that will trigger the second phase of its
    processing, something like this::

        <pending ...public attributes...> + internal attributes

    Use `document.note_pending()` so that the
    `docutils.transforms.Transformer` stage of processing can run all pending
    transforms.
    """

    def __init__(self,
                 transform: Transform,
                 details: Mapping[str, Any] | None = None,
                 rawsource: str = '',
                 *children,
                 **attributes: Any,
                 ) -> None:
        Element.__init__(self, rawsource, *children, **attributes)

        self.transform: Transform = transform
        """The `docutils.transforms.Transform` class implementing the pending
        operation."""

        self.details: Mapping[str, Any] = details or {}
        """Detail data (dictionary) required by the pending operation."""

    def pformat(self, indent: str = '    ', level: int = 0) -> str:
        internals = ['.. internal attributes:',
                     '     .transform: %s.%s' % (self.transform.__module__,
                                                 self.transform.__name__),
                     '     .details:']
        details = sorted(self.details.items())
        for key, value in details:
            if isinstance(value, Node):
                internals.append('%7s%s:' % ('', key))
                internals.extend(['%9s%s' % ('', line)
                                  for line in value.pformat().splitlines()])
            elif (value
                  and isinstance(value, list)
                  and isinstance(value[0], Node)):
                internals.append('%7s%s:' % ('', key))
                for v in value:
                    internals.extend(['%9s%s' % ('', line)
                                      for line in v.pformat().splitlines()])
            else:
                internals.append('%7s%s: %r' % ('', key, value))
        return (Element.pformat(self, indent, level)
                + ''.join(('    %s%s\n' % (indent * level, line))
                          for line in internals))

    def copy(self) -> Self:
        obj = self.__class__(self.transform, self.details, self.rawsource,
                             **self.attributes)
        obj._document = self._document
        obj.source = self.source
        obj.line = self.line
        return obj


class raw(Special, Inline, PreBibliographic,
          FixedTextElement, PureTextElement):
    """Raw data that is to be passed untouched to the Writer.

    Can be used as Body element or Inline element.
    """
    valid_attributes: Final = Element.valid_attributes + (
        'format', 'xml:space')


# Inline Elements
# ===============

class abbreviation(Inline, TextElement): pass
class acronym(Inline, TextElement): pass
class emphasis(Inline, TextElement): pass
class generated(Inline, TextElement): pass
class inline(Inline, TextElement): pass
class literal(Inline, TextElement): pass
class strong(Inline, TextElement): pass
class subscript(Inline, TextElement): pass
class superscript(Inline, TextElement): pass
class title_reference(Inline, TextElement): pass


class footnote_reference(Inline, Referential, PureTextElement):
    valid_attributes: Final = Element.valid_attributes + (
        'auto', 'refid', 'refname')


class citation_reference(Inline, Referential, PureTextElement):
    valid_attributes: Final = Element.valid_attributes + ('refid', 'refname')


class substitution_reference(Inline, TextElement):
    valid_attributes: Final = Element.valid_attributes + ('refname',)


class math(Inline, PureTextElement):
    """Mathematical notation in running text."""


class problematic(Inline, TextElement):
    valid_attributes: Final = Element.valid_attributes + (
                           'refid', 'refname', 'refuri')


# ========================================
#  Auxiliary Classes, Functions, and Data
# ========================================

node_class_names: Sequence[str] = """
    Text
    abbreviation acronym address admonition attention attribution author
        authors
    block_quote bullet_list
    caption caution citation citation_reference classifier colspec comment
        compound contact container copyright
    danger date decoration definition definition_list definition_list_item
        description docinfo doctest_block document
    emphasis entry enumerated_list error
    field field_body field_list field_name figure footer
        footnote footnote_reference
    generated
    header hint
    image important inline
    label legend line line_block list_item literal literal_block
    math math_block meta
    note
    option option_argument option_group option_list option_list_item
        option_string organization
    paragraph pending problematic
    raw reference revision row rubric
    section sidebar status strong subscript substitution_definition
        substitution_reference subtitle superscript system_message
    table target tbody term tgroup thead tip title title_reference topic
        transition
    version
    warning""".split()
"""A list of names of all concrete Node subclasses."""


class NodeVisitor:
    """
    "Visitor" pattern [GoF95]_ abstract superclass implementation for
    document tree traversals.

    Each node class has corresponding methods, doing nothing by
    default; override individual methods for specific and useful
    behaviour.  The `dispatch_visit()` method is called by
    `Node.walk()` upon entering a node.  `Node.walkabout()` also calls
    the `dispatch_departure()` method before exiting a node.

    The dispatch methods call "``visit_`` + node class name" or
    "``depart_`` + node class name", resp.

    This is a base class for visitors whose ``visit_...`` & ``depart_...``
    methods must be implemented for *all* compulsory node types encountered
    (such as for `docutils.writers.Writer` subclasses).
    Unimplemented methods will raise exceptions (except for optional nodes).

    For sparse traversals, where only certain node types are of interest, use
    subclass `SparseNodeVisitor` instead.  When (mostly or entirely) uniform
    processing is desired, subclass `GenericNodeVisitor`.

    .. [GoF95] Gamma, Helm, Johnson, Vlissides. *Design Patterns: Elements of
       Reusable Object-Oriented Software*. Addison-Wesley, Reading, MA, USA,
       1995.
    """

    optional: ClassVar[tuple[str, ...]] = ('meta',)
    """
    Tuple containing node class names (as strings).

    No exception will be raised if writers do not implement visit
    or departure functions for these node classes.

    Used to ensure transitional compatibility with existing 3rd-party writers.
    """

    def __init__(self, document: document, /) -> None:
        self.document: document = document

    def dispatch_visit(self, node) -> None:
        """
        Call self."``visit_`` + node class name" with `node` as
        parameter.  If the ``visit_...`` method does not exist, call
        self.unknown_visit.
        """
        node_name = node.__class__.__name__
        method = getattr(self, 'visit_' + node_name, self.unknown_visit)
        self.document.reporter.debug(
            'docutils.nodes.NodeVisitor.dispatch_visit calling %s for %s'
            % (method.__name__, node_name))
        return method(node)

    def dispatch_departure(self, node) -> None:
        """
        Call self."``depart_`` + node class name" with `node` as
        parameter.  If the ``depart_...`` method does not exist, call
        self.unknown_departure.
        """
        node_name = node.__class__.__name__
        method = getattr(self, 'depart_' + node_name, self.unknown_departure)
        self.document.reporter.debug(
            'docutils.nodes.NodeVisitor.dispatch_departure calling %s for %s'
            % (method.__name__, node_name))
        return method(node)

    def unknown_visit(self, node) -> None:
        """
        Called when entering unknown `Node` types.

        Raise an exception unless overridden.
        """
        if (self.document.settings.strict_visitor
            or node.__class__.__name__ not in self.optional):
            raise NotImplementedError(
                '%s visiting unknown node type: %s'
                % (self.__class__, node.__class__.__name__))

    def unknown_departure(self, node) -> None:
        """
        Called before exiting unknown `Node` types.

        Raise exception unless overridden.
        """
        if (self.document.settings.strict_visitor
            or node.__class__.__name__ not in self.optional):
            raise NotImplementedError(
                '%s departing unknown node type: %s'
                % (self.__class__, node.__class__.__name__))


class SparseNodeVisitor(NodeVisitor):
    """
    Base class for sparse traversals, where only certain node types are of
    interest.  When ``visit_...`` & ``depart_...`` methods should be
    implemented for *all* node types (such as for `docutils.writers.Writer`
    subclasses), subclass `NodeVisitor` instead.
    """


class GenericNodeVisitor(NodeVisitor):
    """
    Generic "Visitor" abstract superclass, for simple traversals.

    Unless overridden, each ``visit_...`` method calls `default_visit()`, and
    each ``depart_...`` method (when using `Node.walkabout()`) calls
    `default_departure()`. `default_visit()` (and `default_departure()`) must
    be overridden in subclasses.

    Define fully generic visitors by overriding `default_visit()` (and
    `default_departure()`) only. Define semi-generic visitors by overriding
    individual ``visit_...()`` (and ``depart_...()``) methods also.

    `NodeVisitor.unknown_visit()` (`NodeVisitor.unknown_departure()`) should
    be overridden for default behavior.
    """

    def default_visit(self, node):
        """Override for generic, uniform traversals."""
        raise NotImplementedError

    def default_departure(self, node):
        """Override for generic, uniform traversals."""
        raise NotImplementedError


def _call_default_visit(self: GenericNodeVisitor, node) -> None:
    self.default_visit(node)


def _call_default_departure(self: GenericNodeVisitor, node) -> None:
    self.default_departure(node)


def _nop(self: SparseNodeVisitor, node) -> None:
    pass


def _add_node_class_names(names) -> None:
    """Save typing with dynamic assignments:"""
    for _name in names:
        setattr(GenericNodeVisitor, "visit_" + _name, _call_default_visit)
        setattr(GenericNodeVisitor, "depart_" + _name, _call_default_departure)
        setattr(SparseNodeVisitor, 'visit_' + _name, _nop)
        setattr(SparseNodeVisitor, 'depart_' + _name, _nop)


_add_node_class_names(node_class_names)


class TreeCopyVisitor(GenericNodeVisitor):
    """
    Make a complete copy of a tree or branch, including element attributes.
    """

    def __init__(self, document: document) -> None:
        super().__init__(document)
        self.parent_stack: list[list] = []
        self.parent: list = []

    def get_tree_copy(self):
        return self.parent[0]

    def default_visit(self, node) -> None:
        """Copy the current node, and make it the new acting parent."""
        newnode = node.copy()
        self.parent.append(newnode)
        self.parent_stack.append(self.parent)
        self.parent = newnode

    def default_departure(self, node) -> None:
        """Restore the previous acting parent."""
        self.parent = self.parent_stack.pop()


# Custom Exceptions
# =================

class ValidationError(ValueError):
    """Invalid Docutils Document Tree Element."""
    def __init__(self, msg: str, problematic_element: Element = None) -> None:
        super().__init__(msg)
        self.problematic_element = problematic_element


class TreePruningException(Exception):
    """
    Base class for `NodeVisitor`-related tree pruning exceptions.

    Raise subclasses from within ``visit_...`` or ``depart_...`` methods
    called from `Node.walk()` and `Node.walkabout()` tree traversals to prune
    the tree traversed.
    """


class SkipChildren(TreePruningException):
    """
    Do not visit any children of the current node.  The current node's
    siblings and ``depart_...`` method are not affected.
    """


class SkipSiblings(TreePruningException):
    """
    Do not visit any more siblings (to the right) of the current node.  The
    current node's children and its ``depart_...`` method are not affected.
    """


class SkipNode(TreePruningException):
    """
    Do not visit the current node's children, and do not call the current
    node's ``depart_...`` method.
    """


class SkipDeparture(TreePruningException):
    """
    Do not call the current node's ``depart_...`` method.  The current node's
    children and siblings are not affected.
    """


class NodeFound(TreePruningException):
    """
    Raise to indicate that the target of a search has been found.  This
    exception must be caught by the client; it is not caught by the traversal
    code.
    """


class StopTraversal(TreePruningException):
    """
    Stop the traversal altogether.  The current node's ``depart_...`` method
    is not affected.  The parent nodes ``depart_...`` methods are also called
    as usual.  No other nodes are visited.  This is an alternative to
    NodeFound that does not cause exception handling to trickle up to the
    caller.
    """


# definition moved here from `utils` to avoid circular import dependency
def unescape(text: str,
             restore_backslashes: bool = False,
             respect_whitespace: bool = False,
             ) -> str:
    """
    Return a string with nulls removed or restored to backslashes.
    Backslash-escaped spaces are also removed.
    """
    # `respect_whitespace` is ignored (since introduction 2016-12-16)
    if restore_backslashes:
        return text.replace('\x00', '\\')
    else:
        for sep in ['\x00 ', '\x00\n', '\x00']:
            text = ''.join(text.split(sep))
        return text


def make_id(string: str) -> str:
    """
    Convert `string` into an identifier and return it.

    Docutils identifiers will conform to the regular expression
    ``[a-z](-?[a-z0-9]+)*``.  For CSS compatibility, identifiers (the "class"
    and "id" attributes) should have no underscores, colons, or periods.
    Hyphens may be used.

    - The `HTML 4.01 spec`_ defines identifiers based on SGML tokens:

          ID and NAME tokens must begin with a letter ([A-Za-z]) and may be
          followed by any number of letters, digits ([0-9]), hyphens ("-"),
          underscores ("_"), colons (":"), and periods (".").

    - However the `CSS1 spec`_ defines identifiers based on the "name" token,
      a tighter interpretation ("flex" tokenizer notation; "latin1" and
      "escape" 8-bit characters have been replaced with entities)::

          unicode     \\[0-9a-f]{1,4}
          latin1      [&iexcl;-&yuml;]
          escape      {unicode}|\\[ -~&iexcl;-&yuml;]
          nmchar      [-a-z0-9]|{latin1}|{escape}
          name        {nmchar}+

    The CSS1 "nmchar" rule does not include underscores ("_"), colons (":"),
    or periods ("."), therefore "class" and "id" attributes should not contain
    these characters. They should be replaced with hyphens ("-"). Combined
    with HTML's requirements (the first character must be a letter; no
    "unicode", "latin1", or "escape" characters), this results in the
    ``[a-z](-?[a-z0-9]+)*`` pattern.

    .. _HTML 4.01 spec: https://www.w3.org/TR/html401
    .. _CSS1 spec: https://www.w3.org/TR/REC-CSS1
    """
    id = string.lower()
    id = id.translate(_non_id_translate_digraphs)
    id = id.translate(_non_id_translate)
    # get rid of non-ascii characters.
    # 'ascii' lowercase to prevent problems with turkish locale.
    id = unicodedata.normalize(
            'NFKD', id).encode('ascii', 'ignore').decode('ascii')
    # shrink runs of whitespace and replace by hyphen
    id = _non_id_chars.sub('-', ' '.join(id.split()))
    id = _non_id_at_ends.sub('', id)
    return str(id)


_non_id_chars: re.Pattern[str] = re.compile('[^a-z0-9]+')
_non_id_at_ends: re.Pattern[str] = re.compile('^[-0-9]+|-+$')
_non_id_translate: dict[int, str] = {
    0x00f8: 'o',       # o with stroke
    0x0111: 'd',       # d with stroke
    0x0127: 'h',       # h with stroke
    0x0131: 'i',       # dotless i
    0x0142: 'l',       # l with stroke
    0x0167: 't',       # t with stroke
    0x0180: 'b',       # b with stroke
    0x0183: 'b',       # b with topbar
    0x0188: 'c',       # c with hook
    0x018c: 'd',       # d with topbar
    0x0192: 'f',       # f with hook
    0x0199: 'k',       # k with hook
    0x019a: 'l',       # l with bar
    0x019e: 'n',       # n with long right leg
    0x01a5: 'p',       # p with hook
    0x01ab: 't',       # t with palatal hook
    0x01ad: 't',       # t with hook
    0x01b4: 'y',       # y with hook
    0x01b6: 'z',       # z with stroke
    0x01e5: 'g',       # g with stroke
    0x0225: 'z',       # z with hook
    0x0234: 'l',       # l with curl
    0x0235: 'n',       # n with curl
    0x0236: 't',       # t with curl
    0x0237: 'j',       # dotless j
    0x023c: 'c',       # c with stroke
    0x023f: 's',       # s with swash tail
    0x0240: 'z',       # z with swash tail
    0x0247: 'e',       # e with stroke
    0x0249: 'j',       # j with stroke
    0x024b: 'q',       # q with hook tail
    0x024d: 'r',       # r with stroke
    0x024f: 'y',       # y with stroke
}
_non_id_translate_digraphs: dict[int, str] = {
    0x00df: 'sz',      # ligature sz
    0x00e6: 'ae',      # ae
    0x0153: 'oe',      # ligature oe
    0x0238: 'db',      # db digraph
    0x0239: 'qp',      # qp digraph
}


def dupname(node: Element, name: str) -> None:
    node['dupnames'].append(name)
    node['names'].remove(name)
    # Assume that `node` is referenced, even though it isn't;
    # we don't want to throw unnecessary system_messages.
    node.referenced = True


def fully_normalize_name(name: str) -> str:
    """Return a case- and whitespace-normalized name."""
    return ' '.join(name.lower().split())


def whitespace_normalize_name(name: str) -> str:
    """Return a whitespace-normalized name."""
    return ' '.join(name.split())


def serial_escape(value: str) -> str:
    """Escape string values that are elements of a list, for serialization."""
    return value.replace('\\', r'\\').replace(' ', r'\ ')


def split_name_list(s: str) -> list[str]:
    r"""Split a string at non-escaped whitespace.

    Backslashes escape internal whitespace (cf. `serial_escape()`).
    Return list of "names" (after removing escaping backslashes).

    >>> split_name_list(r'a\ n\ame two\\ n\\ames'),
    ['a name', 'two\\', r'n\ames']

    Provisional.
    """
    s = s.replace('\\', '\x00')         # escape with NULL char
    s = s.replace('\x00\x00', '\\')     # unescape backslashes
    s = s.replace('\x00 ', '\x00\x00')  # escaped spaces -> NULL NULL
    names = s.split(' ')
    # restore internal spaces, drop other escaping characters
    return [name.replace('\x00\x00', ' ').replace('\x00', '')
            for name in names]


def pseudo_quoteattr(value: str) -> str:
    """Quote attributes for pseudo-xml"""
    return '"%s"' % value


def parse_measure(measure: str, unit_pattern: str = '[a-zA-Zµ]*|%?'
                  ) -> tuple[int|float, str]:
    """Parse a measure__, return value + unit.

    `unit_pattern` is a regular expression describing recognized units.
    The default is suited for (but not limited to) CSS3 units and SI units.
    It matches runs of ASCII letters or Greek mu, a single percent sign,
    or no unit.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#measure

    Provisional.
    """
    match = re.fullmatch(f'(-?[0-9.]+) *({unit_pattern})', measure)
    try:
        try:
            value = int(match.group(1))
        except ValueError:
            value = float(match.group(1))
        unit = match.group(2)
    except (AttributeError, ValueError):
        raise ValueError(f'"{measure}" is no valid measure.')
    return value, unit


# Methods to validate `Element attribute`__ values.

# Ensure the expected Python `data type`__, normalize, and check for
# restrictions.
#
# The methods can be used to convert `str` values (eg. from an XML
# representation) or to validate an existing document tree or node.
#
# Cf. `Element.validate_attributes()`, `docutils.parsers.docutils_xml`,
# and the `attribute_validating_functions` mapping below.
#
# __ https://docutils.sourceforge.io/docs/ref/doctree.html#attribute-reference
# __ https://docutils.sourceforge.io/docs/ref/doctree.html#attribute-types

def create_keyword_validator(*keywords: str) -> Callable[[str], str]:
    """
    Return a function that validates a `str` against given `keywords`.

    Provisional.
    """
    def validate_keywords(value: str) -> str:
        if value not in keywords:
            allowed = '", \"'.join(keywords)
            raise ValueError(f'"{value}" is not one of "{allowed}".')
        return value
    return validate_keywords


def validate_identifier(value: str) -> str:
    """
    Validate identifier key or class name.

    Used in `idref.type`__ and for the tokens in `validate_identifier_list()`.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#idref-type

    Provisional.
    """
    if value != make_id(value):
        raise ValueError(f'"{value}" is no valid id or class name.')
    return value


def validate_identifier_list(value: str | list[str]) -> list[str]:
    """
    A (space-separated) list of ids or class names.

    `value` may be a `list` or a `str` with space separated
    ids or class names (cf. `validate_identifier()`).

    Used in `classnames.type`__, `ids.type`__, and `idrefs.type`__.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#classnames-type
    __ https://docutils.sourceforge.io/docs/ref/doctree.html#ids-type
    __ https://docutils.sourceforge.io/docs/ref/doctree.html#idrefs-type

    Provisional.
    """
    if isinstance(value, str):
        value = value.split()
    for token in value:
        validate_identifier(token)
    return value


def validate_measure(measure: str) -> str:
    """
    Validate a measure__ (number + optional unit).  Return normalized `str`.

    See `parse_measure()` for a function returning a "number + unit" tuple.

    The unit may be a run of ASCII letters or Greek mu, a single percent sign,
    or the empty string. Case is preserved.

    Provisional.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#measure
    """
    value, unit = parse_measure(measure)
    return f'{value}{unit}'


def validate_colwidth(measure: str|int|float) -> int|float:
    """Validate the "colwidth__" attribute.

    Provisional:
        `measure` must be a `str` and will be returned as normalized `str`
        (with unit "*" for proportional values) in Docutils 1.0.

        The default unit will change to "pt" in Docutils 2.0.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#colwidth
    """
    if isinstance(measure, (int, float)):
        value = measure
    elif measure in ('*', ''):  # short for '1*'
        value = 1
    else:
        try:
            value, _unit = parse_measure(measure, unit_pattern='[*]?')
        except ValueError:
            value = -1
    if value <= 0:
        raise ValueError(f'"{measure}" is no proportional measure.')
    return value


def validate_NMTOKEN(value: str) -> str:
    """
    Validate a "name token": a `str` of ASCII letters, digits, and [-._].

    Provisional.
    """
    if not re.fullmatch('[-._A-Za-z0-9]+', value):
        raise ValueError(f'"{value}" is no NMTOKEN.')
    return value


def validate_NMTOKENS(value: str | list[str]) -> list[str]:
    """
    Validate a list of "name tokens".

    Provisional.
    """
    if isinstance(value, str):
        value = value.split()
    for token in value:
        validate_NMTOKEN(token)
    return value


def validate_refname_list(value: str | list[str]) -> list[str]:
    """
    Validate a list of `reference names`__.

    Reference names may contain all characters;
    whitespace is normalized (cf, `whitespace_normalize_name()`).

    `value` may be either a `list` of names or a `str` with
    space separated names (with internal spaces backslash escaped
    and literal backslashes doubled cf. `serial_escape()`).

    Return a list of whitespace-normalized, unescaped reference names.

    Provisional.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#reference-name
    """
    if isinstance(value, str):
        value = split_name_list(value)
    return [whitespace_normalize_name(name) for name in value]


def validate_yesorno(value: str | int | bool) -> bool:
    """Validate a `%yesorno`__ (flag) value.

    The string literal "0" evaluates to ``False``, all other
    values are converterd with `bool()`.

    __ https://docutils.sourceforge.io/docs/ref/doctree.html#yesorno
    """
    if value == "0":
        return False
    return bool(value)


ATTRIBUTE_VALIDATORS: dict[str, Callable[[str], Any]] = {
    'alt': str,  # CDATA
    'align': str,
    'anonymous': validate_yesorno,
    'auto': str,  # CDATA (only '1' or '*' are used in rST)
    'backrefs': validate_identifier_list,
    'bullet': str,  # CDATA (only '-', '+', or '*' are used in rST)
    'classes': validate_identifier_list,
    'char': str,  # from Exchange Table Model (CALS), currently ignored
    'charoff': validate_NMTOKEN,  # from CALS, currently ignored
    'colname': validate_NMTOKEN,  # from CALS, currently ignored
    'colnum': int,  # from CALS, currently ignored
    'cols': int,  # from CALS: "NMTOKEN, […] must be an integer > 0".
    'colsep': validate_yesorno,
    'colwidth': validate_colwidth,  # see docstring for pending changes
    'content': str,  # <meta>
    'delimiter': str,
    'dir': create_keyword_validator('ltr', 'rtl', 'auto'),  # <meta>
    'dupnames': validate_refname_list,
    'enumtype': create_keyword_validator('arabic', 'loweralpha', 'lowerroman',
                                         'upperalpha', 'upperroman'),
    'format': str,  # CDATA (space separated format names)
    'frame': create_keyword_validator('top', 'bottom', 'topbot', 'all',
                                      'sides', 'none'),  # from CALS, ignored
    'height': validate_measure,
    'http-equiv': str,  # <meta>
    'ids': validate_identifier_list,
    'lang': str,  # <meta>
    'level': int,
    'line': int,
    'ltrim': validate_yesorno,
    'loading': create_keyword_validator('embed', 'link', 'lazy'),
    'media': str,  # <meta>
    'morecols': int,
    'morerows': int,
    'name': whitespace_normalize_name,  # in <reference> (deprecated)
    # 'name': node_attributes.validate_NMTOKEN,  # in <meta>
    'names': validate_refname_list,
    'namest': validate_NMTOKEN,  # start of span, from CALS, currently ignored
    'nameend': validate_NMTOKEN,  # end of span, from CALS, currently ignored
    'pgwide': validate_yesorno,  # from CALS, currently ignored
    'prefix': str,
    'refid': validate_identifier,
    'refname': whitespace_normalize_name,
    'refuri': str,
    'rowsep': validate_yesorno,
    'rtrim': validate_yesorno,
    'scale': int,
    'scheme': str,
    'source': str,
    'start': int,
    'stub': validate_yesorno,
    'suffix': str,
    'title': str,
    'type': validate_NMTOKEN,
    'uri': str,
    'valign': create_keyword_validator('top', 'middle', 'bottom'),  # from CALS
    'width': validate_measure,
    'xml:space': create_keyword_validator('default', 'preserve'),
    }
"""
Mapping of `attribute names`__ to validating functions.

Provisional.

__ https://docutils.sourceforge.io/docs/ref/doctree.html#attribute-reference
"""
