3

T'íc@
ã"@sldZd
dl
mZ
d
dlmZ
dZd
dlZd
dlZd
dlZd
dl	Z	d
dl
Z
ej
dJkr\eZ
eZGdd„deƒZGd	d
„d
eƒZej
dKkršGdd„de
ƒZne
Zd
d„Z
dLdd„
ZGdd„deeƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGd d!„d!eƒZGd"d#„d#eƒZGd$d%„d%eƒZGd&d'„d'eƒZ Gd(d)„d)eƒZ!Gd*d+„d+eƒZ"Gd,d-„d-e"ƒZ#Gd.d/„d/e"ƒZ$Gd0d1„d1e"ƒZ%Gd2d3„d3e"ƒZ&Gd4d5„d5eƒZ'Gd6d7„d7eƒZ(Gd8d9„d9eƒZ)Gd:d;„d;eƒZ*Gd<d=„d=eƒZ+Gd>d?„d?eƒZ,Gd@dA„dAee!eƒZ-GdBdC„dCeeeƒZ.GdDdE„dEeeeƒZ/GdFdG„dGeeƒZ0GdHdI„dIeeƒZ1GdJdK„dKeeƒZ2GdLdM„dMeeƒZ3GdNdO„dOeeƒZ4GdPdQ„dQeeƒZ5GdRdS„dSeeƒZ6GdTdU„dUeeƒZ7GdVdW„dWeeƒZ8GdXdY„dYeeƒZ9GdZd[„d[eeƒZ:Gd\d]„d]eeƒZ;Gd^d_„d_e eƒZ<Gd`da„dae eƒZ=Gdbdc„dce eƒZ>Gddde„dee!eƒZ?Gdfdg„dge!eƒZ@Gdhdi„die!eƒZAGdjdk„dke!eƒZBGdldm„dme#eƒZCGdndo„doe#eƒZDGdpdq„dqe#eƒZEGdrds„dse$eƒZFGdtdu„due$eƒZGGdvdw„dwe(eƒZHGdxdy„dye$eƒZIGdzd{„d{e(eƒZJGd|d}„d}e(eƒZKGd~d„de(eƒZLGd€d„de(eƒZMGd‚dƒ„dƒe$eƒZNGd„d…„d…e(eƒZOGd†d‡„d‡e(eƒZPGdˆd‰„d‰e(eƒZQGdŠd‹„d‹e(eƒZRGdŒd„de(eƒZSGdŽd„de(eƒZTGdd‘„d‘e$eƒZUGd’d“„d“e(eƒZVGd”d•„d•e(eƒZWGd–d—„d—e(eƒZXGd˜d™„d™e#eƒZYGdšd›„d›e#eƒZZGdœd„de#eƒZ[GdždŸ„dŸe#eƒZ\Gd d¡„d¡e(eƒZ]Gd¢d£„d£e#eƒZ^Gd¤d¥„d¥e(eƒZ_Gd¦d§„d§e%eƒZ`Gd¨d©„d©e%eƒZaGdªd«„d«e%eƒZbGd¬d­„d­e%eƒZcGd®d¯„d¯e%eƒZdGd°d±„d±e%eƒZeGd²d³„d³e%eƒZfGd´dµ„dµe%eƒZgGd¶d·„d·e%eƒZhGd¸d¹„d¹e%eƒZiGdºd»„d»e&e'eƒZjGd¼d½„d½e&e'eƒZkGd¾d¿„d¿e&e'e)ee+ƒZlGdÀdÁ„dÁe#eee,e+ƒZmGdÂdÄdÃe#eee,e+ƒZnGdÄdńdÅe(eƒZoGdÆdDŽdÇe#eƒZpGdÈdɄdÉe(eƒZqGdÊd˄dËe(eƒZrGdÌd̈́dÍe#eƒZsGdÎdτdÏe(eƒZtGdÐdфdÑe(eƒZuGdÒdӄdÓe(eƒZvGdÔdՄdÕe(eƒZwGdÖdׄd×e(eƒZxGdØdلdÙe(eƒZyGdÚdۄdÛe&eeeƒZzGdÜd݄dÝe&e'eƒZ{GdÞd߄dße&e)eeƒZ|Gdàdá„dáe)eƒZ}Gdâdã„dãe)eƒZ~Gdädå„dåe)eƒZGdædç„dçe#e)e*eƒZ€Gdèdé„dée)e*eƒZGdêdë„dëe)e*eƒZ‚Gdìdí„díe)eƒZƒGdîdï„dïe)eƒZ„Gdðdñ„dñe)eƒZ…Gdòdó„dóe)eƒZ†Gdôdõ„dõe)eƒZ‡Gdöd÷„d÷e)eƒZˆGdødù„dùe)eƒZ‰Gdúdû„dûe#e)eƒZŠGdüdý„dýe)eƒZ‹Gdþdÿ„dÿe)eƒZŒG
d
d
„
d
e)eƒZ
djŽƒZG
d
d„
deƒZG
d
d„
deƒZ‘G
d
d„
deƒZ’
d	
d
„Z“
d
d„Z”
d

d„Z•
d
d„Z–e–eƒ

G
d
d„
de’ƒZ—G
d
d„
de˜ƒZ™G
d
d„
de™ƒZšG
d
d„
de™ƒZ›G
d
d„
de™ƒZœG
d
d„
de™ƒZG
d
d„
de™ƒZžG
d
d „
d e™ƒZŸ
d!
d"„Z ej¡
d#ƒ
Z¢ej¡
d$ƒ
Z£
d%
d&
d'
d(
d)
d*
d+
d+
d,
d&
d-
d.
d)
d/
d0
d*
d*
d1
d2
d3
d2
d)
d/
d*
d4
d,
d5
d2
d6
d4
d7
d8
d1
d9œ!Z¤
d:
d;
d<
d=
d>
d?œZ¥
d@
dA„Z¦
dB
dC„Z§
dD
dE„Z¨
dF
dG„Z©
dH
dI„ZªdS(M
aØ
Docutils document tree element class library.

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.

.. _DTD: http://docutils.sourceforge.net/docs/ref/docutils.dtd
é)
Úprint_function)
ÚCounterZreStructuredTextNéc@seZ
dZd
Zdd„Zeejƒ
Zeejƒ
Zeejƒ
Zeej	ƒ
Z	eej
ƒ
Z
eejƒ
Zeejƒ
Zeej
ƒ
Z
eejƒ
Zeejƒ
Zeejƒ
Zeejƒ
ZdS)Ú_traversal_listFc
sd
‰
‡‡
fdd„}
|
S)Nzm
   The iterable returned by Node.traverse()
   will become an iterator instead of a list in Docutils > 0.16.c
s,|jst
jˆ
td
d
d|_ˆ|f
|
ž|Ž
S)Né)
Ú
stacklevelT)ÚdoneÚwarningsÚwarnÚ
FutureWarning)ÚselfÚargsÚkwargs)ÚfunÚmsg©ú2/tmp/pip-build-gk9425m9/docutils/docutils/nodes.pyÚwrapper,s



z3_traversal_list._warning_decorator.<locals>.wrapperr)rrr)rrrÚ_warning_decorator(s
z"_traversal_list._warning_decoratorN)Ú__name__Ú
__module__Ú__qualname__rrÚlistÚ__add__Ú__contains__Ú__getitem__Ú__reversed__Ú__setitem__ÚappendÚcountÚextendÚindexÚinsertÚpopÚreverserrrrr%s






















rc@sÔeZ
dZd
ZdZdZdZdZedd„ƒ
Z	e	j
dd„ƒ
Z	dd„Zej
d)krLeZej
d*kr^d
d„Zd+dd
„
Zd,dd„
Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd„Zdd „Zd-d#d$„
Zd.d%d&„
Zd/d'd(„
ZdS)0ÚNodez0Abstract base class of nodes in a document tree.Nc

Cs(y|jp|j
jStk
r"


d
SXd
S)zZ
        Return the `document` node at the root of the tree containing this Node.
        N)Ú	_documentÚparentÚdocumentÚAttributeError)
rrrrr(Ts


z
Node.documentcCs
|
|_dS)
N)
r&)rÚvaluerrrr(^sc


Csd
S)a8

        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.  Use `None` to represent a boolean
        false value.
        Tr)
rrrrÚ__bool__bs	z
Node.__bool__rr
c

Cst|ƒ
j
d
ƒ
S)NZraw_unicode_escape)ÚunicodeÚencode)
rrrrÚ__str__ss
zNode.__str__cCs&|
d
krdd
lj
j}
|
jƒ}|j|ƒ
S)z6Return a DOM **fragment** representation of this Node.Nr
)Úxml.dom.minidomÚdomÚminidomÚDocumentÚ	_dom_node)rr0ÚdomrootrrrÚasdomvs


z
Node.asdomú    c
Cst‚
d
S)zs
        Return an indented pseudo-XML representation, for test purposes.

        Override in subclasses.
        N)
