403WebShell

403Webshell
Server IP : 93.86.61.54 / Your IP : 216.73.216.60
Web Server : Apache/2.4.62 (Ubuntu)
System : Linux rasin.ddns.net 6.8.0-124-generic #124~22.04.1-Ubuntu SMP PREEMPT_DYNAMIC Tue May 26 21:05:19 UTC x86_64
User : www-data ( 33)
PHP Version : 8.4.22
Disable Function : NONE
MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON
Directory : /usr/lib/python3/dist-packages/tinycss/__pycache__/
Upload File :
[ Back ]
Current File : /usr/lib/python3/dist-packages/tinycss/__pycache__/css21.cpython-310.pyc
o

�9�W�q�@s�dZddlmZddlmZmZddlmZddlm	Z	m
Z
mZmZm
Z
mZddlmZddlmZGd	d
�d
e�ZGdd�de�ZGd
d�de�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de�Zdd�ZGdd�de�ZdS)z�
    tinycss.css21
    -------------

    Parser for CSS 2.1
    http://www.w3.org/TR/CSS21/syndata.html

    :copyright: (c) 2012 by Simon Sapin.
    :license: BSD, see LICENSE for more details.
�)�unicode_literals)�chain�islice�)�decode)�
ParseError�remove_whitespace�split_on_comma�strip_whitespace�validate_any�validate_value)�	TokenList)�tokenize_groupedc@� eZdZdZdd�Zdd�ZdS)�
Stylesheetal
    A parsed CSS stylesheet.

    .. attribute:: rules

        A mixed list, in source order, of :class:`RuleSet` and various
        at-rules such as :class:`ImportRule`, :class:`MediaRule`
        and :class:`PageRule`.
        Use their :obj:`at_keyword` attribute to distinguish them.

    .. attribute:: errors

        A list of :class:`~.parsing.ParseError`. Invalid rules and declarations
        are ignored, with the details logged in this list.

    .. attribute:: encoding

        The character encoding that was used to decode the stylesheet
        from bytes, or ``None`` for Unicode stylesheets.

    cCs||_||_||_dS�N)�rules�errors�encoding)�selfrrr�r�//usr/lib/python3/dist-packages/tinycss/css21.py�__init__@s
zStylesheet.__init__cCsd�|t|j�t|j��S)Nz-<{0.__class__.__name__} {1} rules {2} errors>)�format�lenrr�rrrr�__repr__Es�zStylesheet.__repr__N��__name__�
__module__�__qualname__�__doc__rrrrrrr*src@r)�AtRulea�
    An unparsed at-rule.

    .. attribute:: at_keyword

        The normalized (lower-case) at-keyword as a string. Eg: ``'@page'``

    .. attribute:: head

        The part of the at-rule between the at-keyword and the ``{``
        marking the body, or the ``;`` marking the end of an at-rule without
        a body.  A :class:`~.token_data.TokenList`.

    .. attribute:: body

        The content of the body between ``{`` and ``}`` as a
        :class:`~.token_data.TokenList`, or ``None`` if there is no body
        (ie. if the rule ends with ``;``).

    The head was validated against the core grammar but **not** the body,
    as the body might contain declarations. In case of an error in a
    declaration, parsing should continue from the next declaration.
    The whole rule should not be ignored as it would be for an error
    in the head.

    These at-rules are expected to be parsed further before reaching
    the user API.

    cCs6||_t|�|_|durt|�n||_||_||_dSr)�
at_keywordr
�head�body�line�column)rr#r$r%r&r'rrrrhs


zAtRule.__init__cC�
d�|�S)Nz;<{0.__class__.__name__} {0.line}:{0.column} {0.at_keyword}>�rrrrrro��zAtRule.__repr__Nrrrrrr"Jsr"c@s$eZdZdZdZdd�Zdd�ZdS)�RuleSeta�A ruleset.

    .. attribute:: at_keyword

        Always ``None``. Helps to tell rulesets apart from at-rules.

    .. attribute:: selector

        The selector as a :class:`~.token_data.TokenList`.
        In CSS 3, this is actually called a selector group.

        ``rule.selector.as_css()`` gives the selector as a string.
        This string can be used with *cssselect*, see :ref:`selectors3`.

    .. attribute:: declarations

        The list of :class:`Declaration`, in source order.

    NcCs t|�|_||_||_||_dSr)r
�selector�declarationsr&r')rr,r-r&r'rrrr�s

