
    Mh[                     t   d Z ddlmZ ddlmZmZmZ  G d d          Z G d de          Z G d	 d
e          Z	 G d de          Z
 G d de          Z G d de          Z G d de          Z G d de          Z G d de          Z G d de          Z G d de          Z G d de          Z G d de          Z G d d e          Z G d! d"e          Z G d# d$e          Z G d% d&e          Z G d' d(e          Z G d) d*e          Z G d+ d,e          Z G d- d.e          Zd/S )0z5

Data structures for the CSS abstract syntax tree.

    )ascii_lower   )_serialize_toserialize_identifierserialize_namec                   2    e Zd ZdZddgZd Zd Zd Zd ZdS )	Nodea  Every node type inherits from this class,
    which is never instantiated directly.

    .. attribute:: type

        Each child class has a :attr:`type` class attribute
        with a unique string value.
        This allows checking for the node type with code like:

        .. code-block:: python

            if node.type == 'whitespace':

        instead of the more verbose:

        .. code-block:: python

            from tinycss2.ast import WhitespaceToken
            if isinstance(node, WhitespaceToken):

    Every node also has these attributes and methods,
    which are not repeated for brevity:

    .. attribute:: source_line

        The line number of the start of the node in the CSS source.
        Starts at 1.

    .. attribute:: source_column

        The column number within :attr:`source_line` of the start of the node
        in the CSS source.
        Starts at 1.

    .. automethod:: serialize

    source_linesource_columnc                 "    || _         || _        d S N)r
   r   )selfr
   r   s      L/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/tinycss2/ast.py__init__zNode.__init__5   s    &*    c                 8    | j                             |           S )Nr   )repr_formatformatr   s    r   __repr__zNode.__repr__9   s    &&D&111r   c                 d    g }|                      |j                   d                    |          S )z>Serialize this node to CSS syntax and return a Unicode string. )r   appendjoin)r   chunkss     r   	serializezNode.serialize<   s-    6=)))wwvr   c                     t           )zSerialize this node to CSS syntax, writing chunks as Unicode string
        by calling the provided :obj:`write` callback.

        )NotImplementedErrorr   writes     r   r   zNode._serialize_toB   s
    
 "!r   N)	__name__
__module____qualname____doc__	__slots__r   r   r   r    r   r   r	   r	      sg        $ $J 0I+ + +2 2 2  " " " " "r   r	   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	
ParseErrora  A syntax error of some sort. May occur anywhere in the tree.

    Syntax errors are not fatal in the parser
    to allow for different error handling behaviors.
    For example, an error in a Selector list makes the whole rule invalid,
    but an error in a Media Query list only replaces one comma-separated query
    with ``not all``.

    .. autoattribute:: type

    .. attribute:: kind

        Machine-readable string indicating the type of error.
        Example: ``'bad-url'``.

    .. attribute:: message

        Human-readable explanation of the error, as a string.
        Could be translated, expanded to include details, etc.

    kindmessageerrorz'<{self.__class__.__name__} {self.kind}>c                 Z    t                               | ||           || _        || _        d S r   )r	   r   r)   r*   )r   linecolumnr)   r*   s        r   r   zParseError.__init__d   s*    dD&)))	r   c                     | j         dk    r |d           d S | j         dk    r |d           d S | j         dv r || j                    d S | j         dv rd S t          d| z            )Nz
bad-stringz"[bad string]
zbad-urlzurl([bad url])z)]})eof-in-stringz
eof-in-urlzCan not serialize %r)r)   	TypeErrorr   s     r   r   zParseError._serialize_toi   s    9$$E#$$$$$Y)##E"#####Y%E$)Y999D2T9:::r   N	r!   r"   r#   r$   r%   typer   r   r   r&   r   r   r(   r(   J   sR         * #ID;K  

; 
; 
; 
; 
;r   r(   c                   ,    e Zd ZdZdgZdZdZd Zd ZdS )Commenta  A CSS comment.

    Comments can be ignored by passing ``skip_comments=True``
    to functions such as :func:`~tinycss2.parse_component_value_list`.

    .. autoattribute:: type

    .. attribute:: value

        The content of the comment, between ``/*`` and ``*/``, as a string.

    valuecomment(<{self.__class__.__name__} {self.value}>c                 L    t                               | ||           || _        d S r   r	   r   r6   r   r-   r.   r6   s       r   r   zComment.__init__   #    dD&)))


r   c                 R     |d            || j                     |d           d S )Nz/*z*/r6   r   s     r   r   zComment._serialize_to   s2    ddjdr   Nr2   r&   r   r   r5   r5   v   sO          	ID<K      r   r5   c                   ,    e Zd ZdZdgZdZdZd Zd ZdS )WhitespaceTokenzA :diagram:`whitespace-token`.

    .. autoattribute:: type

    .. attribute:: value

        The whitespace sequence, as a string, as in the original CSS source.


    r6   
