| Server IP : 35.80.110.71 / Your IP : 216.73.216.52 Web Server : Apache/2.4.58 (Ubuntu) System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64 User : ubuntu ( 1000) PHP Version : 8.3.31 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : OFF Directory : /lib/python3/dist-packages/css_parser/css/__pycache__/ |
Upload File : |
�
��3etk � � � d Z ddlmZmZmZmZ ddgZdZdZddl m
Z
dd l m Z dd
l
Z
G d � de
e
j j � Zy
) aJ CSSStyleDeclaration implements DOM Level 2 CSS CSSStyleDeclaration and
extends CSS2Properties
see
http://www.w3.org/TR/1998/REC-CSS2-19980512/syndata.html#parsing-errors
Unknown properties
------------------
User agents must ignore a declaration with an unknown property.
For example, if the style sheet is::
H1 { color: red; rotation: 70minutes }
the user agent will treat this as if the style sheet had been::
H1 { color: red }
css_parser gives a message about any unknown properties but
keeps any property (if syntactically correct).
Illegal values
--------------
User agents must ignore a declaration with an illegal value. For example::
IMG { float: left } /* correct CSS2 */
IMG { float: left here } /* "here" is not a value of 'float' */
IMG { background: "red" } /* keywords cannot be quoted in CSS2 */
IMG { border-width: 3 } /* a unit must be specified for length values */
A CSS2 parser would honor the first rule and ignore the rest, as if the
style sheet had been::
IMG { float: left }
IMG { }
IMG { }
IMG { }
css_parser again will issue a message (WARNING in this case) about invalid
CSS2 property values.
TODO:
This interface is also used to provide a read-only access to the
computed values of an element. See also the ViewCSS interface.
- return computed values and not literal values
- simplify unit pairs/triples/quadruples
2px 2px 2px 2px -> 2px for border/padding...
- normalize compound properties like:
background: no-repeat left url() #fff
-> background: #fff url() no-repeat left
� )�unicode_literals�division�absolute_import�print_function�CSSStyleDeclaration�Property�restructuredtextz$Id$� )�CSS2Properties)r Nc �\ � � e Zd ZdZ d(� fd� Zd� Zd� Zd� Zd� Zd� Z d� Z
� fd �Z d
� Z d � Z
d � Zd
� Zd� Zd� Zd� Zd� Zd� Z eeed�� Zd)d�Zd� Z ed� ed�� Zd*d�Zd+d�Zd+d�Z d+d �Z d+d �Z d+d �Z d,d �Z d � Z! ed!� d"�� Z"d#� Z#d$� Z$ ee#e$d%�� Z%d&� Z& ee&d'�� Z'� xZ(S )-r aH The CSSStyleDeclaration class represents a single CSS declaration
block. This class may be used to determine the style properties
currently set in a block or to set style properties explicitly
within the block.
While an implementation may not recognize all CSS properties within
a CSS declaration block, it is expected to provide access to all
specified properties in the style sheet through the
CSSStyleDeclaration interface.
Furthermore, implementations that support a specific level of CSS
should correctly handle CSS shorthand properties for that level. For
a further discussion of shorthand properties, see the CSS2Properties
interface.
Additionally the CSS2Properties interface is implemented.
$css2propertyname
All properties defined in the CSS2Properties class are available
as direct properties of CSSStyleDeclaration with their respective
DOM name, so e.g. ``fontStyle`` for property 'font-style'.
These may be used as::
>>> style = CSSStyleDeclaration(cssText='color: red')
>>> style.color = 'green'
>>> print style.color
green
>>> del style.color
>>> print style.color
<BLANKLINE>
Format::
[Property: Value Priority?;]* [Property: Value Priority?]?
c �b �� t t | � � || _ || _ || _ || _ y)a�
:param cssText:
Shortcut, sets CSSStyleDeclaration.cssText
:param parentRule:
The CSS rule that contains this declaration block or
None if this CSSStyleDeclaration is not attached to a CSSRule.
:param readonly:
defaults to False
:param validating:
a flag defining if this sheet should be validated on change.
Defaults to None, which means defer to the parent stylesheet.
N)�superr �__init__� _parentRule�
validating�cssText� _readonly)�selfr �
parentRule�readonlyr � __class__s ��D/usr/lib/python3/dist-packages/css_parser/css/cssstyledeclaration.pyr z CSSStyleDeclaration.__init__d s0 �� � �!�4�1�3�%���$��� �� �!��� c � � t |t � r
|j }n| j |� }|| j � v S )z�Check if a property (or a property with given name) is in style.
:param name:
a string or Property, uses normalized name and not literalname
)�
isinstancer �name�
_normalize� _CSSStyleDeclaration__nnames)r �nameOrPropertyr s r � __contains__z CSSStyleDeclaration.__contains__x s8 � � �n�h� /�!�&�&�D��?�?�>�2�D��t�}�}��&�&r c � � � � fd�} |� S )zAIterator of set Property objects with different normalized names.c 3 �^ �K � �j � D ] } �j | � �� � y �w�N)r � getProperty)r r s �r �
propertiesz0CSSStyleDeclaration.__iter__.<locals>.properties� s- �� �� � �
�
��
-���&�&�t�,�,�
-�s �*-� )r r% s ` r �__iter__z CSSStyleDeclaration.__iter__� s �� � -� �|�r c �4 � t | j � � S )z]Analoguous to standard dict returns property names which are set in
this declaration.)�listr �r s r �keyszCSSStyleDeclaration.keys� s � � �D�M�M�O�$�$r c �$ � | j |� S )zzRetrieve the value of property ``CSSName`` from this declaration.
``CSSName`` will be always normalized.
��getPropertyValue�r �CSSNames r � __getitem__z CSSStyleDeclaration.__getitem__� s � �
�$�$�W�-�-r c �V � d}t |t � r|\ }}| j |||� S )z�Set value of property ``CSSName``. ``value`` may also be a tuple of
(value, priority), e.g. style['color'] = ('red', 'important')
``CSSName`` will be always normalized.
N)r �tuple� setProperty)r r0 �value�prioritys r � __setitem__z CSSStyleDeclaration.__setitem__� s1 � � �� �e�U� #� #�O�E�8�� � ����9�9r c �$ � | j |� S )z�Delete property ``CSSName`` from this declaration.
If property is not in this declaration return u'' just like
removeProperty.
``CSSName`` will be always normalized.
��removePropertyr/ s r � __delitem__z CSSStyleDeclaration.__delitem__� s � � �"�"�7�+�+r c � �� g d�}|j t j � ||v rt t | � ||� yt
d|z � �)a Prevent setting of unknown properties on CSSStyleDeclaration
which would not work anyway. For these
``CSSStyleDeclaration.setProperty`` MUST be called explicitly!
TODO:
implementation of known is not really nice, any alternative?
)�
_tokenizer�_log�_ttypes�_seq�seqr r r �valid�
wellformedr r � _profiles� _validatingzRUnknown CSS Property, ``CSSStyleDeclaration.setProperty("%s", ...)`` MUST be used.N)�extendr � _propertiesr r � __setattr__�AttributeError)r �n�v�knownr s �r rH z CSSStyleDeclaration.__setattr__� sQ �� �:�� � � �^�/�/�0� ��:� �%�t� 8��A� >� � "8�:;�"<� =�
=r c �\ � d| j j �d| j d�� �d�S )Nzcss_parser.css.z (cssText=� )� separator�))r �__name__�
getCssTextr* s r �__repr__z CSSStyleDeclaration.__repr__� s' � � �N�N� #� #� �O�O�c�O� *�,� ,r c � � d| j j | j t | j d�� � t | � fz S )Nz6<css_parser.css.%s object length=%r (all: %r) at 0x%x>T��all)r rQ �length�len�
getProperties�idr* s r �__str__zCSSStyleDeclaration.__str__� sF � �G� �N�N� #� #� �K�K� ��"�"�t�"�,� -� �t�H� K� � r c �� � g }t | j � D ]I }|j }t |t � s� |j
|vs�/|j
|j
� �K t |� S )z�Return iterator for all different names in order as set
if names are set twice the last one is used (double reverse!)
)�reversedrA r5 r r r �append)r �names�item�vals r �__nnamesz CSSStyleDeclaration.__nnames� s[ � � �� �T�X�X�&� '�D��*�*�C��#�x�(�S�X�X�U�-B�� � �S�X�X�&� '� ��� r c �$ � | j |� S )aY (DOM CSS2Properties) Overwritten here and effectively the same as
``self.getPropertyValue(CSSname)``.
Parameter is in CSSname format ('font-style'), see CSS2Properties.
Example::
>>> style = CSSStyleDeclaration(cssText='font-style:italic;')
>>> print style.fontStyle
italic
r- r/ s r �_getPzCSSStyleDeclaration._getP� s � � �$�$�W�-�-r c �( � | j ||� y)a� (DOM CSS2Properties) Overwritten here and effectively the same as
``self.setProperty(CSSname, value)``.
Only known CSS2Properties may be set this way, otherwise an
AttributeError is raised.
For these unknown properties ``setPropertyValue(CSSname, value)``
has to be called explicitly.
Also setting the priority of properties needs to be done with a
call like ``setPropertyValue(CSSname, value, priority)``.
Example::
>>> style = CSSStyleDeclaration()
>>> style.fontStyle = 'italic'
>>> # or
>>> style.setProperty('font-style', 'italic', '!important')
N)r4 )r r0 r5 s r �_setPzCSSStyleDeclaration._setP� s � �&
����%�(r c �& � | j |� y)a2 (css_parser only) Overwritten here and effectively the same as
``self.removeProperty(CSSname)``.
Example::
>>> style = CSSStyleDeclaration(cssText='font-style:italic;')
>>> del style.fontStyle
>>> print style.fontStyle
<BLANKLINE>
Nr9 r/ s r �_delPzCSSStyleDeclaration._delP� s � �
���G�$r c # �J K � | j D ] }|j �� � y�w)z�Generator yielding any known child in this declaration including
*all* properties, comments or CSSUnknownrules.
N)r@ r5 )r r` s r �childrenz CSSStyleDeclaration.children
s% � �� � �I�I� �D��*�*� � �s �!#c �@ � t j j | � S )z#Return serialized property cssText.��
css_parser�ser�do_css_CSSStyleDeclarationr* s r � _getCssTextz CSSStyleDeclaration._getCssText s � ��~�~�8�8��>�>r c � � � � � j � � j |� }d� fd� }d� fd� � d� � fd� }� j � }� j d||||d�� �� \ }}|D ] }� |j _ � � j
|� y)a� Setting this attribute will result in the parsing of the new value
and resetting of all the properties in the declaration block
including the removal or addition of properties.
:exceptions:
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if this declaration is readonly or a property is readonly.
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified CSS string value has a syntax error and
is unparsable.
Nc �> �� �j ||d�� }�j |d � dk( r|j � t ��� }||_ |j
r|j
|d� | S �j j d�j |� z � | S )NT)�
starttoken� semicolon����;��parentr z1CSSStyleDeclaration: Syntax Error in Property: %s)
� _tokensupto2� _tokenvalue�popr r rC r^ r> �error� _valuestr)�expectedrA �token� tokenizer�tokens�propertyr s �r �identz.CSSStyleDeclaration._setCssText.<locals>.ident$ s� �� � �&�&�y�U�15� '� 7�F�� � ��r�
�+�s�2��
�
� � �t�,�H� %�H� ��"�"��
�
�8�Z�0�
�O� � � ��� !/�15� � ��1G�!H� I� �Or c � �� �j |� �j �j |d�� � z }�j j d|z |� | S )NT)�propertyvalueendonlyz8CSSStyleDeclaration: Unexpected token, ignoring upto %r.)rz r} ry r> r| )r~ rA r r� �ignoredr s �r �
unexpectedz3CSSStyleDeclaration._setCssText.<locals>.unexpected5 sd �� ��&�&�u�-�����!�!�)�7;� "� =�1>� >�G�
�I�I�O�O� '�)0� 1�27�
9� �Or c � �� �j |� dk( r2�j j d�j |g� z d�� | S �| |||� S )Nrv z6CSSStyleDeclaration: Stripped standalone semicolon: %sT��
neverraise)rz r> �infor} )r~ rA r r� r r� s ��r �charz-CSSStyleDeclaration._setCssText.<locals>.char? s^ �� �� � ��&�#�-�� � ��� &�(,����w�(?� @�LP� � R� ��!�(�C�� �B�Br )�IDENT�CHAR)r~ rA r� � productions�defaultr# )�_checkReadonly�
_tokenize2�_tempSeq�_parser5 �_parent�_setSeq)
r r r� r� r� �newseqrC r~ r` r� s
` @r � _setCssTextz CSSStyleDeclaration._setCssText s� �� �
��� ��O�O�G�,� � �" � C� � � � �� #�{�{�D�/5��AF�PT�7U�3=� +� ?� �
�H� � &�D�!%�D�J�J� � &�
� � �V� r zh(DOM) A parsable textual representation of the declaration block excluding the surrounding curly braces.)�docc �B � t j j | |� S )aU
:returns:
serialized property cssText, each property separated by
given `separator` which may e.g. be ``u''`` to be able to use
cssText directly in an HTML style attribute. ``;`` is part of
each property (except the last one) and **cannot** be set with
separator!
rl )r rO s r rR z CSSStyleDeclaration.getCssText[ s � � �~�~�8�8��y�I�Ir c � � || _ y r# �r )r r s r �_setParentRulez"CSSStyleDeclaration._setParentRulef �
� �%��r c � � | j S r# r� r* s r �<lambda>z CSSStyleDeclaration.<lambda>k s � �t�'7�'7� r zy(DOM) The CSS rule that contains this declaration block or None if this CSSStyleDeclaration is not attached to a CSSRule.c � � |r|s| j |� }|r|gS g S |s-| j � D �cg c] }| j |� �� c}S | j |� }g }| j D ]M }|j }t |t � s� t |� du s|j |k( s�=|j |� �O |S c c}w )aZ
:param name:
optional `name` of properties which are requested.
Only properties with this **always normalized** `name` are returned.
If `name` is ``None`` all properties are returned (at least one for
each set name depending on parameter `all`).
:param all:
if ``False`` (DEFAULT) only the effective properties are returned.
If name is given a list with only one property is returned.
if ``True`` all properties including properties set multiple times
with different values or priorities for different UAs are returned.
The order of the properties is fully kept as in the original
stylesheet.
:returns:
a list of :class:`~css_parser.css.Property` objects set in
this declaration.
F)
r$ r r rA r5 r r �boolr r^ ) r r rV �p�name_�nnamer% r` ra s r rY z!CSSStyleDeclaration.getPropertieso s� � �& ��� � ��&�A���s�
�� ��9=� � � �I��D�$�$�U�+�I� I� �O�O�D�)�E��J� ���
+���j�j�� �c�8�,���K�5�(�c�h�h�%�.?� �%�%�c�*�
+�
� �� Js �B=c � � | j |� }d}t | j � D ]U }|j }t |t
� s� |r||j k( s||j k( s�A|j r|c S |r�T|}�W |S )a�
:param name:
of the CSS property, always lowercase (even if not normalized)
:param normalize:
if ``True`` (DEFAULT) name will be normalized (lowercase, no simple
escapes) so "color", "COLOR" or "C\olor" will all be equivalent
If ``False`` may return **NOT** the effective value but the
effective for the unnormalized name.
:returns:
the effective :class:`~css_parser.css.Property` object.
N) r r] rA r5 r r r � literalnamer6 )r r � normalizer� �foundr` ra s r r$ z CSSStyleDeclaration.getProperty� sv � � ����%���� �T�X�X�&� $�D��*�*�C��#�x�(� �%�3�8�8�"3�����8O��|�|� "�
� "� #�� $� � r c �� � | j |� }|| j v r | j j d|z d�� | j ||� }|r |j
S y)a�
:param name:
of the CSS property, always lowercase (even if not normalized)
:param normalize:
if ``True`` (DEFAULT) name will be normalized (lowercase, no simple
escapes) so "color", "COLOR" or "C\olor" will all be equivalent
If ``False`` may return **NOT** the effective value but the
effective for the unnormalized name.
:returns:
:class:`~css_parser.css.CSSValue`, the value of the effective
property if it has been explicitly set for this declaration block.
(DOM)
Used to retrieve the object representation of the value of a CSS
property if it has been explicitly set within this declaration
block. Returns None if the property has not been set.
(This method returns None if the property is a shorthand
property. Shorthand property values can only be accessed and
modified as strings, using the getPropertyValue and setProperty
methods.)
**css_parser currently always returns a CSSValue if the property is
set.**
for more on shorthand properties see
http://www.dustindiaz.com/css-shorthand/
zSCSSValue for shorthand property "%s" should be None, this may be implemented later.Tr� N)r �_SHORTHANDPROPERTIESr> r� r$ �
propertyValue)r r r� r� r� s r �getPropertyCSSValuez'CSSStyleDeclaration.getPropertyCSSValue� sj � �< ����%�� �D�-�-� -� �I�I�N�N� B� � !�-1�
�
3�
� � �T�9� -�� ��?�?� "�r c �D � | j ||� }|r |j S y)ah
:param name:
of the CSS property, always lowercase (even if not normalized)
:param normalize:
if ``True`` (DEFAULT) name will be normalized (lowercase, no simple
escapes) so "color", "COLOR" or "C\olor" will all be equivalent
If ``False`` may return **NOT** the effective value but the
effective for the unnormalized name.
:returns:
the value of the effective property if it has been explicitly set
for this declaration block. Returns the empty string if the
property has not been set.
� )r$ r5 �r r r� r� s r r. z$CSSStyleDeclaration.getPropertyValue� s% � �
� � �T�9� -�� ��7�7�N�r c �D � | j ||� }|r |j S y)a
:param name:
of the CSS property, always lowercase (even if not normalized)
:param normalize:
if ``True`` (DEFAULT) name will be normalized (lowercase, no simple
escapes) so "color", "COLOR" or "C\olor" will all be equivalent
If ``False`` may return **NOT** the effective value but the
effective for the unnormalized name.
:returns:
the priority of the effective CSS property (e.g. the
"important" qualifier) if the property has been explicitly set in
this declaration block. The empty string if none exists.
r� )r$ r6 r� s r �getPropertyPriorityz'CSSStyleDeclaration.getPropertyPriority� s& � �
� � �T�9� -�� ��:�:� �r c � � | j � | j ||�� }| j � }|rh| j |� }| j D ]G }t |j t � r|j j |k( r�7|j |� �I nV| j D ]G }t |j t � r|j j |k( r�7|j |� �I | j |� |S )a�
(DOM)
Used to remove a CSS property if it has been explicitly set within
this declaration block.
:param name:
of the CSS property
:param normalize:
if ``True`` (DEFAULT) name will be normalized (lowercase, no simple
escapes) so "color", "COLOR" or "C\olor" will all be equivalent.
The effective Property value is returned and *all* Properties
with ``Property.name == name`` are removed.
If ``False`` may return **NOT** the effective value but the
effective for the unnormalized `name` only. Also only the
Properties with the literal name `name` are removed.
:returns:
the value of the property if it has been explicitly set for
this declaration block. Returns the empty string if the property
has not been set or the property name does not correspond to a
known CSS property
:exceptions:
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if this declaration is readonly or the property is
readonly.
)r� ) r� r. r� r rA r r5 r r �
appendItemr� r� )r r r� �rr� r� r` s r r: z"CSSStyleDeclaration.removeProperty s� � �:
��� � � !� !�$�)� !� <��� � � �� ��O�O�D�)�E� ���
,��"�4�:�:�x�8� �J�J�O�O�u� 4��%�%�d�+�
,� ���
,��"�4�:�:�x�8� �J�J� 2� 2�d� :��%�%�d�+�
,�
� � �V� ��r c � � | j � t |t � r|}|j }n"|s| j |� S t |||| �� }|j
r�|r�| j
|� }| j || �� }t |� D ]~ } |r=| j |k( r.|j j | _
|j | _ y| j |k( s�R|j j | _
|j | _ y | |_
d| j _ | j j! |d� d| j _ y| j" j% d|�d|�d |��� y)
a� (DOM) Set a property value and priority within this declaration
block.
:param name:
of the CSS property to set (in W3C DOM the parameter is called
"propertyName"), always lowercase (even if not normalized)
If a property with this `name` is present it will be reset.
css_parser also allowed `name` to be a
:class:`~css_parser.css.Property` object, all other
parameter are ignored in this case
:param value:
the new value of the property, ignored if `name` is a Property.
:param priority:
the optional priority of the property (e.g. "important"),
ignored if `name` is a Property.
:param normalize:
if True (DEFAULT) `name` will be normalized (lowercase, no simple
escapes) so "color", "COLOR" or "C\olor" will all be equivalent
:param replace:
if True (DEFAULT) the given property will replace a present
property. If False a new property will be added always.
The difference to `normalize` is that two or more properties with
the same name may be set, useful for e.g. stuff like::
background: red;
background: rgba(255, 0, 0, 0.5);
which defines the same property but only capable UAs use the last
property value, older ones use the first value.
:exceptions:
- :exc:`~xml.dom.SyntaxErr`:
Raised if the specified value has a syntax error and is
unparsable.
- :exc:`~xml.dom.NoModificationAllowedErr`:
Raised if this declaration is readonly or the property is
readonly.
rw rU NFr TzInvalid Property: z: rN )r� r r r� r: rC r rY r] r r� r r6 rx rA r r^ r> �warn)
r r r5 r6 r� �replace�newpr� r% r� s
r r4 z CSSStyleDeclaration.setProperty4 sE � �V
��� � �d�H� %��D��#�#�D���&�&�t�,� ,��D�%��$�?�D� �?�?�� ����-�� !� /� /��y�=� /� J�
� (�� 4� �H� �X�]�]�e�%;�15�1C�1C�1K�1K��.�,0�M�M��)� �!�-�-��5�15�1C�1C�1K�1K��.�,0�M�M��)� � � �D�K�!&�D�H�H� � �H�H�O�O�D�*� -�!%�D�H�H� �
�I�I�N�N� "�E�8� 5�
6r c �^ � t | j � � } || S # t $ r Y yw xY w)a� (DOM) Retrieve the properties that have been explicitly set in
this declaration block. The order of the properties retrieved using
this method does not have to be the order in which they were set.
This method can be used to iterate over all properties in this
declaration block.
:param index:
of the property to retrieve, negative values behave like
negative indexes on Python lists, so -1 is the last element
:returns:
the name of the property at this ordinal position. The
empty string if no property exists at this position.
**ATTENTION:**
Only properties with different names are counted. If two
properties with the same name are present in this declaration
only the effective one is included.
:meth:`item` and :attr:`length` work on the same set here.
r� )r) r �
IndexError)r �indexr_ s r r` zCSSStyleDeclaration.item� s5 � �, �T�]�]�_�%�� ���<� ��� �� �s � � ,�,c �F � t t | j � � � S r# )rX r) r r* s r r� z CSSStyleDeclaration.<lambda>� s � �3�t�D�M�M�O�'<�#=� r a (DOM) The number of distinct properties that have been explicitly in this declaration block. The range of valid indices is 0 to length-1 inclusive. These are properties with a different ``name`` only. :meth:`item` and :attr:`length` work on the same set here.c � � | j j j S # t $ r | j �| j cY S Y yw xY w)NT)r �parentStyleSheetr rI rE r* s r �_getValidatingz"CSSStyleDeclaration._getValidating� sN � � (��?�?�3�3�>�>� >�� � (�� � �+��'�'�'� ,� � (�s � " �!A�Ac � � || _ y r# )rE )r r s r �_setValidatingz"CSSStyleDeclaration._setValidating� r� r z�If ``True`` this declaration validates contained properties. The parent StyleSheet validation setting does *always* win though so even if validating is True it may not validate if the StyleSheet defines else!c �B � t d� | j � D � � S )z+Check each contained property for validity.c 3 �4 K � | ] }|j �� � y �wr# )rB )�.0�props r � <genexpr>z0CSSStyleDeclaration._getValid.<locals>.<genexpr>� s � �� �?�$�4�:�:�?�s �)rV rY r* s r � _getValidz CSSStyleDeclaration._getValid� s � ��?�$�*<�*<�*>�?�?�?r z#``True`` if each property is valid.)r� NFNr# )NF)T)Nr� TT))rQ �
__module__� __qualname__�__doc__r r r' r+ r1 r7 r; rH rS r[ r rd rf rh rj rp r� r� r rR r� r rY r$ r� r. r� r: r4 r` rW r� r� r r� rB �
__classcell__)r s @r r r ? s �� �"�H >C� �"�(
'� �%�
.�
:�,�=�(,�
� � .� )�, %� �?�? �B �{�K� %�&�G�
J�&�
�7� � [�\�J�& �P�2(�T�*�*.�` 68�,0�M6�^�8 �=�+�,�F� �&� �.�.� <�=�J�@�
�Y�>�
@�Er )r� �
__future__r r r r �__all__�
__docformat__� __version__�
csspropertiesr r� r rm �util�Base2r r& r r �<module>r� sM ��2�f S� R� �*�
-��"�
�� � )� � �B
@�.�*�/�/�*?�*?� B
@r