ÚNotImplementedError)rÚindentÚlevelrrrÚpformat}szNode.pformatc


Cst‚
d
S)zReturn a copy of self.N)
r7)
rrrrÚcopy…sz	Node.copyc


Cst‚
d
S)z3Return a deep copy of self (also copying children).N)
r7)
rrrrÚdeepcopy‰sz
Node.deepcopyc


Cst‚
d
S)z,Return a string representation of this Node.N)
r7)
rrrrÚastextszNode.astextcCs@||
_|j
r<|j
|
_
|
jdkr(|j
j|
_|
jdkr<|j
j|
_dS)
N)r'r(ÚsourceÚcurrent_sourceÚlineÚcurrent_line)rÚchildrrrÚsetup_child‘s









zNode.setup_childcCs¼d
}|
jj
jd|jjƒ

y„y|
j|ƒ

Wn*ttfk
rB


|Stk
rT


YnX|j	}y*x$|dd…D]}|j
|
ƒ
rld}PqlWWntk
rš


YnXWntk
r¶


d}YnX|S)aé
        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.
        Fz6docutils.nodes.Node.walk calling dispatch_visit for %sNT)
r(ÚreporterÚdebugÚ	__class__rÚdispatch_visitÚSkipChildrenÚSkipNodeÚ
SkipDepartureÚchildrenÚwalkÚSkipSiblingsÚ
StopTraversal)rÚvisitorÚstoprKrBrrrrLšs,
























z	Node.walkcCsöd
}d}|
jj
jd|jjƒ

y„y|
j|ƒ

Wn*tk
rB


|Stk
rX


d}YnX|j}y*x$|dd…D]}|j	|
ƒ
rpd
}PqpWWnt
k
rž


YnXWn*tk
r¶


Yntk
rÌ


d
}YnX|rò|
jj
jd|jjƒ

|
j
|ƒ

|S)a†

        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.
        TFz;docutils.nodes.Node.walkabout calling dispatch_visit for %sNz?docutils.nodes.Node.walkabout calling dispatch_departure for %s)r(rDrErFrrGrIrJrKÚ	walkaboutrMrHrNÚdispatch_departure)rrOZcall_departrPrKrBrrrrQÈs<


































zNode.walkaboutccs>t||
ƒr|V
x(|j
D]}x|j|
ƒ
D]
}|V
q(WqWd
S)z3Return iterator that only supports instance checks.N)Ú
isinstancerKÚ_fast_traverse)rÚclsrBÚsubnoderrrrTós





zNode._fast_traversec
cs2|V
x&|jD]}
x|
j
ƒD]
}|V
qWqWd
S)z3Return iterator that doesn't check for a condition.N)rKÚ
_all_traverse)rrBrVrrrrWûs


zNode._all_traverseTFcCst|j
|
||||ƒƒ
S)
a
        Return an iterable containing

        * self (if include_self is true)
        * all descendants in tree traversal order (if descend is true)
        * all siblings (if siblings is true) and their descendants (if
          also descend is true)
        * the 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 iterable contains only nodes
        for which ``condition(node)`` is true.  If `condition` is a
        node class ``cls``, it is equivalent to a function consisting
        of ``return isinstance(node, cls)``.

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

        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 list(emphasis.traverse()) equals ::

            [<emphasis>, <strong>, <#text: Foo>, <#text: Bar>]

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

            [<strong>, <#text: Foo>, <#text: Bar>, <reference>, <#text: Baz>]
        )rÚ	_traverse)rÚ	conditionÚinclude_selfÚdescendÚsiblingsÚascendrrrÚtraverse
s)

z
Node.traverseccsV
|rd
}|rb|rb|rb|
dkr:x|jƒD]
}|V
q(WdSt
|
tƒrbx|j|
ƒ
D]
}|V
qPWdSt
|
tƒr||
}|f
dd„
}
|r–|
dks|
|ƒ
r–|V
|rÖt|jƒ
rÖx0|D](}x"|j|
d
d
dddD]
}|V
qÄWqªW|sà|
rR|}	xl|	j
rP|	jj|	ƒ
}
xB|	j|
dd…D],}x$|j|
d
|dddD]}|V

q(W
qW|
sHPqæ|	j}	qæWdS)z>Return iterator over nodes following `self`. See `traverse()`.TNcSs
t||
ƒS)
N)
rS)ÚnodeÚ
node_classrrrrYB
s
z!Node._traverse.<locals>.conditionF)rYrZr[r\r]é
)	rWrSÚtyperTÚlenrKrXr'r!)rrYrZr[r\r]rVr`rBr_r!ZsiblingrrrrX.
sD



































zNode._traversecCs4|j|
||||ƒ}yt
|ƒ
Stk
r.


d
SXd
S)zè
        Return the first node in the iterable returned by traverse(),
        or None if the iterable is empty.

        Parameter list is the same as of traverse.  Note that
        include_self defaults to False, though.
        N)rXÚnextÚ
StopIteration)rrYrZr[r\r]Z
node_iteratorrrrÚ	next_node\
s	





zNode.next_node)rr
)rr
)
N)r6r
)NTTFF)NTTFF)NFTFF)rrrÚ__doc__r'r>r@r&Úpropertyr(Úsetterr+ÚsysÚversion_infoÚ__nonzero__r.r5r:r;r<r=rCrLrQrTrWr^rXrfrrrrr%Es8





	.+

+

-
r%c@seZ
dZd
Zdd„ZdS)ÚreprunicodezU
        A unicode sub-class that removes the initial u from unicode's repr.
        c

Cstj
|ƒ
d
d…S)Nra)r,Ú__repr__)
rrrrrnr
s
zreprunicode.__repr__N)rrrrgrnrrrrrmm
srmc

Cs$tj
dkr t|tƒr |jddƒS|S)z4
    Failsave conversion of `unicode` to `str`.
    rr
ÚasciiÚbackslashreplace)rr
)rjrkrSr,r-)
Ú
srrrÚ
ensure_strx
s

rrFcCs6|
r|jd
dƒSxdD]}dj
|j|ƒ
ƒ
}qW|SdS)zw
    Return a string with nulls removed or restored to backslashes.
    Backslash-escaped spaces are also removed.
    ú
ú
\ú ú
ÚN)rurvrs)ÚreplaceÚjoinÚsplit)ÚtextZrestore_backslashesZrespect_whitespaceÚseprrrÚunescape
s




r}c@s’eZ
dZd
ZdZfZejd kr*d!dd„
Zn
d"dd„
Zd#d
d„
Z	d$d
d„
Z
dd„Zdd„Zdd„Z
dd„Zdd„Zd%dd„
Zd&dd„
Zd'dd„
ZdS)(ÚTextzÐ
    Instances are terminal nodes (leaves) containing text only; no child
    nodes or attributes.  Initialize by passing a string to the constructor.
    Access the text itself with the `astext` method.
    z#textrr
NcCst|
t
ƒrtd
ƒ
‚
tj||
ƒS)z7Prevent the rawsource argument from propagating to str.zexpecting str data, not bytes)rSÚbytesÚ	TypeErrorrmÚ__new__)rUÚdataÚ	rawsourcerrrr
s


zText.__new__cCstj
||
ƒS)
z7Prevent the rawsource argument from propagating to str.)rmr)rUr‚rƒrrrr£
srwcCs
||_dS)
N)
rƒ)rr‚rƒrrrÚ__init__§
s

z
Text.__init__écCs6|}t|ƒ
|
kr$|d|
d
…d}d|j
t|ƒ
fS)Néz ...z<%s: %r>)rcÚtagnamerm)rÚmaxlenr‚rrrÚ	shortrepr«
s



zText.shortreprc

Cs|jd
d
S)NéD)
rˆ)
r‰)
rrrrrn±
s
z
Text.__repr__cCs|
jt
|ƒ
ƒ
S)
N)ZcreateTextNoder,)rr4rrrr3´
s
zText._dom_nodec

Cstt
|ƒ
ƒ
S)
N)rmr})
rrrrr=·
s
zText.astextc

Cs|jt
|ƒ
|jd
S)N)
rƒ)rFrmrƒ)
rrrrr;Ã
s
z	Text.copyc


Cs|jƒS)
N)
r;)
rrrrr<Æ
s
z
Text.deepcopyú    cs˜yJ|jj
jrHd
ˆˆ
dfg
‡‡
fdd„|jdd
Dƒ
}dj|ƒ
dSWntk
r^


YnXˆˆ
‰‡f
dd„|jƒjƒDƒ
}|sŠd	Sdj|ƒ
dS)
Nz%s%sz<#text>c
s g|]}
ˆˆ
dt|
ƒ
‘qS)
ra)
Úrepr)Ú.0r@)r8r9rrú
<listcomp>Í
s
z Text.pformat.<locals>.<listcomp>T)
ÚkeependsÚ

c
sg|]}
ˆ|
‘qSrr)rr@)
r8rrrŽÓ
srw)r(ÚsettingsZ	detailledÚ
splitlinesryr)r=)rr8r9Úlinesr)r8r9rr:É
s