zRuleSet.__init__cCsd�||j���S)Nz3<{0.__class__.__name__} at {0.line}:{0.column} {1}>)rr,�as_cssrrrrr�s�zRuleSet.__repr__�rrr r!r#rrrrrrr+ts
r+c@r)�Declarationa�A property declaration.

    .. attribute:: name

        The property name as a normalized (lower-case) string.

    .. attribute:: value

        The property value as a :class:`~.token_data.TokenList`.

        The value is not parsed. UAs using tinycss may only support
        some properties or some values and tinycss does not know which.
        They need to parse values themselves and ignore declarations with
        unknown or unsupported properties or values, and fall back
        on any previous declaration.

        :mod:`tinycss.color3` parses color values, but other values
        will need specific parsing/validation code.

    .. attribute:: priority

        Either the string ``'important'`` or ``None``.

    cCs&||_t|�|_||_||_||_dSr)�namer
�value�priorityr&r')rr1r2r3r&r'rrrr�s


zDeclaration.__init__cCs(|jrd|jnd}d�||j��|�S)Nz !�z=<{0.__class__.__name__} {0.line}:{0.column} {0.name}: {1}{2}>)r3rr2r.)rr3rrrr�s��zDeclaration.__repr__Nrrrrrr0�sr0c@�$eZdZdZdZdd�Zdd�ZdS)�PageRulea�A parsed CSS 2.1 @page rule.

    .. attribute:: at_keyword

        Always ``'@page'``

    .. attribute:: selector

        The page selector.
        In CSS 2.1 this is either ``None`` (no selector), or the string
        ``'first'``, ``'left'`` or ``'right'`` for the pseudo class
        of the same name.

    .. attribute:: specificity

        Specificity of the page selector. This is a tuple of four integers,
        but these tuples are mostly meant to be compared to each other.

    .. attribute:: declarations

        A list of :class:`Declaration`, in source order.

    .. attribute:: at_rules

        The list of parsed at-rules inside the @page block, in source order.
        Always empty for CSS 2.1.

    �@pagecCs(||_||_||_||_||_||_dSr)r,�specificityr-�at_rulesr&r')rr,r8r-r9r&r'rrrr�s
zPageRule.__init__cCr()Nz9<{0.__class__.__name__} {0.line}:{0.column} {0.selector}>r)rrrrr�r*zPageRule.__repr__Nr/rrrrr6�s
	r6c@r5)�	MediaRuleaOA parsed @media rule.

    .. attribute:: at_keyword

        Always ``'@media'``

    .. attribute:: media

        For CSS 2.1 without media queries: the media types
        as a list of strings.

    .. attribute:: rules

        The list :class:`RuleSet` and various at-rules inside the @media
        block, in source order.

    �@mediacC�||_||_||_||_dSr)�mediarr&r')rr=rr&r'rrrr��
zMediaRule.__init__cCr()Nz6<{0.__class__.__name__} {0.line}:{0.column} {0.media}>r)rrrrrr*zMediaRule.__repr__Nr/rrrrr:�s
r:c@r5)�
ImportRulea�A parsed @import rule.

    .. attribute:: at_keyword

        Always ``'@import'``

    .. attribute:: uri

        The URI to be imported, as read from the stylesheet.
        (URIs are not made absolute.)

    .. attribute:: media

        For CSS 2.1 without media queries: the media types
        as a list of strings.
        This attribute is explicitly ``['all']`` if the media was omitted
        in the source.

    �@importcCr<r)�urir=r&r')rrAr=r&r'rrrrr>zImportRule.__init__cCr()Nz4<{0.__class__.__name__} {0.line}:{0.column} {0.uri}>r)rrrrr%r*zImportRule.__repr__Nr/rrrrr?	s
r?cCsft|�}tt|d��}dd�|D�gd�kr.|\}}}}|j|jfdkr.|��ddkr.|St||�S)z�Remove any valid @charset at the beggining of a token stream.

    :param tokens:
        An iterable of tokens
    :returns:
        A possibly truncated iterable of tokens

    �cS�g|]}|j�qSr��type)�.0�trrr�
<listcomp>5�z&_remove_at_charset.<locals>.<listcomp>)�	ATKEYWORD�S�STRING�;)�@charset� r�")�iter�listrr2r.r)�tokens�header�atkw�space�string�	semicolonrrr�_remove_at_charset*s	
rYc@s�eZdZdZ		ddd�Z		ddd�Zd dd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�ZdS)!�CSS21ParserarParser for CSS 2.1

    This parser supports the core CSS syntax as well as @import, @media,
    @page and !important.

    Note that property values are still not parsed, as UAs using this
    parser may only support some properties or some values.

    Currently the parser holds no state. It being a class only allows
    subclassing and overriding its methods.

    NcCsVt|d�r