whitespacez<{self.__class__.__name__}>c                 L    t                               | ||           || _        d S r   r:   r;   s       r   r   zWhitespaceToken.__init__   r<   r   c                 &     || j                    d S r   r>   r   s     r   r   zWhitespaceToken._serialize_to       djr   Nr2   r&   r   r   r@   r@      sO        	 	 	ID/K      r   r@   c                   8    e Zd ZdZdgZdZdZd Zd Zd Z	d Z
d	S )
LiteralTokena  Token that represents one or more characters as in the CSS source.

    .. autoattribute:: type

    .. attribute:: value

        A string of one to four characters.

    Instances compare equal to their :attr:`value`,
    so that these are equivalent:

    .. code-block:: python

        if node == ';':
        if node.type == 'literal' and node.value == ';':

    This regroups what `the specification`_ defines as separate token types:

    .. _the specification: https://drafts.csswg.org/css-syntax-3/

    * *<colon-token>* ``:``
    * *<semicolon-token>* ``;``
    * *<comma-token>* ``,``
    * *<cdc-token>* ``-->``
    * *<cdo-token>* ``<!--``
    * *<include-match-token>* ``~=``
    * *<dash-match-token>* ``|=``
    * *<prefix-match-token>* ``^=``
    * *<suffix-match-token>* ``$=``
    * *<substring-match-token>* ``*=``
    * *<column-token>* ``||``
    * *<delim-token>* (a single ASCII character not part of any another token)

    r6   literalr8   c                 L    t                               | ||           || _        d S r   r:   r;   s       r   r   zLiteralToken.__init__   r<   r   c                      | j         |k    p| |u S r   r>   r   others     r   __eq__zLiteralToken.__eq__   s    zU"3dem3r   c                     | |k     S r   r&   rJ   s     r   __ne__zLiteralToken.__ne__   s    5=  r   c                 &     || j                    d S r   r>   r   s     r   r   zLiteralToken._serialize_to   rD   r   N)r!   r"   r#   r$   r%   r3   r   r   rL   rN   r   r&   r   r   rF   rF      sn        ! !D 	ID<K  4 4 4! ! !    r   rF   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	