zText.pformatcCs|jt
j||
ƒ|jƒS)
N)rFrmÚrstriprƒ)rÚcharsrrrr”Ü
s
zText.rstripcCs|jt
j||
ƒ|jƒS)
N)rFrmÚlstriprƒ)rr•rrrr–ß
s
zText.lstrip)rr
)
N)
N)
rw)
r…)r‹r
)
N)
N)rrrrgr‡rKrjrkrr„r‰rnr3r=r;r<r:r”r–rrrrr~
s 






r~c@s>eZ
dZd
Zd‚ZdƒZeeZed„Zd	Zd
Z	d…dd
„
Z
dd„Zdd„Zdd„Z
dd„Zejd†krdeZd‡dd„
Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zdˆd4d5„
Z d6d7„Z!d8d9„Z"d‰d:d;„
Z#e!Z$dŠd<d=„
Z%d>d?„Z&d@dA„Z'dBdC„Z(dŒdEdF„
Z)dGdH„Z*dIdJ„Z+dKdL„Z,dMdN„Z-dOdP„Z.dQdR„Z/ddTdU„
Z0dŽdVdW„
Z1dXdY„Z2dZd[„Z3d\d]„Z4e4dSd^fd_d`„
Z5ddadb„
Z6ddcdd„
Z7d‘dedf„
Z8d’dgdh„
Z9didj„Z:dkdl„Z;dmdn„Z<dej=fdodp„
Z>dej=fdqdr„
Z?d“dtdu„
Z@dvdw„ZAdxdy„ZBdzd{„ZCd”d|d}„
ZDeEd~d„ƒ
ZFeEd€d„ƒ
ZGd	S)•ÚElementa‰
    `Element` is the superclass to all specific elements.

    Elements contain attributes and child nodes.  Elements emulate
    dictionaries for attributes, indexing by attribute name (a string).  To
    set the attribute 'att' to 'value', do::

        element['att'] = 'value'

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

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

        element[0]

    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])``.
    ÚidsÚclassesÚnamesÚdupnamesÚbackrefsr>rƒNz

rwcOs”|
|_g|_
|j|ƒ

i|_x|jD]}g|j|<q$WxD|jƒD]8\}}|jƒ}||jkrn|dd…|j|<q@||j|<q@W|jdkr|jj	|_dS)
N)
rƒrKr Ú
attributesÚlist_attributesÚitemsÚlowerr‡rFr)rrƒrKrÚattr*rrrr„ s







zElement.__init__cCst|
j|j
ƒ
}xB|jƒD]6\}}t|tƒr<d
jdd„|Dƒ
ƒ
}|j|d|ƒ
qWx|jD]}|j|j	|
ƒ
ƒ

qXW|S)Nú
 c
Ssg|]}
td|
f
ƒ
‘qS)
z%s)
Ú
serial_escape)rÚ
vrrrrŽBsz%Element._dom_node.<locals>.<listcomp>z%s)
Ú
createElementr‡ÚattlistrSrryZsetAttributerKÚappendChildr3)rr4ÚelementÚ	attributer*rBrrrr3>s








zElement._dom_nodec
Cs€d
}
x8|jD].}|
|j
ƒ7}
t|
ƒ
dkr|
dd…d}
PqW|drld|jjdjdd	„|dDƒ
ƒ
|
fSd
|jj|
fSdS)Nrwé<é8z ...ršz
<%s "%s": %s>z; c
Ssg|]}
t|
ƒ
‘qSr)
rr)rÚ
nrrrrŽQsz$Element.__repr__.<locals>.<listcomp>z<%s: %s>)rKr‰rcrFrry)rr‚Ú
crrrrnHs








zElement.__repr__c

Cs:|d
r,d|jj
djdd„|d
Dƒ
ƒ
fSd|jSdS)Nršz<%s "%s"...>z; c
Ssg|]}
t|
ƒ
‘qSr)
rr)rr¬rrrrŽXsz%Element.shortrepr.<locals>.<listcomp>z<%s...>)rFrryr‡)
rrrrr‰Us


zElement.shortreprc

Cs:|jr.d
|j
ƒdjdd„|jDƒ
ƒ
|jƒfS|jƒSdS)Nz%s%s%srwc
Ssg|]}
t|
ƒ
‘qSr)
r,)rr­rrrrŽ_sz'Element.__unicode__.<locals>.<listcomp>)rKÚstarttagryÚendtagÚemptytag)
rrrrÚ__unicode__\s




zElement.__unicode__rr
cCs–|
dkrt}
|j
g
}xr|jƒD]f\}}|dkr>|jd
|ƒ

qt|tƒrbdd„|Dƒ
}dj|ƒ
}nt|ƒ
}|
|ƒ
}|jd||fƒ

qWddj|ƒ
S)Nz	%s="True"c
Ssg|]}
td|
f
ƒ
‘qS)
z%s)
r£)rr¤rrrrŽqsz$Element.starttag.<locals>.<listcomp>r¢z%s=%sz<%s>)Úpseudo_quoteattrr‡r¦rrSrryr,)rÚ	quoteattrÚpartsÚnamer*Úvaluesrrrr®gs












zElement.starttagc

Cs
d
|jS)Nz</%s>)
r‡)
rrrrr¯ys
zElement.endtagc

Cs$d
dj|j
g
dd„|jƒDƒ
ƒ
S)Nz<%s/>r¢c
Ssg|]\}
}d|
|f‘qS)
z%s="%s"r)rr¬r¤rrrrŽ~s
z$Element.emptytag.<locals>.<listcomp>)ryr‡r¦)
rrrrr°|s


zElement.emptytagc

Cs
t|j
ƒ
S)
N)rcrK)
rrrrÚ__len__s
zElement.__len__cCst|
t
ƒr|
|jkS|
|jkS)
N)rSÚ
basestringrrK)rÚkeyrrrr„s



zElement.__contains__cCsbt|
t
ƒr|j|
St|
tƒr(|j|
St|
tƒrV|
jdksDtdƒ
‚
|j|
j|
j	…St
dƒ
‚
dS)Nrazcannot handle slice with stridezFelement index must be an integer, a slice, or an attribute name string)Nra)rSr¸rÚintrKÚsliceÚstepÚAssertionErrorÚstartrPr€)rr¹rrrrŠs











zElement.__getitem__cCsŽt|
t
ƒr||jt|
ƒ
<npt|
tƒr:|j|ƒ

||j|
<nPt|
tƒr‚|
jdksVt	dƒ
‚
x|D]}|j|ƒ

q\W||j|
j
|
j…<ntdƒ
‚
dS)Nrazcannot handle slice with stridezFelement index must be an integer, a slice, or an attribute name string)Nra)
rSr¸rÚstrrºrCrKr»r¼r½r¾rPr€)rr¹Úitemr_rrrr–s














zElement.__setitem__cCsbt|
t
ƒr|j|
=nJt|
tƒr(|j|
=n6t|
tƒrV|
jdksDtdƒ
‚
|j|
j|
j	…=nt
dƒ
‚
dS)Nrazcannot handle slice with stridezMelement index must be an integer, a simple slice, or an attribute name string)Nra)rSr¸rrºrKr»r¼r½r¾rPr€)rr¹rrrÚ__delitem__¥s











zElement.__delitem__cCs
|j|
S)
N)
rK)rÚotherrrrr±s
zElement.__add__cCs
|
|jS)
N)
rK)rrÂrrrÚ__radd__´s
zElement.__radd__cCs,t|
t
ƒr|j|
ƒ

n|
d
k	r(|j|
ƒ

|S)z4Append a node or a list of nodes to `self.children`.N)rSr%rr )rrÂrrrÚ__iadd__·s






zElement.__iadd__c

Cs|jj
d
d„|jDƒ
ƒ
S)Nc
Ssg|]}
|
jƒ‘qSr)
r=)rrBrrrrŽÁsz"Element.astext.<locals>.<listcomp>)Úchild_text_separatorryrK)
rrrrr=¿s

zElement.astextc
Cs2i}
x(|jj
ƒD]\}}|j|ƒ
r||
|<qW|
S)
N)rrŸÚis_not_default)rZattsr¹r*rrrÚnon_default_attributesÃs






zElement.non_default_attributesc
Cst|j
ƒjƒƒ
}
|
S)
N)ÚsortedrÇrŸ)rr¦rrrr¦Ês

zElement.attlistcCs|jj
|
|ƒS)
N)rÚget)rr¹ÚfailobjrrrrÉÎs
zElement.getcCs
|
|jkS)
N)
r)rÚattrrrrÚhasattrÑs
zElement.hasattrcCs|
|jkr|j|
=dS)
N)
r)rrËrrrÚdelattrÔs


zElement.delattrcCs|jj
|
|ƒS)
N)rÚ
setdefault)rr¹rÊrrrrÎØs
zElement.setdefaultcCsRx*|jd
gƒD]}|j
dƒ
r|dd…SqWy|jj|
ƒ
Stk
rL


|
SXdS)zî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`.
        r™z	language-é	N)rÉÚ