|��}nt|d��}|��}Wd�n1swY|�||||�S)a]Parse a stylesheet from a file or filename.

        Character encoding-related parameters and behavior are the same
        as in :meth:`parse_stylesheet_bytes`.

        :param css_file:
            Either a file (any object with a :meth:`~file.read` method)
            or a filename.
        :return:
            A :class:`Stylesheet`.

        �read�rbN)�hasattrr[�open�parse_stylesheet_bytes)r�css_file�protocol_encoding�linking_encoding�document_encoding�	css_bytes�fdrrr�parse_stylesheet_fileNs


��z!CSS21Parser.parse_stylesheet_filecCs t||||�\}}|j||d�S)aNParse a stylesheet from a byte string.

        The character encoding is determined from the passed metadata and the
        ``@charset`` rule in the stylesheet (if any).
        If no encoding information is available or decoding fails,
        decoding defaults to UTF-8 and then fall back on ISO-8859-1.

        :param css_bytes:
            A CSS stylesheet as a byte string.
        :param protocol_encoding:
            The "charset" parameter of a "Content-Type" HTTP header (if any),
            or similar metadata for other protocols.
        :param linking_encoding:
            ``<link charset="">`` or other metadata from the linking mechanism
            (if any)
        :param document_encoding:
            Encoding of the referring style sheet or document (if any)
        :return:
            A :class:`Stylesheet`.

        )r)r�parse_stylesheet)rrdrarbrc�css_unicoderrrrr_ds�z"CSS21Parser.parse_stylesheet_bytescCs2t|�}|r
t|�}|j|dd�\}}t|||�S)a2Parse a stylesheet from an Unicode string.

        :param css_unicode:
            A CSS stylesheet as an unicode string.
        :param encoding:
            The character encoding used to decode the stylesheet from bytes,
            if any.
        :return:
            A :class:`Stylesheet`.

        �
stylesheet)�context)rrY�parse_rulesr)rrhrrSrrrrrrgs
zCSS21Parser.parse_stylesheetcCs|�t|��S)a�Parse a "style" attribute (eg. of an HTML element).

        This method only accepts Unicode as the source (HTML) document
        is supposed to handle the character encoding.

        :param css_source:
            The attribute value, as an unicode string.
        :return:
            A tuple of the list of valid :class:`Declaration` and
            a list of :class:`~.parsing.ParseError`.
        )�parse_declaration_listr)r�
css_sourcerrr�parse_style_attr�szCSS21Parser.parse_style_attrc
Cs�g}g}t|�}|D]L}|jdvrVz-|jdkr+|�||�}|�||||�}|�|�n|�||�\}}|�|�|�|�Wq
tyU}	z|�|	�WYd}	~	q
d}	~	wwq
||fS)a�Parse a sequence of rules (rulesets and at-rules).

        :param tokens:
            An iterable of tokens.
        :param context:
            Either ``'stylesheet'`` or an at-keyword such as ``'@media'``.
            (Most at-rules are only allowed in some contexts.)
        :return:
            A tuple of a list of parsed rules and a list of
            :class:`~.parsing.ParseError`.

        )rK�CDO�CDCrJN)rQrE�read_at_rule�
parse_at_rule�append�
parse_ruleset�extendr)
rrSrjrr�token�rule�result�rule_errors�excrrrrk�s,


�

����zCSS21Parser.parse_rulescCsx|j��}g}|}|D]}|jdvrn|�|�qt|�}|D]}t|d�q |jdkr0|jnd}t||||j|j	�S)aGRead an at-rule from a token stream.

        :param at_keyword_token:
            The ATKEYWORD token that starts this at-rule
            You may have read it already to distinguish the rule
            from a ruleset.
        :param tokens:
            An iterator of subsequent tokens. Will be consumed just enough
            for one at-rule.
        :return:
            An unparsed :class:`AtRule`.
        :raises:
            :class:`~.parsing.ParseError` if the head is invalid for the core
            grammar. The body is **not** validated. See :class:`AtRule`.

        z{;zat-rule head�{N)
r2�lowerrErsr
r�contentr"r&r')r�at_keyword_tokenrSr#r$rv�
head_tokenr%rrrrq�s

�zCSS21Parser.read_at_rulecCs|jdkr@|dkrt|d|��|�|j�\}}|jdur&t|d�|j���|�|jd�\}}}	|�|	�t|||||j	|j
�S|jdkr�|dkrPt|d|��|jsXt|d��|�|j�}
|jdurlt|d�|j���|�|jd�\}}	|�|	�t
|
||j	|j
�S|jd	kr�|dkr�t|d
|��|D]}|jdvr�|jr�d�|j�}
nd
}
t|d|
��q�|j}|s�t|d��|djdvr�t|d|dj��|dj}|�t|dd���}
|jdur�t|dd��t||
|j	|j
�S|jdkr�t|d��t|d�||j���)a�Parse an at-rule.

        Subclasses that override this method must use ``super()`` and
        pass its return value for at-rules they do not know.

        In CSS 2.1, this method handles @charset, @import, @media and @page
        rules.

        :param rule:
            An unparsed :class:`AtRule`.
        :param previous_rules:
            The list of at-rules and rulesets that have been parsed so far
            in this context. This list can be used to decide if the current
            rule is valid. (For example, @import rules are only allowed
            before anything but a @charset rule.)
        :param context:
            Either ``'stylesheet'`` or an at-keyword such as ``'@media'``.
            (Most at-rules are only allowed in some contexts.)
        :raises:
            :class:`~.parsing.ParseError` if the rule is invalid.
        :return:
            A parsed at-rule

        r7riz@page rule not allowed in Nzinvalid {0} rule: missing blockr;z@media rule not allowed in zexpected media types for @mediar@z@import rule not allowed in )rNr@zan {0} rulez	a rulesetz@import rule not allowed after z'expected URI or STRING for @import ruler)�URIrLz-expected URI or STRING for @import rule, got r���zexpected ';', got a blockrNz%mis-placed or malformed @charset rulez#unknown at-rule in {0} context: {1})r#r�parse_page_selectorr$r%r�parse_declarations_and_at_rulesrur6r&r'�parse_mediarkr:rEr2r
r?)rrw�previous_rulesrrjr,r8r-r9ryr=r�
previous_rule�type_r$rArrrrr�s�

���

�


��

�
�����



��zCSS21Parser.parse_at_rulecCst|sdgSg}tt|��D]*}dd�|D�}|dgkr$|�|dj�q
t|dd|r4dd�|���d	��|S)
aCFor CSS 2.1, parse a list of media types.

        Media Queries are expected to override this.

        :param tokens:
            A list of tokens
        :raises:
            :class:`~.parsing.ParseError` on invalid media types/queries
        :returns:
            For CSS 2.1, a list of media types as strings
        �allcSrCrrD)rFrvrrrrHPrIz+CSS21Parser.parse_media.<locals>.<listcomp>�IDENTrzexpected a media typez, got z, r4)r	rrsr2r�join)rrS�media_types�part�typesrrrr�@s 
����zCSS21Parser.parse_mediacCsf|sdSt|�dkr,|djdkr,|djdkr,|dj}dddd	��|�}|r,||fSt|dd
��)a�Parse an @page selector.

        :param tokens:
            An iterable of token, typically from the  ``head`` attribute of
            an unparsed :class:`AtRule`.
        :returns:
            A page selector. For CSS 2.1, this is ``'first'``, ``'left'``,
            ``'right'`` or ``None``.
        :raises:
            :class:`~.parsing.ParseError` on invalid selectors

        )N)rr�r�:rr�)rr)rr)�first�left�rightzinvalid @page selector)rrEr2�getr)rrS�pseudo_classr8rrrr�Ys

��zCSS21Parser.parse_page_selectorcCsg}g}g}t|�}|D]w}|jdkr@z|�||�}|�||||�}|�|�Wqty?}	z|�|	�WYd}	~	qd}	~	ww|jdkr�g}
|r_|jdkr_|
�|�t|d�}|r_|jdksN|
r�z
|�|�|
��Wqty�}	z|�|	�WYd}	~	qd}	~	wwq|||fS)a�Parse a mixed list of declarations and at rules, as found eg.
        in the body of an @page rule.

        Note that to add supported at-rules inside @page,
        :class:`~.page3.CSSPage3Parser` extends :meth:`parse_at_rule`,
        not this method.

        :param tokens:
            An iterable of token, typically from the  ``body`` attribute of
            an unparsed :class:`AtRule`.
        :param context:
            An at-keyword such as ``'@page'``.
            (Most at-rules are only allowed in some contexts.)
        :returns:
            A tuple of:

            * A list of :class:`Declaration`
            * A list of parsed at-rules (empty for CSS 2.1)
            * A list of :class:`~.parsing.ParseError`

        rJNrKrM)rQrErqrrrsr�next�parse_declaration)rrSrjr9r-rrvrwrx�err�declaration_tokensrrrr�rsB