IdentTokena`  An :diagram:`ident-token`.

    .. autoattribute:: type

    .. attribute:: value

        The unescaped value, as a Unicode string.

    .. attribute:: lower_value

        Same as :attr:`value` but normalized to *ASCII lower case*,
        see :func:`~webencodings.ascii_lower`.
        This is the value to use when comparing to a CSS keyword.

    r6   lower_valueidentr8   c                     t                               | ||           || _        	 t          |          | _        d S # t
          $ r || _        Y d S w xY wr   r	   r   r6   r   rR   UnicodeEncodeErrorr;   s       r   r   zIdentToken.__init__   f    dD&)))
	%*511D! 	% 	% 	%$D	%   ; AAc                 @     |t          | j                             d S r   r   r6   r   s     r   r   zIdentToken._serialize_to   s#    "4:../////r   Nr2   r&   r   r   rQ   rQ      sR          -(ID<K% % %0 0 0 0 0r   rQ   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	AtKeywordTokena   An :diagram:`at-keyword-token`.

    .. code-block:: text

        '@' <value>

    .. autoattribute:: type

    .. attribute:: value

        The unescaped value, as a Unicode string, without the preceding ``@``.

    .. attribute:: lower_value

        Same as :attr:`value` but normalized to *ASCII lower case*,
        see :func:`~webencodings.ascii_lower`.
        This is the value to use when comparing to a CSS at-keyword.

        .. code-block:: python

            if node.type == 'at-keyword' and node.lower_value == 'import':

    r6   rR   z
at-keywordz)<{self.__class__.__name__} @{self.value}>c                     t                               | ||           || _        	 t          |          | _        d S # t
          $ r || _        Y d S w xY wr   rU   r;   s       r   r   zAtKeywordToken.__init__  rW   rX   c                 V     |d            |t          | j                             d S )N@rZ   r   s     r   r   zAtKeywordToken._serialize_to!  s0    c


"4:../////r   Nr2   r&   r   r   r\   r\      sR         . -(ID=K% % %0 0 0 0 0r   r\   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )		HashTokena  A :diagram:`hash-token`.

    .. code-block:: text

        '#' <value>

    .. autoattribute:: type

    .. attribute:: value

        The unescaped value, as a Unicode string, without the preceding ``#``.

    .. attribute:: is_identifier

        A boolean, true if the CSS source for this token
        was ``#`` followed by a valid identifier.
        (Only such hash tokens are valid ID selectors.)

    r6   is_identifierhashz)<{self.__class__.__name__} #{self.value}>c                 Z    t                               | ||           || _        || _        d S r   )r	   r   r6   rb   )r   r-   r.   r6   rb   s        r   r   zHashToken.__init__>  s-    dD&)))
*r   c                      |d           | j         r |t          | j                             d S  |t          | j                             d S )N#)rb   r   r6   r   r   s     r   r   zHashToken._serialize_toC  s[    c


 	.E&tz2233333E.,,-----r   Nr2   r&   r   r   ra   ra   &  sR         & /*ID=K+ + +
. . . . .r   ra   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	StringTokenzA :diagram:`string-token`.

    .. code-block:: text

        '"' <value> '"'

    .. autoattribute:: type

    .. attribute:: value

        The unescaped value, as a Unicode string, without the quotes.

    r6   representationstring1<{self.__class__.__name__} {self.representation}>c                 Z    t                               | ||           || _        || _        d S r   r	   r   r6   ri   r   r-   r.   r6   ri   s        r   r   zStringToken.__init__]  -    dD&)))
,r   c                 &     || j                    d S r   ri   r   s     r   r   zStringToken._serialize_tob      d!"""""r   Nr2   r&   r   r   rh   rh   K  sS          *+IDEK- - -
# # # # #r   rh   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	URLTokenzAn :diagram:`url-token`.

    .. code-block:: text

        'url(' <value> ')'

    .. autoattribute:: type

    .. attribute:: value

        The unescaped URL, as a Unicode string, without the ``url(`` and ``)``
        markers.

    r6   ri   urlrk   c                 Z    t                               | ||           || _        || _        d S r   rm   rn   s        r   r   zURLToken.__init__y  ro   r   c                 &     || j                    d S r   rq   r   s     r   r   zURLToken._serialize_to~  rr   r   Nr2   r&   r   r   rt   rt   f  sS          *+IDEK- - -
# # # # #r   rt   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	UnicodeRangeTokenaF  A :diagram:`unicode-range-token`.

    .. autoattribute:: type

    .. attribute:: start

        The start of the range, as an integer between 0 and 1114111.

    .. attribute:: end

        The end of the range, as an integer between 0 and 1114111.
        Same as :attr:`start` if the source only specified one value.

    startendzunicode-rangez3<{self.__class__.__name__} {self.start} {self.end}>c                 Z    t                               | ||           || _        || _        d S r   )r	   r   rz   r{   )r   r-   r.   rz   r{   s        r   r   zUnicodeRangeToken.__init__  s*    dD&)))
r   c                     | j         | j        k    r |d| j        z             d S  |d| j        | j         fz             d S )NzU+%XzU+%X-%X)r{   rz   r   s     r   r   zUnicodeRangeToken._serialize_to  sR    8tz!!E&4:%&&&&&E)tz484455555r   Nr2   r&   r   r   ry   ry     sR          % IDGK  
6 6 6 6 6r   ry   c                   .    e Zd ZdZg dZdZdZd Zd ZdS )NumberTokena  A :diagram:`number-token`.

    .. autoattribute:: type

    .. attribute:: value

        The numeric value as a :class:`float`.

    .. attribute:: int_value

        The numeric value as an :class:`int`
        if :attr:`is_integer` is true, :obj:`None` otherwise.

    .. attribute:: is_integer

        Whether the token was syntactically an integer, as a boolean.

    .. attribute:: representation

        The CSS representation of the value, as a Unicode string.

    r6   	int_value
is_integerri   numberrk   c                 z    t                               | ||           || _        || _        |d u| _        || _        d S r   r	   r   r6   r   r   ri   r   r-   r.   r6   r   ri   s         r   r   zNumberToken.__init__  @    dD&)))
"#4/,r   c                 &     || j                    d S r   rq   r   s     r   r   zNumberToken._serialize_to  rr   r   Nr2   r&   r   r   r   r     sT         , GFFIDEK- - -# # # # #r   r   c                   .    e Zd ZdZg dZdZdZd Zd ZdS )PercentageTokenuI  A :diagram:`percentage-token`.

    .. code-block:: text

        <representation> '%'

    .. autoattribute:: type

    .. attribute:: value

        The value numeric as a :class:`float`.

    .. attribute:: int_value

        The numeric value as an :class:`int`
        if the token was syntactically an integer,
        or :obj:`None`.

    .. attribute:: is_integer

        Whether the token’s value was syntactically an integer, as a boolean.

    .. attribute:: representation

        The CSS representation of the value without the unit,
        as a Unicode string.

    r   
percentagez2<{self.__class__.__name__} {self.representation}%>c                 z    t                               | ||           || _        || _        |d u| _        || _        d S r   r   r   s         r   r   zPercentageToken.__init__  r   r   c                 <     || j                     |d           d S )N%rq   r   s     r   r   zPercentageToken._serialize_to  s&    d!"""c




r   Nr2   r&   r   r   r   r     sT         8 GFFIDFK- - -    r   r   c                   .    e Zd ZdZg dZdZdZd Zd ZdS )DimensionTokenu  A :diagram:`dimension-token`.

    .. code-block:: text

        <representation> <unit>

    .. autoattribute:: type

    .. attribute:: value

        The value numeric as a :class:`float`.

    .. attribute:: int_value

        The numeric value as an :class:`int`
        if the token was syntactically an integer,
        or :obj:`None`.

    .. attribute:: is_integer

        Whether the token’s value was syntactically an integer, as a boolean.

    .. attribute:: representation

        The CSS representation of the value without the unit,
        as a Unicode string.

    .. attribute:: unit

        The unescaped unit, as a Unicode string.

    .. attribute:: lower_unit

        Same as :attr:`unit` but normalized to *ASCII lower case*,
        see :func:`~webencodings.ascii_lower`.
        This is the value to use when comparing to a CSS unit.

        .. code-block:: python

            if node.type == 'dimension' and node.lower_unit == 'px':

    )r6   r   r   ri   unit
lower_unit	dimensionz<<{self.__class__.__name__} {self.representation}{self.unit}>c                     t                               | ||           || _        || _        |d u| _        || _        || _        t          |          | _        d S r   )	r	   r   r6   r   r   ri   r   r   r   )r   r-   r.   r6   r   ri   r   s          r   r   zDimensionToken.__init__%  sT    dD&)))
"#4/,	%d++r   c                      || j                    | j        }|dv s|                    d          r- |d            |t          |dd                               d S  |t	          |                     d S )N)eE)ze-zE-z\65 r   )ri   r   
startswithr   r   )r   r    r   s      r   r   zDimensionToken._serialize_to.  s    d!"""y:!>!>E'NNNE.abb**+++++E&t,,-----r   Nr2   r&   r   r   r   r     sZ        ) )T' ' 'ID7K, , ,. . . . .r   r   c                   ,    e Zd ZdZdgZdZdZd Zd ZdS )ParenthesesBlocka"  A :diagram:`()-block`.

    .. code-block:: text

        '(' <content> ')'

    .. autoattribute:: type

    .. attribute:: content

        The content of the block, as list of :term:`component values`.
        The ``(`` and ``)`` markers themselves are not represented in the list.

    contentz() blocku#   <{self.__class__.__name__} ( … )>c                 L    t                               | ||           || _        d S r   r	   r   r   r   r-   r.   r   s       r   r   zParenthesesBlock.__init__L  #    dD&)))r   c                 \     |d           t          | j        |            |d           d S )N()r   r   r   s     r   r   zParenthesesBlock._serialize_toP  2    c


dlE***c




r   Nr2   r&   r   r   r   r   9  O          ID7K      r   r   c                   ,    e Zd ZdZdgZdZdZd Zd ZdS )SquareBracketsBlocka"  A :diagram:`[]-block`.

    .. code-block:: text

        '[' <content> ']'

    .. autoattribute:: type

    .. attribute:: content

        The content of the block, as list of :term:`component values`.
        The ``[`` and ``]`` markers themselves are not represented in the list.

    r   z[] blocku#   <{self.__class__.__name__} [ … ]>c                 L    t                               | ||           || _        d S r   r   r   s       r   r   zSquareBracketsBlock.__init__i  r   r   c                 \     |d           t          | j        |            |d           d S )N[]r   r   s     r   r   z!SquareBracketsBlock._serialize_tom  r   r   Nr2   r&   r   r   r   r   V  r   r   r   c                   ,    e Zd ZdZdgZdZdZd Zd ZdS )CurlyBracketsBlocka"  A :diagram:`{}-block`.

    .. code-block:: text

        '{' <content> '}'

    .. autoattribute:: type

    .. attribute:: content

        The content of the block, as list of :term:`component values`.
        The ``[`` and ``]`` markers themselves are not represented in the list.

    r   z{} blocku%   <{self.__class__.__name__} {{ … }}>c                 L    t                               | ||           || _        d S r   r   r   s       r   r   zCurlyBracketsBlock.__init__  r   r   c                 \     |d           t          | j        |            |d           d S N{}r   r   s     r   r   z CurlyBracketsBlock._serialize_to  r   r   Nr2   r&   r   r   r   r   s  sO          ID9K      r   r   c                   .    e Zd ZdZg dZdZdZd Zd ZdS )FunctionBlocka  A :diagram:`function-block`.

    .. code-block:: text

        <name> '(' <arguments> ')'

    .. autoattribute:: type

    .. attribute:: name

        The unescaped name of the function, as a Unicode string.

    .. attribute:: lower_name

        Same as :attr:`name` but normalized to *ASCII lower case*,
        see :func:`~webencodings.ascii_lower`.
        This is the value to use when comparing to a CSS function name.

    .. attribute:: arguments

        The arguments of the function, as list of :term:`component values`.
        The ``(`` and ``)`` markers themselves are not represented in the list.
        Commas are not special, but represented as :obj:`LiteralToken` objects
        in the list.

    )name
lower_name	argumentsfunctionu.   <{self.__class__.__name__} {self.name}( … )>c                     t                               | ||           || _        t          |          | _        || _        d S r   )r	   r   r   r   r   r   )r   r-   r.   r   r   s        r   r   zFunctionBlock.__init__  s9    dD&)))	%d++"r   c                     |t          | j                              |d           t          | j        |           | }t	          |t
                    rj|j        rct	          |j        d         t                    o|j        d         j        dk    }|rd S |j        d         }t	          |t
                    r|j        c |d           d S )Nr   r0   r   )r   r   r   r   
isinstancer   r(   r)   )r   r    r   eof_in_strings       r   r   zFunctionBlock._serialize_to  s    "49--...c


dne,,,=11 	.h6H 	.8-b1:>> ?"2&+>   )"-H =11 	.h6H 	. 	c




r   Nr2   r&   r   r   r   r     sS         4 433IDBK# # #    r   r   c                   .    e Zd ZdZg dZdZdZd Zd ZdS )Declarationa  A (property or descriptor) :diagram:`declaration`.

    .. code-block:: text

        <name> ':' <value>
        <name> ':' <value> '!important'

    .. autoattribute:: type

    .. attribute:: name

        The unescaped name, as a Unicode string.

    .. attribute:: lower_name

        Same as :attr:`name` but normalized to *ASCII lower case*,
        see :func:`~webencodings.ascii_lower`.
        This is the value to use when comparing to
        a CSS property or descriptor name.

        .. code-block:: python

            if node.type == 'declaration' and node.lower_name == 'color':

    .. attribute:: value

        The declaration value as a list of :term:`component values`:
        anything between ``:`` and
        the end of the declaration, or ``!important``.

    .. attribute:: important

        A boolean, true if the declaration had an ``!important`` marker.
        It is up to the consumer to reject declarations that do not accept
        this flag, such as non-property descriptor declarations.

    )r   r   r6   	importantdeclarationu,   <{self.__class__.__name__} {self.name}: …>c                 v    t                               | ||           || _        || _        || _        || _        d S r   )r	   r   r   r   r6   r   )r   r-   r.   r   r   r6   r   s          r   r   zDeclaration.__init__  s8    dD&)))	$
"r   c                      |t          | j                              |d           t          | j        |           | j        r |d           d S d S )N:z
!important)r   r   r   r6   r   r   s     r   r   zDeclaration._serialize_to  sf    "49--...c


dj%(((> 	 E,	  	 r   Nr2   r&   r   r   r   r     sT        $ $J =<<ID@K# # #         r   r   c                   .    e Zd ZdZddgZdZdZd Zd ZdS )	QualifiedRuleu  A :diagram:`qualified rule`.

    .. code-block:: text

        <prelude> '{' <content> '}'

    The interpretation of qualified rules depend on their context.
    At the top-level of a stylesheet
    or in a conditional rule such as ``@media``,
    they are **style rules** where the :attr:`prelude` is Selectors list
    and the :attr:`content` is a list of property declarations.

    .. autoattribute:: type

    .. attribute:: prelude

        The rule’s prelude, the part before the {} block,
        as a list of :term:`component values`.

    .. attribute:: content

        The rule’s content, the part inside the {} block,
        as a list of :term:`component values`.

    preluder   zqualified-ruleu)   <{self.__class__.__name__} … {{ … }}>c                 Z    t                               | ||           || _        || _        d S r   )r	   r   r   r   )r   r-   r.   r   r   s        r   r   zQualifiedRule.__init__  s*    dD&)))r   c                     t          | j        |            |d           t          | j        |            |d           d S r   )r   r   r   r   s     r   r   zQualifiedRule._serialize_to!  sD    dlE***c


dlE***c




r   Nr2   r&   r   r   r   r     sT         2 I&ID$K  
    r   r   c                   .    e Zd ZdZg dZdZdZd Zd ZdS )AtRuleu  An :diagram:`at-rule`.

    .. code-block:: text

        @<at_keyword> <prelude> '{' <content> '}'
        @<at_keyword> <prelude> ';'

    The interpretation of at-rules depend on their at-keyword
    as well as their context.
    Most types of at-rules (ie. at-keyword values)
    are only allowed in some context,
    and must either end with a {} block or a semicolon.

    .. autoattribute:: type

    .. attribute:: at_keyword

        The unescaped value of the rule’s at-keyword,
        without the ``@`` symbol, as a Unicode string.

    .. attribute:: lower_at_keyword

        Same as :attr:`at_keyword` but normalized to *ASCII lower case*,
        see :func:`~webencodings.ascii_lower`.
        This is the value to use when comparing to a CSS at-keyword.

        .. code-block:: python

            if node.type == 'at-rule' and node.lower_at_keyword == 'import':

    .. attribute:: prelude

        The rule’s prelude, the part before the {} block or semicolon,
        as a list of :term:`component values`.

    .. attribute:: content

        The rule’s content, if any.
        The block’s content as a list of :term:`component values`
        for at-rules with a {} block,
        or :obj:`None` for at-rules ending with a semicolon.

    )
at_keywordlower_at_keywordr   r   zat-ruleu<   <{self.__class__.__name__} @{self.at_keyword} … {{ … }}>c                 v    t                               | ||           || _        || _        || _        || _        d S r   )r	   r   r   r   r   r   )r   r-   r.   r   r   r   r   s          r   r   zAtRule.__init__Y  s9    dD&)))$ 0r   c                      |d            |t          | j                             t          | j        |           | j         |d           d S  |d           t          | j        |            |d           d S )Nr_   ;r   r   )r   r   r   r   r   r   s     r   r   zAtRule._serialize_toa  s    c


"4?33444dlE***<E#JJJJJE#JJJ$,...E#JJJJJr   Nr2   r&   r   r   r   r   (  sW        * *V IHHID7K  	 	 	 	 	r   r   N)r$   webencodingsr   
serializerr   r   r   r	   r(   r5   r@   rF   rQ   r\   ra   rh   rt   ry   r   r   r   r   r   r   r   r   r   r   r&   r   r   <module>r      s    % $ $ $ $ $ K K K K K K K K K K:" :" :" :" :" :" :" :"z); ); ); ); ); ); ); );X    d   6    d   .2 2 2 2 24 2 2 2j0 0 0 0 0 0 0 0@&0 &0 &0 &0 &0T &0 &0 &0R". ". ". ". ". ". ". ".J# # # # #$ # # #6# # # # #t # # #86 6 6 6 6 6 6 6>## ## ## ## ##$ ## ## ##L* * * * *d * * *ZB. B. B. B. B.T B. B. B.J    t   :    $   :       :1 1 1 1 1D 1 1 1h6  6  6  6  6 $ 6  6  6 r( ( ( ( (D ( ( (VB B B B BT B B B B Br   