startswithr'Zget_languager))rÚfallbackrUrrrÚget_language_codeÝs






zElement.get_language_codecCs|j|
ƒ

|j
j|
ƒ

dS)
N)rCrKr)rrÀrrrrìs


zElement.appendcCsx|
D]}|j|ƒ

qWdS)
N)
r)rrÀr_rrrr ðs


zElement.extendcCs<t|t
ƒr$|j|ƒ

|jj|
|ƒ
n|dk	r8|||
|
…<dS)
N)rSr%rCrKr")rr!rÀrrrr"ôs







zElement.insertracCs|jj
|
ƒ
S)
N)rKr#)rÚ
irrrr#ûs
zElement.popcCs|jj
|
ƒ

dS)
N)rKÚremove)rrÀrrrrÔþs
zElement.removecCs|jj
|
ƒ
S)
N)rKr!)rrÀrrrr!
s
z
Element.indexcCs"||
gkr|
|jkrd
SdSdS)Nr
ra)
rž)rr¹rrrrÆs

zElement.is_not_defaultcCs8t|
t
ƒr|
j}
x"|jD]}|j||
j|gƒƒ
qWd
S)zŒ
        Update basic attributes ('ids', 'names', 'classes',
        'dupnames', but not 'source') from node or dictionary `dict_`.
        N)rSr%rÚbasic_attributesÚappend_attr_listrÉ)rÚdict_r¡rrrÚupdate_basic_atts
s



zElement.update_basic_attscCs,x&|D]}|||
kr||
j|ƒ

qWd
S)zÜ
        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.
        N)
r)rrËr¶r*rrrrÖs	


zElement.append_attr_listcCs>t|j
|
ƒ
tƒs||
g
||
<t|tƒs.|g
}|j|
|ƒ
d
S)a

        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.
        N)rSrÉrrÖ)rrËr*rrrÚcoerce_append_attr_list!s
	




zElement.coerce_append_attr_listTcCs|s|j|
ƒ
d
kr|||
<d
S)z‚
        If self[attr] does not exist or force is True or omitted, set
        self[attr] to value, otherwise do nothing.
        N)
rÉ)rrËr*ÚforcerrrÚreplace_attr0s
zElement.replace_attrcCs|j|
ƒ
|k	r|j
|
|ƒ
d
S)a

        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.
        N)rÉrÙ)rrËr*rxrrrÚcopy_attr_convert9s
zElement.copy_attr_convertcCsH|j|
ƒ
|k	rDt
|j|
ƒ
tƒs(t
|tƒr6|j|
|ƒ
n|j|
||ƒ
d
S)a—

        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.
        N)rÉrSrrÙrÛ)rrËr*rxrrrÚcopy_attr_coerceDs
	



zElement.copy_attr_coercecCsH|j|
ƒ
|k	rDt
|j|
ƒ
tƒr6t
|tƒr6|j|
|ƒ
n|j|
||ƒ
d
S)aM

        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.
        N)rÉrSrrÖrÛ)rrËr*rxrrrÚcopy_attr_concatenateTs




zElement.copy_attr_concatenatecCs |j|
ƒ
|k	r|j
|
||ƒ
d
S)zz
        If replace is True or self[attr] is None, replace self[attr] with
        value.  Otherwise, do nothing.
        N)rÉrÛ)rrËr*rxrrrÚcopy_attr_consistentcs
zElement.copy_attr_consistentFcCsVt|
t
ƒr|
j}
|r|j}n|j}|j|
ƒ

x$t||
ƒD]}||||
||ƒ
q8Wd
S)a.
        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.
        N)rSr%rÚis_not_list_attributeÚis_not_known_attributerØÚfilter)rr×Z
update_funrxÚ
and_sourceZ
filter_funr¡rrrÚupdate_all_attsks




zElement.update_all_attscCs|j|
t
j||ƒ
d
S)aC
        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.
        N)rär—rß)rr×rxrãrrrÚupdate_all_atts_consistantly‘s
z$Element.update_all_atts_consistantlycCs|j|
t
j||ƒ
d
S)a
        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.
        N)rär—rÞ)rr×rxrãrrrÚupdate_all_atts_concatenating¦s
z%Element.update_all_atts_concatenatingcCs|j|
t
j||ƒ
d
S)a[
        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.
        N)rär—rÝ)rr×rxrãrrrÚupdate_all_atts_coercion¾s
z Element.update_all_atts_coercioncCs|j|
t
j|d

dS)a}
        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.
        )
rãN)rär—rÜ)rr×rãrrrÚupdate_all_atts_convert×s

zElement.update_all_atts_convertc

Cs
g|_dS)
N)
rK)
rrrrÚclearìs
z
Element.clearcCsD|j|
ƒ
}t
|tƒr(|j|ƒ

|||<n|d
k	r@||||d…<d
S)z8Replace one child `Node` with another child or children.Nra)r!rSr%rC)rÚoldÚnewr!rrrrxïs








zElement.replacecCsŠ|
}t|
t
ƒs4y|
d
}Wntk
r2


d}YnXt|tƒrJ|j|ƒ

n.x,|jD]"}||sRtd|||fƒ
‚
qRW|jj||
ƒ
dS)zc
        Replace `self` node with `new`, where `new` is a node or a
        list of nodes.
        r
NzLosing "%s" attribute: %s)	rSr%Ú
IndexErrorr—rØrÕr½r'rx)rrëÚupdater¡rrrÚreplace_selføs











zElement.replace_selfcCsRt|
t
ƒs|
f
}
x<t|tt|ƒ
|ƒƒD]$}x|
D]}t|||ƒr0|Sq0Wq&Wd
S)aM

        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.
        N)rSÚtupleÚrangeÚminrc)rÚ
childclassr¾Úendr!r­rrrÚfirst_child_matching_classs







z"Element.first_child_matching_classcCsVt|
t
ƒs|
f
}
x@t|tt|ƒ
|ƒƒD](}x"|
D]}t|j||ƒr0Pq0W|Sq&Wd
S)aI

        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.
        N)rSrïrðrñrcrK)rròr¾rór!r­rrrÚfirst_child_not_matching_class!s







z&Element.first_child_not_matching_classú    cs2d
jdˆˆ
|j
ƒfg
‡‡
fdd„|jDƒ
ƒ
S)Nrwz%s%s
c
sg|]}
|
jˆˆ
dƒ‘qS)
ra)
r:)rrB)r8r9rrrŽ9s
z#Element.pformat.<locals>.<listcomp>)ryr®rK)rr8r9r)r8r9rr:7s


zElement.pformatc
Cs4|jfd
|j
i
|j—Ž
}
|j|
_|j|
_|j|
_|
S)Nrƒ)rFrƒrr&r>r@)rÚobjrrrr;<s





zElement.copyc
Cs"|jƒ}
|
j
d
d„|jDƒ
ƒ

|
S)Nc
Ssg|]}
|
jƒ‘qSr)
r<)rrBrrrrŽEsz$Element.deepcopy.<locals>.<listcomp>)r;r rK)rr;rrrr<Cs


zElement.deepcopycCs2tj
d
tdd
d|
kst‚
|dj|
jƒƒ

dS)z+Add a new class to the "classes" attribute.zadocutils.nodes.Element.set_class deprecated; append to Element['classes'] list attribute directlyr)
rr¢r™N)r	r
ÚDeprecationWarningr½rr )rrµrrrÚ	set_classHs


zElement.set_classcCsZd
|_t
|diƒj|
ƒ
}t
|diƒj|ƒ
}|r@|
dk	s:t‚
d
|_|rV|dk	sPt‚
d
|_dS)zQNote that this Element has been referenced by its name
        `name` or id `id`.raZexpect_referenced_by_nameZexpect_referenced_by_idN)Ú
referencedÚgetattrrÉr½)rrµÚidZby_nameZby_idrrrÚnote_referenced_byPs






zElement.note_referenced_bycCs
|
|jkS)
z‹
        Returns True if and only if the given attribute is NOT one of the
        basic list attributes defined for all Elements.
        )
rž)rUrËrrrràaszElement.is_not_list_attributecCs
|
|jkS)
zj
        Returns True if and only if the given attribute is NOT recognized by
        this class.
        )
Úknown_attributes)rUrËrrrráiszElement.is_not_known_attribute)r˜r™ršr›)
rœ)r>rƒ)
rw)rr
)
N)
N)
N)
rwéÿÿÿÿ)
rÿ)
T)
T)TF)TF)TF)
F)rör
)NN)HrrrrgrÕZlocal_attributesržrþr‡rÅr„r3rnr‰r±rjrkr.r®r¯r°r·rrrrÁrrÃrÄr=rÇr¦rÉrÌrÍrÎZhas_keyrÒrr r"r#rÔr!rÆrØrÖrÙrÛrÜrÝrÞrßrärårærçrèrérxrîÚmaxsizerôrõr:r;r<rùrýÚclassmethodràrárrrrr—â
sŽ#












	