���


�����
z+CSS21Parser.parse_declarations_and_at_rulesc	Cs�g}t|g|�D]8}|jdkr;t|�}|st|d��|D]}t|d�q|�|j�\}}t|||j|j	�}||fS|�
|�qt|d��)alParse a ruleset: a selector followed by declaration block.

        :param first_token:
            The first token of the ruleset (probably of the selector).
            You may have read it already to distinguish the rule
            from an at-rule.
        :param tokens:
            an iterator of subsequent tokens. Will be consumed just enough
            for one ruleset.
        :return:
            a tuple of a :class:`RuleSet` and an error list.
            The errors are recovered :class:`~.parsing.ParseError` in
            declarations. (Parsing continues from the next declaration on such
            errors.)
        :raises:
            :class:`~.parsing.ParseError` if the selector is invalid for the
            core grammar.
            Note a that a selector can be valid for the core grammar but
            not for CSS 2.1 or another level.

        r{zempty selectorr,z&no declaration block found for ruleset)rrEr
rrrlr}r+r&r'rs)	r�first_tokenrSr,rv�selector_tokenr-r�rulesetrrrrt�s"

��
zCSS21Parser.parse_rulesetcCs�g}g}|D]}|jdkr|�|�g}q|�|�q|�|�g}g}|D]*}t|�}|rPz
|�|�|��Wq&tyO}z|�|�WYd}~q&d}~wwq&||fS)aParse a ``;`` separated declaration list.

        You may want to use :meth:`parse_declarations_and_at_rules` (or
        some other method that uses :func:`parse_declaration` directly)
        instead if you have not just declarations in the same context.

        :param tokens:
            an iterable of tokens. Should stop at (before) the end
            of the block, as marked by ``}``.
        :return:
            a tuple of the list of valid :class:`Declaration` and a list
            of :class:`~.parsing.ParseError`

        rMN)rErsr
r�r)rrS�parts�	this_partrvr-rrzrrrrl�s*


���z"CSS21Parser.parse_declaration_listcCs�t|�}t|�}|jdkr|j��}n	t|d�|j���|}|D]}|jdkr)n|jdkr7t|d�|j���q t|d��tt|��}|sJt|d��t	|�|�
|�\}}t||||j|j
�S)a=Parse a single declaration.

        :param tokens:
            an iterable of at least one token. Should stop at (before)
            the end of the declaration, as marked by a ``;`` or ``}``.
            Empty declarations (ie. consecutive ``;`` with only white space
            in-between) should be skipped earlier and not passed to
            this method.
        :returns:
            a :class:`Declaration`
        :raises:
            :class:`~.parsing.ParseError` if the tokens do not match the
            'declaration' production of the core grammar.

        r�z!expected a property name, got {0}r�rKzexpected ':', got {0}zexpected ':'zexpected a property value)rQr�rEr2r|rrr
rRr�parse_value_priorityr0r&r')rrS�
name_token�
property_namervr2r3rrrr��s6
��

��

�zCSS21Parser.parse_declarationcCs�t|�}|��}|jdkrQ|j��dkrQ|rQ|��}|jdkrE|jdkrE|r:|djdkr:|��|r:|djdks-|sAt|d��|dfS|jdkrO	|dfS|s|dfS)	a!Separate any ``!important`` marker at the end of a property value.

        :param tokens:
            A list of tokens for the property value.
        :returns:
            A tuple of the actual property value (a list of tokens)
            and the :attr:`~Declaration.priority`.
        r��	important�DELIM�!r�rKz"expected a value before !importantN)rR�poprEr2r|r)rrSr2rvrrrr�s&	��
�
z CSS21Parser.parse_value_priority)NNNr)rrr r!rfr_rgrnrkrqrrr�r�r�rtrlr�r�rrrrrZ>s(
�
�
!$Z0(&-rZN)r!�
__future__r�	itertoolsrr�decodingr�parsingrrr	r
rr�
token_datar
�	tokenizerr�objectrr"r+r0r6r:r?rYrZrrrr�<module>s   *"'-!
Youez - 2016 - github.com/yon3zu
LinuXploit