%






	


r—c@seZ
dZd
ZdZddd„
ZdS)ÚTextElementaé

    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.
    rwcOs@|d
kr(t|ƒ
}t
j||
|f|ž|Ž

nt
j||
f|ž|Ž

dS)Nrw)r~r—r„)rrƒr{rKrZtextnoderrrr„„s




zTextElement.__init__N)rwrw)rrrrgrÅr„rrrrr
rs
r
c@seZ
dZd
Zddd„
ZdS)ÚFixedTextElementz5An element which directly contains preformatted text.rwcOs$tj
||
|f|ž|Ž

d
|jd<dS)NZpreservez	xml:space)r
r„r)rrƒr{rKrrrrr„‘s

zFixedTextElement.__init__N)rwrw)rrrrgr„rrrrr
sr
c
@seZ
dZd
ZdS)Ú
Resolvabler
N)rrrZresolvedrrrrr
šsr
c@seZ
dZd
d„ZdS)ÚBackLinkablecCs|d
j|
ƒ

dS)Nrœ)
r)rÚrefidrrrÚadd_backref¡s
zBackLinkable.add_backrefN)rrrr
rrrrr
Ÿsr
c
@seZ
dZd
S)ÚRootN)rrrrrrrr
©s
r
c
@seZ
dZd
S)ÚTitularN)rrrrrrrr	
­s
r	
c
@seZ
dZd
ZdS)ÚPreBibliographicz<Category of Node which may occur before Bibliographic Nodes.N)rrrrgrrrrr

±s
r

c
@seZ
dZd
S)Ú
BibliographicN)rrrrrrrr
µs
r
c
@seZ
dZd
S)Ú
DecorativeN)rrrrrrrr
¹s
r
c
@seZ
dZd
S)Ú
StructuralN)rrrrrrrr

½s
r

c
@seZ
dZd
S)ÚBodyN)rrrrrrrr
Ás
r
c
@seZ
dZd
S)ÚGeneralN)rrrrrrrr
Ås
r
c
@seZ
dZd
ZdS)Ú
SequentialzList-like elements.N)rrrrgrrrrr
És
r
c
@seZ
dZd
S)Ú
AdmonitionN)rrrrrrrr
Ísr
c
@seZ
dZd
ZdS)ÚSpecialzSpecial internal body elements.N)rrrrgrrrrr
Ðs
r
c
@seZ
dZd
ZdS)Ú	Invisiblez.Internal elements that don't appear in output.N)rrrrgrrrrr
Ôs
r
c
@seZ
dZd
S)ÚPartN)rrrrrrrr
Øs
r
c
@seZ
dZd
S)ÚInlineN)rrrrrrrr
Üs
r
c
@seZ
dZd
S)ÚReferentialN)rrrrrrrr
às
r
c
@seZ
dZd
ZdZdS)Ú
Targetabler
N)rrrrúZindirect_reference_namerrrrr
äsr
c
@seZ
dZd
ZdS)ÚLabeledz(Contains a `label` as its first element.N)rrrrgrrrrr
ís
r
c@s
eZ
dZd
Zdd„Zdd„Zd>dd„
Zd?d
d„
Zd@dd
„
Zdd„Z	dd„Z
dAdd„
ZdBdd„
Zdd„Z
dd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„ZdCd.d/„
Zd0d1„ZdDd2d3„
Zd4d5„Zd6d7„Zd8d9„Zd:d;„Zd<d=„Z dS)Er(z‚
    The document root element.

    Do not instantiate this class directly; use
    `docutils.utils.new_document()` instead.
    cOsÖtj
|f
|ž|Ž

d|_d|_|
|_||_g|_i|_i|_i|_	i|_
i|_i|_i|_
i|_i|_g|_g|_g|_g|_g|_g|_d
|_d|_tƒ|_g|_g|_ddl}|jj|ƒ
|_g|_ d|_!||_"dS)Nrar
)#r—r„r?rAr‘rDÚindirect_targetsÚsubstitution_defsÚsubstitution_namesÚrefnamesÚrefidsÚnameidsÚ	nametypesr˜Ú
footnote_refsÚ
citation_refsÚ
autofootnotesÚautofootnote_refsÚsymbol_footnotesÚsymbol_footnote_refsÚ	footnotesÚ	citationsZautofootnote_startZsymbol_footnote_startrÚ
id_counterÚparse_messagesÚtransform_messagesZdocutils.transformsZ
transformsZTransformerÚtransformerZinclude_logÚ
decorationr&)rr‘rDr
rZdocutilsrrrr„þs>

zdocument.__init__c
Cs|jj
ƒ}
d
|
d<d
|
d<|
S)zB
        Return dict with unpicklable references removed.
        NrDr+
)Ú__dict__r;)rÚstaterrrÚ__getstate__Zs



zdocument.__getstate__NcCs0|
d
krdd
lj
j}
|
jƒ}|j|j|ƒ
ƒ

|S)z-Return a DOM representation of this document.Nr
)r/r0r1r2r§r3)rr0r4rrrr5cs




zdocument.asdomrwcCs>
|
d
rZxL|
d
D]@}|jj
||
ƒ
|j||
k	r|jjd|ƒ
}|dkr||7}qW|S|jj}|jj}d}d}x®|
dD]$}	t|	ƒ
}||}|r|||jkr|Pq|W|r¼|jdƒ
r¼|d}
n0||}
|
jdƒ
rìd|
dd
…|pæt|
j	ƒ
f}
x4|j
|
d7<d	|
|j
|
f}||jkrîPqîW|
d
j|ƒ

|
|j|<|S)Nr˜zDuplicate ID: "%s".rwršú
%ú
-z%s%s-raz%s%drÿ)r˜rÎrDZseverer‘Ú	id_prefixÚauto_id_prefixÚmake_idÚendswithr‡r(
r)rr_ÚmsgnodeZsuggested_prefixrürr2
r3
Zbase_idrµÚprefixrrrÚset_idks>




























zdocument.set_idcCsHxB|
d
D]6}||jkr,|j
|
||||ƒ
q
||j|<||j|<q
WdS)aÝ
        `self.nameids` maps names to IDs, while `self.nametypes` maps names to
        booleans representing hyperlink type (True==explicit,
        False==implicit).  This method updates the mappings.

        The following state transition table shows how `self.nameids` ("ids")
        and `self.nametypes` ("types") change with new input (a call to this
        method), and what actions are performed ("implicit"-type system
        messages are INFO/1, and "explicit"-type system messages are ERROR/3):

        ====  =====  ========  ========  =======  ====  =====  =====
         Old State    Input          Action        New State   Notes
        -----------  --------  -----------------  -----------  -----
        ids   types  new type  sys.msg.  dupname  ids   types
        ====  =====  ========  ========  =======  ====  =====  =====
        -     -      explicit  -         -        new   True
        -     -      implicit  -         -        new   False
        None  False  explicit  -         -        new   True
        old   False  explicit  implicit  old      new   True
        None  True   explicit  explicit  new      None  True
        old   True   explicit  explicit  new,old  None  True   [#]_
        None  False  implicit  implicit  new      None  False
        old   False  implicit  implicit  new,old  None  False
        None  True   implicit  implicit  new      None  True
        old   True   implicit  implicit  new      old   True
        ====  =====  ========  ========  =======  ====  =====  =====

        .. [#] Do not clear the name-to-id map or invalidate the old target if
           both old and new targets are external and refer to identical URIs.
           The new target is invalidated regardless.
        ršN)r
Úset_duplicate_name_idr
)rr_rür6
ÚexplicitrµrrrÚset_name_id_map”s
 




zdocument.set_name_id_mapcCsj
|j|}|j
|}|p||j
|<|rê|rÂd
}|dk	rŒ|j|}	d|
krp|
d}
|	drpd|	krp|	d|
krpd}|dkrŒt|	|ƒ
d|j|<|jj|d||g
|
d}|dkr¶||7}t|
|ƒ
n&||j|<|dk	rè|j|}	t|	|ƒ
n8|dk	oö|
rd|j|<|j|}	t|	|ƒ
t|
|ƒ
|
s<|
rf|dk	
rf|jjd||g
|
d}|dk
rf||7}dS)NrÚrefuriršraz%Duplicate explicit target name: "%s".)rœÚ	base_nodez%Duplicate implicit target name: "%s".)r
r
r˜ÚdupnamerDÚsystem_messageÚinfo)rr_rürµr6
r:
Zold_idZold_explicitr9Úold_noder<
rrrrr9
»sL















































zdocument.set_duplicate_name_idcCs
|
|jkS)
N)
r
)rrµrrrÚhas_nameås
zdocument.has_namecCs"|j|
|ƒ}|j
|
||dd

dS)N)
r:
)r8
r;
)rÚtargetr6
rürrrÚnote_implicit_targetés

zdocument.note_implicit_targetcCs"|j|
|ƒ}|j
|
||d
d
dS)NT)
r:
)r8
r;
)rrC
r6
rürrrÚnote_explicit_targetís

zdocument.note_explicit_targetcCs|jj
|
d
gƒj|
ƒ

dS)NÚrefname)r
rÎr)rr_rrrÚnote_refnameñs
zdocument.note_refnamecCs|jj
|
d
gƒj|
ƒ

dS)Nr
)r
rÎr)rr_rrrÚ
note_refidôs
zdocument.note_refidcCs"|jj
|
ƒ

|
d
r|j|
ƒ

dS)Nrš)r
rrG
)rrC
rrrÚnote_indirect_target÷s


zdocument.note_indirect_targetcCs|j|
ƒ

dS)
N)
r8
)rrC
rrrÚnote_anonymous_targetüs
zdocument.note_anonymous_targetcCs|j|
ƒ

|j
j|
ƒ

dS)
N)r8
r"
r)rÚfootnoterrrÚnote_autofootnoteÿs


zdocument.note_autofootnotecCs|j|
ƒ

|j
j|
ƒ

dS)
N)r8
r#
r)rÚrefrrrÚnote_autofootnote_refs


zdocument.note_autofootnote_refcCs|j|
ƒ

|j
j|
ƒ

dS)
N)r8
r$
r)rrK
rrrÚnote_symbol_footnotes


zdocument.note_symbol_footnotecCs|j|
ƒ

|j
j|
ƒ

dS)
N)r8
r%
r)rrM
rrrÚnote_symbol_footnote_refs


z!document.note_symbol_footnote_refcCs|j|
ƒ

|j
j|
ƒ

dS)
N)r8
r&
r)rrK
rrrÚ
note_footnotes


zdocument.note_footnotecCs0|j|
ƒ

|j
j|
d
gƒj|
ƒ

|j|
ƒ

dS)NrF
)r8
r 
rÎrrG
)rrM
rrrÚnote_footnote_refs



zdocument.note_footnote_refcCs|jj
|
ƒ

dS)
N)r'
r)rÚcitationrrrÚ
note_citations
zdocument.note_citationcCs0|j|
ƒ

|j
j|
d
gƒj|
ƒ

|j|
ƒ

dS)NrF
)r8
r!
rÎrrG
)rrM
rrrÚnote_citation_refs



zdocument.note_citation_refcCsft|ƒ
}||j
krJ|jjd
||
d}|dkr6||7}|j
|}t||ƒ
|
|j
|<||jt|ƒ
<dS)Nz-Duplicate substitution definition name: "%s".)
r=
)Úwhitespace_normalize_namer
rDÚerrorr>
r
Úfully_normalize_name)rZsubdefZdef_namer6
rµrZoldnoderrrÚnote_substitution_def s












zdocument.note_substitution_defcCst|ƒ
|
d
<dS)NrF
)
rV
)rZsubrefrF
rrrÚnote_substitution_ref/s
zdocument.note_substitution_refcCs|jj
|
|ƒ
dS)
N)r+
Zadd_pending)rÚpendingÚpriorityrrrÚnote_pending2s
zdocument.note_pendingcCs|jj
|
ƒ

dS)
N)r)
r)rÚmessagerrrÚnote_parse_message5s
zdocument.note_parse_messagecCs|jj
|
ƒ

dS)
N)r*
r)rr^
rrrÚnote_transform_message8s
zdocument.note_transform_messagecCs$|
|_|dkr||_
n
|d
|_
dS)Nra)r?rA)rr>ÚoffsetrrrÚnote_source;s


zdocument.note_sourcec
Cs*|j|j
|jf|jŽ
}
|j|
_|j|
_|
S)
N)rFr‘rDrr>r@)rr÷rrrr;Bs





z
document.copyc
CsB|js<tƒ|_|j
tƒ
}
|
dkr.|j|jƒ

n|j|
|jƒ
|jS)
N)r,
rõr	
rr")rr!rrrÚget_decorationIs






zdocument.get_decoration)
N)Nrw)NN)
N)
N)
N)
N)!rrrrgr„r/
r5r8
r;
r9
rB
rD
rE
rG
rH
rI
rJ
rL
rN
rO
rP
rQ
rR
rT
rU
rY
rZ
r]
r_
r`
rb
r;rc
rrrrr(õs<\	

)
'*



r(c
@seZ
dZd
S)ÚtitleN)rrrrrrrrd
Xsrd
c
@seZ
dZd
S)ÚsubtitleN)rrrrrrrre
Ysre
c
@seZ
dZd
S)ÚrubricN)rrrrrrrrf
Zsrf
c
@seZ
dZd
S)ÚdocinfoN)rrrrrrrrg
asrg
c
@seZ
dZd
S)ÚauthorN)rrrrrrrrh
bsrh
c
@seZ
dZd
S)ÚauthorsN)rrrrrrrri
csri
c
@seZ
dZd
S)ÚorganizationN)rrrrrrrrj
dsrj
c
@seZ
dZd
S)ÚaddressN)rrrrrrrrk
esrk
c
@seZ
dZd
S)ÚcontactN)rrrrrrrrl
fsrl
c
@seZ
dZd
S)ÚversionN)rrrrrrrrm
gsrm
c
@seZ
dZd
S)ÚrevisionN)rrrrrrrrn
hsrn
c
@seZ
dZd
S)ÚstatusN)rrrrrrrro
isro
c
@seZ
dZd
S)ÚdateN)rrrrrrrrp
jsrp
c
@seZ
dZd
S)Ú	copyrightN)rrrrrrrrq
ksrq
c@seZ
dZd
d„Zdd„ZdS)r,
c

Cs6t|j
ƒ
st|j
d
tƒr,|jd
tƒƒ
|j
d
S)Nr
)rcrKrSÚheaderr")
rrrrÚ
get_headerts


zdecoration.get_headerc

Cs4t|j
ƒ
st|j
dtƒr*|jtƒƒ

|j
dS)Nrarÿrÿ)rcrKrSÚfooterr)
rrrrÚ
get_footerys


zdecoration.get_footerN)rrrrs
ru
rrrrr,
rsr,
c
@seZ
dZd
S)rr
N)rrrrrrrrr
srr
c
@seZ
dZd
S)rt
N)rrrrrrrrt
€srt
c
@seZ
dZd
S)ÚsectionN)rrrrrrrrv
‡srv
c
@seZ
dZd
ZdS)Útopicaü

    Topics are terminal, "leaf" mini-sections, like block quotes with titles,
    or textual figures.  A topic is just like a section, except that it has no
    subsections, and it doesn't have to conform to section placement rules.

    Topics are allowed wherever body elements (list, table, etc.) are allowed,
    but only at the top level of a section or document.  Topics cannot nest
    inside topics, sidebars, or body elements; you can't have a topic inside a
    table, list, block quote, etc.
    N)rrrrgrrrrrw
Šsrw
c
@seZ
dZd
ZdS)ÚsidebaraŸ
    Sidebars are like miniature, parallel documents that occur inside other
    documents, providing related or reference material.  A sidebar is
    typically offset by a border and "floats" to the side of the page; the
    document's main text may flow around it.  Sidebars can also be likened to
    super-footnotes; their content is outside of the flow of the document's
    main text.

    Sidebars are allowed wherever body elements (list, table, etc.) are
    allowed, but only at the top level of a section or document.  Sidebars
    cannot nest inside sidebars, topics, or body elements; you can't have a
    sidebar inside a table, list, block quote, etc.
    N)rrrrgrrrrrx
˜srx
c
@seZ
dZd
S)Ú
transitionN)rrrrrrrry
©sry
c
@seZ
dZd
S)Ú	paragraphN)rrrrrrrrz
°srz
c
@seZ
dZd
S)ÚcompoundN)rrrrrrrr{
±sr{
c
@seZ
dZd
S)Ú	containerN)rrrrrrrr|
²sr|
c
@seZ
dZd
S)Úbullet_listN)rrrrrrrr}
³sr}
c
@seZ
dZd
S)Úenumerated_listN)rrrrrrrr~
´sr~
c
@seZ
dZd
S)Ú	list_itemN)rrrrrrrr
µsr
c
@seZ
dZd
S)Údefinition_listN)rrrrrrrr€
¶sr€
c
@seZ
dZd
S)Údefinition_list_itemN)rrrrrrrr
·sr
c
@seZ
dZd
S)ÚtermN)rrrrrrrr‚
¸sr‚
c
@seZ
dZd
S)Ú
classifierN)rrrrrrrrƒ
¹srƒ
c
@seZ
dZd
S)Ú
definitionN)rrrrrrrr„
ºsr„
c
@seZ
dZd
S)Ú
field_listN)rrrrrrrr…
»sr…
c
@seZ
dZd
S)ÚfieldN)rrrrrrrr†
¼sr†
c
@seZ
dZd
S)Ú
field_nameN)rrrrrrrr‡
½sr‡
c
@seZ
dZd
S)Ú
field_bodyN)rrrrrrrrˆ
¾srˆ
c
@seZ
dZd
ZdS)ÚoptionrwN)rrrrÅrrrrr‰
Ásr‰
c@seZ
dZd
d„ZdS)Úoption_argumentc

Cs|jd
dƒt
j|ƒ
S)NÚ	delimiterr¢)rÉr
r=)
rrrrr=Ès
zoption_argument.astextN)rrrr=rrrrrŠ
ÆsrŠ
c
@seZ
dZd
ZdS)Úoption_groupz, N)rrrrÅrrrrrŒ
ÌsrŒ
c
@seZ
dZd
S)Úoption_listN)rrrrrrrr
Ñsr
c
@seZ
dZd
ZdS)Úoption_list_itemz  N)rrrrÅrrrrrŽ
ÔsrŽ
c
@seZ
dZd
S)Ú
option_stringN)rrrrrrrr
Ùsr
c
@seZ
dZd
S)ÚdescriptionN)rrrrrrrr
Úsr
c
@seZ
dZd
S)Ú
literal_blockN)rrrrrrrr‘
Ûsr‘
c
@seZ
dZd
S)Ú
doctest_blockN)rrrrrrrr’
Üsr’
c
@seZ
dZd
S)Ú
math_blockN)rrrrrrrr“
Ýsr“
c
@seZ
dZd
S)Ú
line_blockN)rrrrrrrr”
Þsr”
c
@seZ
dZd
Zd
S)r@N)rrrr8rrrrr@ásr@c
@seZ
dZd
S)Úblock_quoteN)rrrrrrrr•
æsr•
c
@seZ
dZd
S)ÚattributionN)rrrrrrrr–
çsr–
c
@seZ
dZd
S)Ú	attentionN)rrrrrrrr—
èsr—
c
@seZ
dZd
S)ÚcautionN)rrrrrrrr˜
ésr˜
c
@seZ
dZd
S)ÚdangerN)rrrrrrrr™
êsr™
c
@seZ
dZd
S)rW
N)rrrrrrrrW
ësrW
c
@seZ
dZd
S)Ú	importantN)rrrrrrrrš
ìsrš
c
@seZ
dZd
S)ÚnoteN)rrrrrrrr›
ísr›
c
@seZ
dZd
S)ÚtipN)rrrrrrrrœ
îsrœ
c
@seZ
dZd
S)ÚhintN)rrrrrrrr
ïsr
c
@seZ
dZd
S)ÚwarningN)rrrrrrrrž
ðsrž
c
@seZ
dZd
S)Ú
admonitionN)rrrrrrrrŸ
ñsrŸ
c
@seZ
dZd
S)ÚcommentN)rrrrrrrr 
òsr 
c
@seZ
dZd
S)Úsubstitution_definitionN)rrrrrrrr¡
ósr¡
c
@seZ
dZd
S)rC
N)rrrrrrrrC
ôsrC
c
@seZ
dZd
S)rK
N)rrrrrrrrK
õsrK
c
@seZ
dZd
S)rS
N)rrrrrrrrS
ösrS
c
@seZ
dZd
S)ÚlabelN)rrrrrrrr¢
÷sr¢
c
@seZ
dZd
S)ÚfigureN)rrrrrrrr£
øsr£
c
@seZ
dZd
S)ÚcaptionN)rrrrrrrr¤
ùsr¤
c
@seZ
dZd
S)ÚlegendN)rrrrrrrr¥
úsr¥
c
@seZ
dZd
S)ÚtableN)rrrrrrrr¦
ûsr¦
c
@seZ
dZd
S)ÚtgroupN)rrrrrrrr§
üsr§
c
@seZ
dZd
S)ÚcolspecN)rrrrrrrr¨
ýsr¨
c
@seZ
dZd
S)ÚtheadN)rrrrrrrr©
þsr©
c
@seZ
dZd
S)ÚtbodyN)rrrrrrrrª
ÿsrª
c
@seZ
dZd
S)ÚrowN)rrrrrrrr«
sr«
c
@seZ
dZd
S)ÚentryN)rrrrrrrr¬

sr¬
c@s"eZ
dZd
Zddd„
Zdd„ZdS)r?
z‘
    System message element.

    Do not instantiate this class directly; use
    ``document.reporter.info/warning/error/severe()`` instead.
    Nc	Os^|jd
dƒ}|
r$t
d|
ƒ}|f
|}ytj||f|ž|Ž

Wn


td|f
ƒ

‚YnXdS)Nrƒrwzsystem_message: children=%r)r#rz
r—r„Úprint)rr^
rKrrƒÚ
prrrr„
s










zsystem_message.__init__c
Cs0|jd
dƒ}
d|d|
|d|dt
j|ƒ
fS)Nr@rwz%s:%s: (%s/%s) %sr>rbr9)rÉr—r=)rr@rrrr=s


zsystem_message.astext)
N)rrrrgr„r=rrrrr?
s
r?
c@s,eZ
dZd
Zddd„
Zd
dd	„
Zd
d„ZdS)r[
aF
    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.
    NrwcOs(tj
||f|ž|Ž

|
|_|p i|_dS)
N)r—r„Ú	transformÚdetails)rr¯
r°
rƒrKrrrrr„:s

zpending.__init__ú    r
cs

d
d|jj
|jjfdg}t|jjƒƒ
}x¸|D]°\}}t|tƒrp|jdd|fƒ

|j	dd„|j
ƒjƒDƒ
ƒ

q.|rÊt|tƒrÊt|dtƒrÊ|jdd|fƒ

x>|D] }|j	d	d„|j
ƒjƒDƒ
ƒ

q¤Wq.|jd
d||fƒ

q.Wt
j
|ˆˆ
ƒdj‡‡
fdd„|Dƒ
ƒ
S)Nz.. internal attributes:z     .transform: %s.%sz     .details:z%7s%s:rwc
Ssg|]}
dd
|
f‘qS)z%9s%srwr)rr@rrrrŽOs
z#pending.pformat.<locals>.<listcomp>r
c
Ssg|]}
dd
|
f‘qS)z%9s%srwr)rr@rrrrŽUs
z	%7s%s: %rc
sg|]}
dˆˆ
|
f‘qS)
z	    %s%s
r)rr@)r8r9rrrŽZs
)r¯
rrrÈr°
rŸrSr%rr r:r’rr—ry)rr8r9Z	internalsr°
r¹r*r¤r)r8r9rr:Es(






















zpending.pformatc
Cs6|j|j
|j|jf|jŽ
}
|j|
_|j|
_|j|
_|
S)
N)rFr¯
r°
rƒrr&r>r@)rr÷rrrr;]s





zpending.copy)Nrw)r±
r
)rrrrgr„r:r;rrrrr[
s




r[
c
@seZ
dZd
ZdS)Úrawz@
    Raw data that is to be passed untouched to the Writer.
    N)rrrrgrrrrr²
fsr²
c
@seZ
dZd
S)ÚemphasisN)rrrrrrrr³
ssr³
c
@seZ
dZd
S)ÚstrongN)rrrrrrrr´
tsr´
c
@seZ
dZd
S)ÚliteralN)rrrrrrrrµ
usrµ
c
@seZ
dZd
S)Ú	referenceN)rrrrrrrr¶
vsr¶
c
@seZ
dZd
S)Úfootnote_referenceN)rrrrrrrr·
wsr·
c
@seZ
dZd
S)Úcitation_referenceN)rrrrrrrr¸
xsr¸
c
@seZ
dZd
S)Úsubstitution_referenceN)rrrrrrrr¹
ysr¹
c
@seZ
dZd
S)Útitle_referenceN)rrrrrrrrº
zsrº
c
@seZ
dZd
S)ÚabbreviationN)rrrrrrrr»
{sr»
c
@seZ
dZd
S)ÚacronymN)rrrrrrrr¼
|sr¼
c
@seZ
dZd
S)ÚsuperscriptN)rrrrrrrr½
}sr½
c
@seZ
dZd
S)Ú	subscriptN)rrrrrrrr¾
~sr¾
c
@seZ
dZd
S)ÚmathN)rrrrrrrr¿
sr¿
c@seZ
dZd
d„ZdS)Úimagec

Cs|jd
dƒS)NZaltrw)
rÉ)
rrrrr=„s
zimage.astextN)rrrr=rrrrrÀ
‚srÀ
c
@seZ
dZd
S)ÚinlineN)rrrrrrrrÁ
ˆsrÁ
c
@seZ
dZd
S)ÚproblematicN)rrrrrrrrÂ
‰srÂ
c
@seZ
dZd
S)Ú	generatedN)rrrrrrrrÃ
ŠsrÃ
a<
    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
    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
    warningc@s<eZ
dZd
ZfZdd„Zdd„Zdd„Zdd	„Zd
d„Z	dS)
ÚNodeVisitoraŽ
    "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 should be implemented for *all* node types encountered (such as
    for `docutils.writers.Writer` subclasses).  Unimplemented methods will
    raise exceptions.

    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.
    cCs
|
|_dS)
N)
r()rr(rrrr„×s
zNodeVisitor.__init__cCs:|
jj
}t|d
||jƒ}|jjjd|j
|fƒ

||
ƒ
S)zª
        Call self."``visit_`` + node class name" with `node` as
        parameter.  If the ``visit_...`` method does not exist, call
        self.unknown_visit.
        Úvisit_z;docutils.nodes.NodeVisitor.dispatch_visit calling %s for %s)rFrrûÚ
unknown_visitr(rDrE)rr_Ú	node_nameÚmethodrrrrGÚs




zNodeVisitor.dispatch_visitcCs:|
jj
}t|d
||jƒ}|jjjd|j
|fƒ

||
ƒ
S)z°
        Call self."``depart_`` + node class name" with `node` as
        parameter.  If the ``depart_...`` method does not exist, call
        self.unknown_departure.
        Údepart_z?docutils.nodes.NodeVisitor.dispatch_departure calling %s for %s)rFrrûÚunknown_departurer(rDrE)rr_rÇ
rÈ
rrrrRçs




zNodeVisitor.dispatch_departurecCs2|jj
js|
jj|jkr.td
|j|
jjfƒ
‚
dS)zk
        Called when entering unknown `Node` types.

        Raise an exception unless overridden.
        z!%s visiting unknown node type: %sN)r(r‘Ústrict_visitorrFrÚoptionalr7)rr_rrrrÆ
ôs





zNodeVisitor.unknown_visitcCs2|jj
js|
jj|jkr.td
|j|
jjfƒ
‚
dS)zi
        Called before exiting unknown `Node` types.

        Raise exception unless overridden.
        z"%s departing unknown node type: %sN)r(r‘rË
rFrrÌ
r7)rr_rrrrÊ
s





zNodeVisitor.unknown_departureN)
rrrrgrÌ
r„rGrRrÆ
rÊ
rrrrrÄ
°s


rÄ
c
@seZ
dZd
ZdS)ÚSparseNodeVisitora

    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.
    N)rrrrgrrrrrÍ

srÍ
c@s eZ
dZd
Zdd„Zdd„ZdS)ÚGenericNodeVisitora˜
    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.
    c
Cst‚
d
S)z)Override for generic, uniform traversals.N)
r7)rr_rrrÚ
default_visit)sz GenericNodeVisitor.default_visitc
Cst‚
d
S)z)Override for generic, uniform traversals.N)
r7)rr_rrrÚdefault_departure-sz$GenericNodeVisitor.default_departureN)rrrrgrÏ
rÐ
rrrrrÎ
srÎ
cCs|j|
ƒ

dS)
N)
rÏ
)rr_rrrÚ_call_default_visit1s
rÑ
cCs|j|
ƒ

dS)
N)
rÐ
)rr_rrrÚ_call_default_departure4s
rÒ
c
CsdS)
Nr)rr_rrrÚ_nop7s
rÓ
c
CsRxL|D]D}
tt
d
|
tƒ
tt
d|
tƒ
ttd
|
tƒ
ttd|
tƒ
qWdS)z%Save typing with dynamic assignments:rÅ
rÉ
N)ÚsetattrrÎ
rÑ
rÒ
rÍ
rÓ
)ršÚ_namerrrÚ_add_node_class_names:s





rÖ
c@s0eZ
dZd
Zdd„Zdd„Zdd„Zdd	„Zd
S)ÚTreeCopyVisitorzQ
    Make a complete copy of a tree or branch, including element attributes.
    cCstj
||
ƒ
g|_g|_dS)
N)rÎ
r„Úparent_stackr')rr(rrrr„Ks


zTreeCopyVisitor.__init__c

Cs
|jd
S)Nr
)
r')
rrrrÚ
get_tree_copyPs
zTreeCopyVisitor.get_tree_copycCs,|
jƒ}|j
j|ƒ

|jj|j
ƒ

||_
d
S)z9Copy the current node, and make it the new acting parent.N)r;r'rrØ
)rr_ZnewnoderrrrÏ
Ss


zTreeCopyVisitor.default_visitcCs|jj
ƒ|_d
S)z#Restore the previous acting parent.N)rØ
r#r')rr_rrrrÐ
Zsz!TreeCopyVisitor.default_departureN)rrrrgr„rÙ
rÏ
rÐ
rrrrr×
Es
r×
c
@seZ
dZd
ZdS)ÚTreePruningExceptionz÷
    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.
    N)rrrrgrrrrrÚ
_srÚ
c
@seZ
dZd
ZdS)rHz…
    Do not visit any children of the current node.  The current node's
    siblings and ``depart_...`` method are not affected.
    N)rrrrgrrrrrHlsrHc
@seZ
dZd
ZdS)rMz
    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.
    N)rrrrgrrrrrMvsrMc
@seZ
dZd
ZdS)rIzq
    Do not visit the current node's children, and do not call the current
    node's ``depart_...`` method.
    N)rrrrgrrrrrI€srIc
@seZ
dZd
ZdS)rJz
    Do not call the current node's ``depart_...`` method.  The current node's
    children and siblings are not affected.
    N)rrrrgrrrrrJŠsrJc
@seZ
dZd
ZdS)Ú	NodeFoundz¥
    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.
    N)rrrrgrrrrrÛ
”srÛ
c
@seZ
dZd
ZdS)rNa=

    Stop the traversal alltogether.  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.
    N)rrrrgrrrrrNŸsrNc
Csr|jƒ}
t
|
tƒs|
jƒ}
|
jtƒ
}
|
jtƒ
}
tjd
|
ƒj	ddƒjdƒ
}
t
jddj|
j
ƒƒ
ƒ}
tjd|
ƒ}
t|
ƒ
S)aû
    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: http://www.w3.org/TR/html401
    .. _CSS1 spec: http://www.w3.org/TR/REC-CSS1
    ZNFKDroÚignorer1
r¢rw)r rSr,ÚdecodeÚ	translateÚ_non_id_translate_digraphsÚ_non_id_translateÚunicodedataÚ	normalizer-Ú
_non_id_charsÚsubryrzÚ_non_id_at_endsr¿)Ústringrürrrr4
¬s#









r4
z
[^a-z0-9]+z^[-0-9]+|-+$Ú
oÚ
dÚ
hrÓÚ
lÚ
tÚ
br­Ú
fÚ
kr¬r®
Ú
yÚ
zÚ
gÚ
jrqÚ
eÚ
qÚ
r)!éøi
i'
i1
iB
ig
i€
iƒ
iˆ
iŒ
i’
i™
iš
iž
i¥
i«
i­
i´
i¶
iå
i%i4i5i6i7i<i?i@iGiIiKiMiOÚszZaeZoeÚdbZqp)éßéæiS
i8i9cCs&|d
j|
ƒ

|dj
|
ƒ

d|_dS)Nr›ršra)rrÔrú)r_rµrrrr>

	s

r>
c

Csd
j|j
ƒjƒƒ
S)z.Return a case- and whitespace-normalized name.r¢)ryr rz)
rµrrrrX
	srX
c

Csd
j|j
ƒƒ
S)z$Return a whitespace-normalized name.r¢)ryrz)
rµrrrrV
	srV
c

Cs|jd
dƒjddƒS)zDEscape string values that are elements of a list, for serialization.rtz\\r¢z\ )
rx)
r*rrrr£	sr£c

Csd
|S)zQuote attributes for pseudo-xmlz"%s"r)
r*rrrr²	sr²)rr
)rr
)FF)«rgÚ
__future__rÚcollectionsrZ
__docformat__rjÚosÚrer	rá
rkr¿r,r¸rrÚobjectr%rmrrr}r~r—r
r
r
r
r
r	
r

r
r
r

r
r
r
r
r
r
r
r
r
r
r
r(rd
re
rf
rg
rh
ri
rj
rk
rl
rm
rn
ro
rp
rq
r,
rr
rt
rv
rw
rx
ry
rz
r{
r|
r}
r~
r
r€
r
r‚
rƒ
r„
r…
r†
r‡
rˆ
r‰
rŠ
rŒ
r
rŽ
r
r
r‘
r’
r“
r”
r@r•
r–
r—
r˜
r™
rW
rš
r›
rœ
r
rž
rŸ
r 
r¡
rC
rK
rS
r¢
r£
r¤
r¥
r¦
r§
r¨
r©
rª
r«
r¬
r?
r[
r²
r³
r´
rµ
r¶
r·
r¸
r¹
rº
r»
r¼
r½
r¾
r¿
rÀ
rÁ
rÂ
rÃ
rzZnode_class_namesrÄ
rÍ
rÎ
rÑ
rÒ
rÓ
rÖ
r×
Ú	ExceptionrÚ
rHrMrIrJrÛ
rNr4
Úcompilerã
rå
rà
rß
r>
rX
rV
r£r²rrrrÚ<module>s¤








 )
	S

	e



























































H














"
]






1