403Webshell
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/fontTools/feaLib/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/fontTools/feaLib/__pycache__/ast.cpython-312.pyc
�

jkeI ��V�ddlmZddlmZddlmZddlmZmZddl	m
Z
ddlZdZgd�Z
d	�Zegd
��Zd�ZGd�d
e�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd�de�ZGd �d!e�ZGd"�d#e�ZGd$�d%e�ZGd&�d'e�Z Gd(�d)e�Z!Gd*�d+e�Z"Gd,�d-e�Z#Gd.�d/e�Z$Gd0�d1e�Z%Gd2�d3e�Z&Gd4�d5e�Z'Gd6�d7e�Z(Gd8�d9e�Z)Gd:�d;e�Z*Gd<�d=e�Z+Gd>�d?e�Z,Gd@�dAe�Z-GdB�dCe�Z.GdD�dEe�Z/GdF�dGe�Z0GdH�dIe�Z1GdJ�dKe�Z2GdL�dMe�Z3GdN�dOe�Z4GdP�dQe�Z5GdR�dSe�Z6GdT�dUe�Z7GdV�dWe�Z8GdX�dYe�Z9GdZ�d[e�Z:Gd\�d]e�Z;Gd^�d_e�Z<Gd`�dae�Z=Gdb�dce�Z>Gdd�dee�Z?Gdf�dge�Z@Gdh�die�ZAGdj�dke�ZBGdl�dme�ZCGdn�doe�ZDGdp�dqe�ZEdr�ZFGds�dte�ZGGdu�dveG�ZHGdw�dxeG�ZIGdy�dze�ZJGd{�d|eG�ZKGd}�d~e�ZLGd�d�e�ZMGd��d�e�ZNGd��d�e�ZOGd��d�e�ZPGd��d�e�ZQGd��d�e�ZRGd��d�e�ZSGd��d�e�ZTGd��d�e�ZUGd��d�e�ZVGd��d�e�ZWy)��)�FeatureLibError)�FeatureLibLocation)�getEncoding)�byteord�tobytes)�OrderedDictNz    )B�Element�FeatureFile�Comment�	GlyphName�
GlyphClass�GlyphClassName�
MarkClassName�AnonymousBlock�Block�FeatureBlock�NestedBlock�LookupBlock�GlyphClassDefinition�GlyphClassDefStatement�	MarkClass�MarkClassDefinition�AlternateSubstStatement�Anchor�AnchorDefinition�AttachStatement�AxisValueLocationStatement�BaseAxis�CVParametersNameStatement�ChainContextPosStatement�ChainContextSubstStatement�CharacterStatement�ConditionsetStatement�CursivePosStatement�ElidedFallbackName�ElidedFallbackNameID�
Expression�FeatureNameStatement�FeatureReferenceStatement�FontRevisionStatement�	HheaField�IgnorePosStatement�IgnoreSubstStatement�IncludeStatement�LanguageStatement�LanguageSystemStatement�LigatureCaretByIndexStatement�LigatureCaretByPosStatement�LigatureSubstStatement�LookupFlagStatement�LookupReferenceStatement�MarkBasePosStatement�MarkLigPosStatement�MarkMarkPosStatement�MultipleSubstStatement�
NameRecord�OS2Field�PairPosStatement� ReverseChainSingleSubstStatement�ScriptStatement�SinglePosStatement�SingleSubstStatement�SizeParameters�	Statement�STATAxisValueStatement�STATDesignAxisStatement�STATNameStatement�SubtableStatement�
TableBlock�ValueRecord�ValueRecordDefinition�	VheaFieldc�>�|�yddjd�|D��zS)Nz
<device NULL>z<device %s>�, c3�&K�|]	}d|z���y�w)z%d %dN�)�.0�ts  �6/usr/lib/python3/dist-packages/fontTools/feaLib/ast.py�	<genexpr>z!deviceToString.<locals>.<genexpr>Ts����(E���1��(E�s�)�join)�devices rQ�deviceToStringrUPs$��
�~���t�y�y�(E�f�(E�E�E�E�)4�anchor�	anchordef�anon�	anonymous�by�contour�cursiverT�enum�	enumerate�excludedflt�exclude_dflt�feature�from�ignore�ignorebaseglyphs�ignoreligatures�ignoremarks�include�includedflt�include_dflt�language�languagesystem�lookup�
lookupflag�mark�markattachmenttype�	markclass�nameid�null�
parameters�pos�position�required�righttoleft�
reversesub�rsub�script�sub�
substitute�subtable�table�usemarkfilteringset�useextension�valuerecorddef�base�gdef�head�hhea�name�vhea�vmtxc���t|d�r|j�St|t�r.t	|�dk(r t|d�dzt|d�zS|j�tvrd|zS|S)N�asFea�rz - ��\)�hasattrr��
isinstance�tuple�len�lower�fea_keywords)�gs rQr�r��sh���q�'���w�w�y��	�A�u�	�#�a�&�A�+��Q�q�T�{�U�"�U�1�Q�4�[�0�0�	
����l�	"��a�x���rVc�,�eZdZdZdd�Zd�Zdd�Zd�Zy)	r	z8A base class representing "something" in a feature file.Nc�F�|rt|t�st|�}||_y�N)r�r�location��selfr�s  rQ�__init__zElement.__init__�s ���J�x�1C�D�)�8�4�H� ��
rVc��yr�rN�r��builders  rQ�buildz
Element.build�s��rVc��t�)z�Returns this element as a string of feature code. For block-type
        elements (such as :class:`FeatureBlock`), the `indent` string is
        added to the start of each line in the output.)�NotImplementedError�r��indents  rQr�z
Element.asFea�s
��"�!rVc�"�|j�Sr��r��r�s rQ�__str__zElement.__str__�s���z�z�|�rVr���)�__name__�
__module__�__qualname__�__doc__r�r�r�r�rNrVrQr	r	�s��B�!�
�"�rVr	c��eZdZy)rBN�r�r�r�rNrVrQrBrB����rVrBc��eZdZy)r'Nr�rNrVrQr'r'�r�rVr'c�,��eZdZdZd�fd�	Zdd�Z�xZS)rzA comment in a feature file.c�:��tt|�|�||_yr�)�superrr��text)r�r�r��	__class__s   �rQr�zComment.__init__�s���
�g�t�%�h�/���	rVc��|jSr�)r�r�s  rQr�z
Comment.asFea�s���y�y�rVr�r��r�r�r�r�r�r��
__classcell__�r�s@rQrr�s���&��
rVrc�&�eZdZdZdd�Zd�Zdd�Zy)�	NullGlyphz5The NULL glyph, used in glyph deletion substitutions.Nc�0�tj||�yr�)r'r�r�s  rQr�zNullGlyph.__init__�s�����D�(�+rVc��y)�BThe glyphs in this class as a tuple of :class:`GlyphName` objects.rNrNr�s rQ�glyphSetzNullGlyph.glyphSet�s��rVc��y)N�NULLrNr�s  rQr�zNullGlyph.asFea�s��rVr�r��r�r�r�r�r�r�r�rNrVrQr�r��s��?�,��rVr�c�&�eZdZdZdd�Zd�Zdd�Zy)rz)A single glyph name, such as ``cedilla``.Nc�>�tj||�||_yr�)r'r��glyph)r�r�r�s   rQr�zGlyphName.__init__�s�����D�(�+���
rVc��|jfS�r�)r�r�s rQr�zGlyphName.glyphSet�s���
�
�}�rVc�,�t|j�Sr�)r�r�r�s  rQr�zGlyphName.asFea�s���T�Z�Z� � rVr�r�r�rNrVrQrr�s��3��
�!rVrc�D�eZdZdZdd�Zd�Zdd�Zd�Zd�Zd�Z	d	�Z
d
�Zy)
r
z1A glyph class, such as ``[acute cedilla grave]``.Nc�b�tj||�|�|ng|_g|_d|_y)Nr)r'r��glyphs�original�curr)r�r�r�s   rQr�zGlyphClass.__init__�s.�����D�(�+� &� 2�f������
���	rVc�,�t|j�Sr�)r�r�r�s rQr�zGlyphClass.glyphSet�s���T�[�[�!�!rVc���t|j�r�|jt|j�krL|jj	|j|jd�t|j�|_ddjt
t|j��zdzSddjt
t|j��zdzS)N�[� �])r�r�r�r��extendrS�mapr�r�s  rQr�zGlyphClass.asFea�s����t�}�}���y�y�3�t�{�{�+�+��
�
�$�$�T�[�[�����%=�>�����,��	�����#�e�T�]�]�";�<�<�s�B�B�����#�e�T�[�[�"9�:�:�S�@�@rVc�:�|jj|�y)z6Add a list of :class:`GlyphName` objects to the class.N)r�r�)r�r�s  rQr�zGlyphClass.extend�s�������6�"rVc�:�|jj|�y)z4Add a single :class:`GlyphName` object to the class.N)r��append)r�r�s  rQr�zGlyphClass.appends�������5�!rVc�P�|jt|j�kr2|jj	|j|jd�|jj||f�|jj	|�t|j�|_y)aAdd a range (e.g. ``A-Z``) to the class. ``start`` and ``end``
        are either :class:`GlyphName` objects or strings representing the
        start and end glyphs in the class, and ``glyphs`` is the full list of
        :class:`GlyphName` objects in the range.N)r�r�r�r�r�r��r��start�endr�s    rQ�	add_rangezGlyphClass.add_rangesr��
�9�9�s�4�;�;�'�'��M�M� � ����T�Y�Y�[�!9�:��
�
���e�S�\�*������6�"�����$��	rVc��|jt|j�kr2|jj	|j|jd�|jjdj
|�dj
|�f�|jj	|�t|j�|_y)z�Add a range to the class by glyph ID. ``start`` and ``end`` are the
        initial and final IDs, and ``glyphs`` is the full list of
        :class:`GlyphName` objects in the range.Nz\{})r�r�r�r�r�r��formatr�s    rQ�
add_cid_rangezGlyphClass.add_cid_ranges����9�9�s�4�;�;�'�'��M�M� � ����T�Y�Y�[�!9�:��
�
���f�m�m�E�2�F�M�M�#�4F�G�H������6�"�����$��	rVc�h�|jt|j�kr2|jj	|j|jd�|jj|�|jj	|j
��t|j�|_y)zNAdd glyphs from the given :class:`GlyphClassName` object to the
        class.N)r�r�r�r�r�r�r�)r��gcs  rQ�	add_classzGlyphClass.add_classst���9�9�s�4�;�;�'�'��M�M� � ����T�Y�Y�[�!9�:��
�
���R� ������2�;�;�=�)�����$��	rV�NNr�)r�r�r�r�r�r�r�r�r�r�r�r�rNrVrQr
r
�s.��;��"�A�#�"�	%�%�%rVr
c�&�eZdZdZdd�Zd�Zdd�Zy)rzyA glyph class name, such as ``@FRENCH_MARKS``. This must be instantiated
    with a :class:`GlyphClassDefinition` object.Nc�b�tj||�t|t�sJ�||_yr�)r'r�r�r�
glyphclass)r�r�r�s   rQr�zGlyphClassName.__init__'s*�����D�(�+��*�&:�;�;�;�$��rVc�H�t|jj��Sr�)r�r�r�r�s rQr�zGlyphClassName.glyphSet,s���T�_�_�-�-�/�0�0rVc�4�d|jjzS�N�@)r�r�r�s  rQr�zGlyphClassName.asFea0s���T�_�_�)�)�)�)rVr�r�r�rNrVrQrr#s��4�%�
1�*rVrc�&�eZdZdZdd�Zd�Zdd�Zy)rz�A mark class name, such as ``@FRENCH_MARKS`` defined with ``markClass``.
    This must be instantiated with a :class:`MarkClass` object.Nc�b�tj||�t|t�sJ�||_yr�)r'r�r�r�	markClass)r�r�r�s   rQr�zMarkClassName.__init__8s)�����D�(�+��)�Y�/�/�/�"��rVc�6�|jj�Sr�)r�r�r�s rQr�zMarkClassName.glyphSet=s���~�~�&�&�(�(rVc�4�d|jjzSr�)r�r�r�s  rQr�zMarkClassName.asFeaAs���T�^�^�(�(�(�(rVr�r�r�rNrVrQrr4s��C�#�
)�)rVrc� �eZdZdZdd�Zdd�Zy)rzAn anonymous data block.Nc�L�tj||�||_||_yr�)rBr��tag�content)r�r�r�r�s    rQr�zAnonymousBlock.__init__Hs �����4��*������rVc��dj|j�}||jz
}|dj|j�z
}|S)Nzanon {} {{
z}} {};

)r�r�r��r�r��ress   rQr�zAnonymousBlock.asFeaMsB���#�#�D�H�H�-���t�|�|����|�"�"�4�8�8�,�,���
rVr�r��r�r�r�r�r�r�rNrVrQrrEs��"��
rVrc�&�eZdZdZdd�Zd�Zdd�Zy)rz,A block of statements: feature, lookup, etc.Nc�>�tj||�g|_yr�)rBr��
statementsr�s  rQr�zBlock.__init__Ws�����4��*���rVc�H�|jD]}|j|��y)z�When handed a 'builder' object of comparable interface to
        :class:`fontTools.feaLib.builder`, walks the statements in this
        block, calling the builder callbacks.N)r�r�)r�r��ss   rQr�zBlock.build[s#�����	�A�
�G�G�G��	rVc	��|tz
}|d|zj|jD�cgc]}|j|����c}�zdzScc}w)N�
�r�)�SHIFTrSr�r�)r�r�r�s   rQr�zBlock.asFeabsP���%�����f�}�"�"�D�O�O�#T�q�A�G�G�6�G�$:�#T�U�
V��
�	
��#Ts�A
r�r��r�r�r�r�r�r�r�rNrVrQrrTs��6���
rVrc��eZdZdZd�Zdd�Zy)r
zpThe top-level element of the syntax tree, containing the whole feature
    file in its ``statements`` attribute.c�@�tj|d��i|_y�N)r�)rr��markClassesr�s rQr�zFeatureFile.__init__os��
���t�d��+���rVc�L��dj�fd�|jD��S)Nrc3�B�K�|]}|j������y�w)rNr�)rOr�r�s  �rQrRz$FeatureFile.asFea.<locals>.<genexpr>ts�����I�A������/�I�s�)rSr�r�s `rQr�zFeatureFile.asFeass����y�y�I����I�I�IrVNr�r�rNrVrQr
r
ks��-��JrVr
c�&�eZdZdZdd�Zd�Zdd�Zy)rzA named feature block.Nc�N�tj||�||c|_|_yr��rr�r��
use_extension�r�r�r
r�s    rQr�zFeatureBlock.__init__z�!��
���t�X�&�(,�m�%��	�4�%rVc�V�|j|j|j�|j}i|_tj||�|jj
�D]&\}}|j|g�j|��(||_|j�y)��Call the ``start_feature`` callback on the builder object, visit
        all the statements in this feature, and then call ``end_feature``.N)
�
start_featurer�r��	features_rr��items�
setdefaultr��end_feature)r�r��features�key�values     rQr�zFeatureBlock.build~s���	���d�m�m�T�Y�Y�7��$�$�����
���D�'�"�!�+�+�1�1�3�	7�J�C������R�(�/�/��6�	7�$������rVc���|d|jj�zz}|jr|dz
}|dz
}|tj	||��z
}||d|jj�zzz
}|S)Nzfeature %s �
useExtension �{
r�} %s;
)r��stripr
rr�r�s   rQr�zFeatureBlock.asFea�ss���}�t�y�y���'8�8�8������?�"�C��u����u�{�{�4��{�/�/���v�	�D�I�I�O�O�$5�5�5�5���
rV�FNr�rrNrVrQrrws�� �<�
�rVrc�&�eZdZdZdd�Zd�Zdd�Zy)rzYA block inside another block, for example when found inside a
    ``cvParameters`` block.Nc�L�tj||�||_||_yr�)rr�r��
block_name)r�r�r"r�s    rQr�zNestedBlock.__init__�s��
���t�X�&����$��rVc��tj||�|jdk(r|j|j�yy)N�ParamUILabelNameID)rr�r"�add_to_cv_num_named_paramsr�r�s  rQr�zNestedBlock.build�s4��
���D�'�"��?�?�2�2��.�.�t�x�x�8�3rVc��dj||j�}|tj||��z
}|dj|�z
}|S)Nz{}{} {{
rz{}}};
)r�r"rr�r�s   rQr�zNestedBlock.asFea�sI��� � �����9���u�{�{�4��{�/�/���y����'�'���
rVr�r�rrNrVrQrr�s���%�
9�
rVrc�&�eZdZdZdd�Zd�Zdd�Zy)rz*A named lookup, containing ``statements``.Nc�N�tj||�||c|_|_yr�rrs    rQr�zLookupBlock.__init__�rrVc��|j|j|j�tj	||�|j�yr�)�start_lookup_blockr�r�rr��end_lookup_blockr�s  rQr�zLookupBlock.build�s4���"�"�4�=�=�$�)�)�<�
���D�'�"�� � �"rVc���dj|j�}|jr|dz
}|dz
}|tj	||��z
}|dj||j�z
}|S)Nz
lookup {} rrrz	{}}} {};
)r�r�r
rr�r�s   rQr�zLookupBlock.asFea�si���!�!�$�)�)�,������?�"�C��u����u�{�{�4��{�/�/���|�"�"�6�4�9�9�5�5���
rVrr�rrNrVrQrr�s��4�<�#�rVrc�,��eZdZdZdd�Zd�fd�	Z�xZS)rGzA ``table ... { }`` block.c�>�tj||�||_yr�)rr�r�)r�r�r�s   rQr�zTableBlock.__init__�s��
���t�X�&���	rVc����dj|jj��}|tt|�|��z
}|dj|jj��z
}|S)Nztable {} {{
rz}} {};
)r�r�rr�rGr�)r�r�r�r�s   �rQr�zTableBlock.asFea�s\����$�$�T�Y�Y�_�_�%6�7���u�Z��,�F�,�;�;���z� � ������!2�3�3���
rVr�r�r�r�s@rQrGrG�s���$���rVrGc�&�eZdZdZdd�Zd�Zdd�Zy)rz!Example: ``@UPPERCASE = [A-Z];``.Nc�L�tj||�||_||_yr�)rBr�r�r�)r�r�r�r�s    rQr�zGlyphClassDefinition.__init__�s �����4��*���	���rVc�H�t|jj��Sr�)r�r�r�r�s rQr�zGlyphClassDefinition.glyphSet�s���T�[�[�)�)�+�,�,rVc�b�d|jzdz|jj�zdzS)Nr�z = �;)r�r�r�r�s  rQr�zGlyphClassDefinition.asFea�s,���T�Y�Y���&����):�):�)<�<�s�B�BrVr�r�r�rNrVrQrr�s��+��
-�CrVrc�(�eZdZdZ	dd�Zd�Zdd�Zy)rz�Example: ``GlyphClassDef @UPPERCASE, [B], [C], [D];``. The parameters
    must be either :class:`GlyphClass` or :class:`GlyphClassName` objects, or
    ``None``.Nc�j�tj||�||c|_|_||_||_yr�)rBr��
baseGlyphs�
markGlyphs�ligatureGlyphs�componentGlyphs)r�r7r8r9r:r�s      rQr�zGlyphClassDefStatement.__init__�s4��	���4��*�,6�
�(�����,���.��rVc���|jr|jj�n	t�}|jr|jj�n	t�}|jr|jj�n	t�}|j
r|j
j�n	t�}|j
|j||||�y)z3Calls the builder's ``add_glyphClassDef`` callback.N)r7r�r�r9r8r:�add_glyphClassDefr�)r�r�r��ligaro�comps      rQr�zGlyphClassDefStatement.build�s���-1�_�_�t���'�'�)�%�'��15�1D�1D�t�"�"�+�+�-�%�'��-1�_�_�t���'�'�)�%�'��26�2F�2F�t�#�#�,�,�.�E�G���!�!�$�-�-��t�T�4�HrVc�b�dj|jr|jj�nd|jr|jj�nd|jr|jj�nd|j
r|j
j��Sd�S)NzGlyphClassDef {}, {}, {}, {};r�)r�r7r�r9r8r:r�s  rQr�zGlyphClassDefStatement.asFea�s���.�5�5�'+���D�O�O�!�!�#�B�+/�+>�+>�D���%�%�'�B�'+���D�O�O�!�!�#�B�,0�,@�,@�D� � �&�&�(�	
�	
�GI�	
�	
rVr�r�rrNrVrQrr�s���
QU�/�I�
rVrc�*�eZdZdZd�Zd�Zd�Zdd�Zy)raBOne `or more` ``markClass`` statements for the same mark class.

    While glyph classes can be defined only once, the feature file format
    allows expanding mark classes with multiple definitions, each using
    different glyphs and anchors. The following are two ``MarkClassDefinitions``
    for the same ``MarkClass``::

        markClass [acute grave] <anchor 350 800> @FRENCH_ACCENTS;
        markClass [cedilla] <anchor 350 -200> @FRENCH_ACCENTS;

    The ``MarkClass`` object is therefore just a container for a list of
    :class:`MarkClassDefinition` statements.
    c�>�||_g|_t�|_yr�)r��definitionsrr�)r�r�s  rQr�zMarkClass.__init__s����	����!�m��rVc�@�t|t�sJ�|jj|�|j	�D]^}||j
vr?|j
|j}|�d}nd|��}td|�d|��|j��||j
|<�`y)z@Add a :class:`MarkClassDefinition` statement to this mark class.Nr�z at zGlyph z already defined)r�rrBr�r�r�r�r)r��
definitionr��otherLocr�s     rQ�
addDefinitionzMarkClass.addDefinitions����*�&9�:�:�:������
�+��(�(�*�
	,�E�����#��;�;�u�-�6�6���#��C� ��
�+�C�%�49�3�?��AT�AT���",�D�K�K���
	,rVc�H�t|jj��Sr�)r�r��keysr�s rQr�zMarkClass.glyphSet#s���T�[�[�%�%�'�(�(rVc�J�djd�|jD��}|S)Nrc3�<K�|]}|j����y�wr�r�)rO�ds  rQrRz"MarkClass.asFea.<locals>.<genexpr>(s����<�a����	�<���)rSrBr�s   rQr�zMarkClass.asFea's!���i�i�<�4�+;�+;�<�<���
rVNr�)r�r�r�r�r�rFr�r�rNrVrQrr�s���$�
,� )�rVrc�&�eZdZdZdd�Zd�Zdd�Zy)raA single ``markClass`` statement. The ``markClass`` should be a
    :class:`MarkClass` object, the ``anchor`` an :class:`Anchor` object,
    and the ``glyphs`` parameter should be a `glyph-containing object`_ .

    Example:

        .. code:: python

            mc = MarkClass("FRENCH_ACCENTS")
            mc.addDefinition( MarkClassDefinition(mc, Anchor(350, 800),
                GlyphClass([ GlyphName("acute"), GlyphName("grave") ])
            ) )
            mc.addDefinition( MarkClassDefinition(mc, Anchor(350, -200),
                GlyphClass([ GlyphName("cedilla") ])
            ) )

            mc.asFea()
            # markClass [acute grave] <anchor 350 800> @FRENCH_ACCENTS;
            # markClass [cedilla] <anchor 350 -200> @FRENCH_ACCENTS;

    Nc���tj||�t|t�sJ�t|t�rt|t
�sJ�|||c|_|_|_yr�)	rBr�r�rrr'r�rWr�)r�r�rWr�r�s     rQr�zMarkClassDefinition.__init__CsQ�����4��*��)�Y�/�/�/��&�&�)�j���.L�L�L�3<�f�f�0�����T�[rVc�6�|jj�Sr�)r�r�r�s rQr�zMarkClassDefinition.glyphSetIs���{�{�#�#�%�%rVc��dj|jj�|jj�|jj
�S)NzmarkClass {} {} @{};)r�r�r�rWr�r�r�s  rQr�zMarkClassDefinition.asFeaMs@��%�,�,��K�K�������!2�!2�!4�d�n�n�6I�6I�
�	
rVr�r�r�rNrVrQrr,s���,M�&�
rVrc�&�eZdZdZdd�Zd�Zdd�Zy)rz�A ``sub ... from ...`` statement.

    ``prefix``, ``glyph``, ``suffix`` and ``replacement`` should be lists of
    `glyph-containing objects`_. ``glyph`` should be a `one element list`.Nc�j�tj||�|||c|_|_|_||_yr�)rBr��prefixr��suffix�replacement)r�rSr�rTrUr�s      rQr�z AlternateSubstStatement.__init__Ys0�����4��*�06��v�,���T�Z���&��rVc��|jj�}t|�dk(sJ|��t|�d}|jD�cgc]}|j���}}|j
D�cgc]}|j���}}|jj�}|j|j||||�ycc}wcc}w)z5Calls the builder's ``add_alternate_subst`` callback.r�rN)	r�r�r��listrSrTrU�add_alternate_substr�)r�r�r��prSr�rTrUs        rQr�zAlternateSubstStatement.build^s����
�
�#�#�%���5�z�Q��%��%���U��A���(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4��&�&�/�/�1���#�#�D�M�M�6�5�&�+�V��5��4s�C�3Cc��d}t|j�st|j�r�t|j�r/|djt	t
|j��dzz
}|t|j�dzz
}t|j�rH|ddjt	t
|j��zz
}n|t|j�z
}|dz
}|t|j�z
}|dz
}|S)N�sub r��'z from r4)r�rSrTrSr�r�r�rUr�s   rQr�zAlternateSubstStatement.asFeahs������t�{�{��s�4�;�;�/��4�;�;���s�x�x��E�4�;�;� 7�8�3�>�>���5����$�s�*�*�C��4�;�;���s�S�X�X�c�%����&=�>�>�>���5����$�$�C��x����u�T�%�%�&�&���s�
���
rVr�r�rrNrVrQrrSs��N�
'�
W�
rVrc�*�eZdZdZ					dd�Zdd�Zy)rz�An ``Anchor`` element, used inside a ``pos`` rule.

    If a ``name`` is given, this will be used in preference to the coordinates.
    Other values should be integer.
    Nc��tj||�||_|||c|_|_|_||c|_|_yr�)r'r�r��x�y�contourpoint�xDeviceTable�yDeviceTable)r�r_r`r�rarbrcr�s        rQr�zAnchor.__init__sD��	���D�(�+���	�,-�q�,�)������)�/;�\�,���4�,rVc��|j�dj|j�Sdj|j|j�}|jr|dj|j�z
}|j
s|jr:|dz
}|t|j
�z
}|dz
}|t|j�z
}|dz
}|S)Nz<anchor {}>z
<anchor {} {}� contourpoint {}r��>)r�r�r_r`rarbrcrUr�s   rQr�zAnchor.asFea�s����9�9� � �'�'��	�	�2�2��$�$�T�V�V�T�V�V�4������%�,�,�T�->�->�?�?�C����� 1� 1��3�J�C��>�$�"3�"3�4�4�C��3�J�C��>�$�"3�"3�4�4�C��s�
���
rV)NNNNNr�r�rNrVrQrrxs#��������
J�rVrc� �eZdZdZdd�Zdd�Zy)rzCA named anchor definition. (2.e.viii). ``name`` should be a string.Nc�n�tj||�||||f\|_|_|_|_yr�)rBr�r�r_r`ra)r�r�r_r`rar�s      rQr�zAnchorDefinition.__init__�s2�����4��*�7;�Q��<�7O�4��	�4�6�4�6�4�#4rVc���dj|j|j�}|jr|dj|j�z
}|dj|j�z
}|S)NzanchorDef {} {}rez {};)r�r_r`rar�r�s   rQr�zAnchorDefinition.asFea�s]���&�&�t�v�v�t�v�v�6������%�,�,�T�->�->�?�?�C��v�}�}�T�Y�Y�'�'���
rVr�r�r�rNrVrQrr�s��M�P�rVrc�&�eZdZdZdd�Zd�Zdd�Zy)rz&A ``GDEF`` table ``Attach`` statement.Nc�L�tj||�||_||_yr�)rBr�r��
contourPoints)r�r�rlr�s    rQr�zAttachStatement.__init__�s!�����4��*����*��rVc��|jj�}|j|j||j�y)z3Calls the builder's ``add_attach_points`` callback.N)r�r��add_attach_pointsr�rl�r�r�r�s   rQr�zAttachStatement.build�s0�����%�%�'���!�!�$�-�-���9K�9K�LrVc��dj|jj�djd�|jD���S)Nz
Attach {} {};r�c3�2K�|]}t|����y�wr���str)rO�cs  rQrRz(AttachStatement.asFea.<locals>.<genexpr>�s����)M�Q�#�a�&�)M���)r�r�r�rSrlr�s  rQr�zAttachStatement.asFea�s<���%�%��K�K�������)M�$�:L�:L�)M�!M�
�	
rVr�r�rrNrVrQrr�s��0�+�
M�

rVrc�&�eZdZdZdd�Zd�Zdd�Zy)r a@A chained contextual positioning statement.

    ``prefix``, ``glyphs``, and ``suffix`` should be lists of
    `glyph-containing objects`_ .

    ``lookups`` should be a list of elements representing what lookups
    to apply at each glyph position. Each element should be a
    :class:`LookupBlock` to apply a single chaining lookup at the given
    position, a list of :class:`LookupBlock`\ s to apply multiple
    lookups, or ``None`` to apply no lookup. The length of the outer
    list should equal the length of ``glyphs``; the inner lists can be
    of variable length.Nc��tj||�|||c|_|_|_t|�|_t|�D]\}}|s�		d�|D��y#t$r|g|j|<Y�1wxYw)Nc3� K�|]}|���y�wr�rN�rO�_s  rQrRz4ChainContextPosStatement.__init__.<locals>.<genexpr>������'�1�Q�'����	rBr�rSr�rTrW�lookupsr_�	TypeError�r�rSr�rTr~r��irms        rQr�z!ChainContextPosStatement.__init__��{�����4��*�06���-���T�[�$�+��G�}���"�7�+�	/�I�A�v��/�'��'�	/��!�/�'-�h�D�L�L��O�/���	A�A:�9A:c�^�|jD�cgc]}|j���}}|jD�cgc]}|j���}}|jD�cgc]}|j���}}|j	|j
||||j�ycc}wcc}wcc}w)z7Calls the builder's ``add_chain_context_pos`` callback.N)rSr�r�rT�add_chain_context_posr�r~�r�r�rYrSr�r�r�rTs        rQr�zChainContextPosStatement.build�s���(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4��%�%��M�M�6�6�6�4�<�<�	
��5��4��4��B �B%�B*c�,�d}t|j�s;t|j�s&t|jD�cgc]}|du��c}��rt|j�r(|djd�|jD��dzz
}t
|j�D]q\}}||j�dzz
}|j|r&|j|D]}|d|jzz
}�|t|j�dz
ks�m|dz
}�st|j�r\|ddjtt|j��zz
}n,|djtt|j��z
}|dz
}|Scc}w)N�pos r�c3�<K�|]}|j����y�wr�r��rOr�s  rQrRz1ChainContextPosStatement.asFea.<locals>.<genexpr>������?�a����	�?�rLr\� lookup r�r4�r�rSrT�anyr~rSr_r�r�r�r�r��r�r�r�r_r�r��lus       rQr�zChainContextPosStatement.asFea��N����������4�;�;���4�<�<�8�a�A�T�M�8�9��4�;�;���s�x�x�?�4�;�;�?�?�#�E�E��!�$�+�+�.�
���1��q�w�w�y�3��&���<�<��?�"�l�l�1�o�4���z�B�G�G�3�3��4��s�4�;�;�'�!�+�+��3�J�C�

��4�;�;���s�S�X�X�c�%����&=�>�>�>���3�8�8�C��t�z�z�2�3�3�C��s�
���
��!9��Fr�r�rrNrVrQr r �����	/�
�rVr c�&�eZdZdZdd�Zd�Zdd�Zy)r!aAA chained contextual substitution statement.

    ``prefix``, ``glyphs``, and ``suffix`` should be lists of
    `glyph-containing objects`_ .

    ``lookups`` should be a list of elements representing what lookups
    to apply at each glyph position. Each element should be a
    :class:`LookupBlock` to apply a single chaining lookup at the given
    position, a list of :class:`LookupBlock`\ s to apply multiple
    lookups, or ``None`` to apply no lookup. The length of the outer
    list should equal the length of ``glyphs``; the inner lists can be
    of variable length.Nc��tj||�|||c|_|_|_t|�|_t|�D]\}}|s�		d�|D��y#t$r|g|j|<Y�1wxYw)Nc3� K�|]}|���y�wr�rNrys  rQrRz6ChainContextSubstStatement.__init__.<locals>.<genexpr>r{r|r}r�s        rQr�z#ChainContextSubstStatement.__init__r�r�c�^�|jD�cgc]}|j���}}|jD�cgc]}|j���}}|jD�cgc]}|j���}}|j	|j
||||j�ycc}wcc}wcc}w)z9Calls the builder's ``add_chain_context_subst`` callback.N)rSr�r�rT�add_chain_context_substr�r~r�s        rQr�z ChainContextSubstStatement.builds���(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4��'�'��M�M�6�6�6�4�<�<�	
��5��4��4r�c�,�d}t|j�s;t|j�s&t|jD�cgc]}|du��c}��rt|j�r(|djd�|jD��dzz
}t
|j�D]q\}}||j�dzz
}|j|r&|j|D]}|d|jzz
}�|t|j�dz
ks�m|dz
}�st|j�r\|ddjtt|j��zz
}n,|djtt|j��z
}|dz
}|Scc}w)Nr[r�c3�<K�|]}|j����y�wr�r�r�s  rQrRz3ChainContextSubstStatement.asFea.<locals>.<genexpr>#r�rLr\r�r�r4r�r�s       rQr�z ChainContextSubstStatement.asFear�r�r�r�rrNrVrQr!r!�r�rVr!c�&�eZdZdZdd�Zd�Zdd�Zy)r$znA cursive positioning statement. Entry and exit anchors can either
    be :class:`Anchor` objects or ``None``.Nc�\�tj||�||_||c|_|_yr�)rBr�r��entryAnchor�
exitAnchor)r�r�r�r�r�s     rQr�zCursivePosStatement.__init__7s*�����4��*�$���,7��)���$�/rVc��|j|j|jj�|j|j
�y)z8Calls the builder object's ``add_cursive_pos`` callback.N)�add_cursive_posr�r�r�r�r�r�s  rQr�zCursivePosStatement.build<s4������M�M�4�?�?�3�3�5�t�7G�7G����	
rVc��|jr|jj�nd}|jr|jj�nd}dj|jj�||�S)N�
<anchor NULL>zpos cursive {} {} {};)r�r�r�r�r�)r�r��entry�exits    rQr�zCursivePosStatement.asFeaBs\��,0�,<�,<�� � �&�&�(�/��*.�/�/�t���$�$�&���&�-�-�d�o�o�.C�.C�.E�u�d�S�SrVr�r�rrNrVrQr$r$3s��/�D�

�TrVr$c�&�eZdZdZdd�Zd�Zdd�Zy)r)zExample: ``feature salt;``Nc�N�tj||�||c|_|_yr�)rBr�r��featureName)r�r�r�s   rQr�z"FeatureReferenceStatement.__init__Ks#�����4��*�+3�[�'��
�t�'rVc�P�|j|j|j�y)z>Calls the builder object's ``add_feature_reference`` callback.N)�add_feature_referencer�r�r�s  rQr�zFeatureReferenceStatement.buildOs���%�%�d�m�m�T�5E�5E�FrVc�8�dj|j�S)Nzfeature {};)r�r�r�s  rQr�zFeatureReferenceStatement.asFeaSs���#�#�D�$4�$4�5�5rVr�r�rrNrVrQr)r)Hs��$�B�G�6rVr)c�&�eZdZdZdd�Zd�Zdd�Zy)r,z�An ``ignore pos`` statement, containing `one or more` contexts to ignore.

    ``chainContexts`` should be a list of ``(prefix, glyphs, suffix)`` tuples,
    with each of ``prefix``, ``glyphs`` and ``suffix`` being
    `glyph-containing objects`_ .Nc�>�tj||�||_yr��rBr��
chainContexts�r�r�r�s   rQr�zIgnorePosStatement.__init__^������4��*�*��rVc�8�|jD]|\}}}|D�cgc]}|j���}}|D�cgc]}|j���}}|D�cgc]}|j���}}|j|j|||g��~ycc}wcc}wcc}w)z[Calls the builder object's ``add_chain_context_pos`` callback on each
        rule context.N)r�r�r�r��r�r�rSr�rTrYr�r�s        rQr�zIgnorePosStatement.buildbs���'+�&8�&8�	U�"�F�F�F�,2�3�q�a�j�j�l�3�F�3�,2�3�q�a�j�j�l�3�F�3�,2�3�q�a�j�j�l�3�F�3��)�)�$�-�-����QS�T�		U��3��3��3��B
�B�Bc	���g}|jD]�\}}}d}t|�st|�r|t|�r%|djtt|��dzz
}|djd�|D��z
}t|�rH|ddjtt|��zz
}n"|djtt|��z
}|j|���ddj|�zdzS)Nr�r�c3�BK�|]}|j�dz���y�w�r\Nr�r�s  rQrRz+IgnorePosStatement.asFea.<locals>.<genexpr>rs����@�A����	�C��@���zignore pos rLr4�r�r�rSr�r�r��r�r��contextsrSr�rTr�s       rQr�zIgnorePosStatement.asFeaks�����&*�&8�&8�
	!�"�F�F�F��C��6�{�c�&�k��v�;��3�8�8�C��v�$6�7�#�=�=�C��s�x�x�@��@�@�@���v�;��3����#�e�V�*<�!=�=�=�C��s�x�x��E�6� 2�3�3���O�O�C� �
	!��t�y�y��2�2�S�8�8rVr�r�rrNrVrQr,r,Ws��%�+�U�
9rVr,c�&�eZdZdZdd�Zd�Zdd�Zy)r-z�An ``ignore sub`` statement, containing `one or more` contexts to ignore.

    ``chainContexts`` should be a list of ``(prefix, glyphs, suffix)`` tuples,
    with each of ``prefix``, ``glyphs`` and ``suffix`` being
    `glyph-containing objects`_ .Nc�>�tj||�||_yr�r�r�s   rQr�zIgnoreSubstStatement.__init__�r�rVc�8�|jD]|\}}}|D�cgc]}|j���}}|D�cgc]}|j���}}|D�cgc]}|j���}}|j|j|||g��~ycc}wcc}wcc}w)z]Calls the builder object's ``add_chain_context_subst`` callback on
        each rule context.N)r�r�r�r�r�s        rQr�zIgnoreSubstStatement.build�s���'+�&8�&8�	W�"�F�F�F�,2�3�q�a�j�j�l�3�F�3�,2�3�q�a�j�j�l�3�F�3�,2�3�q�a�j�j�l�3�F�3��+�+�D�M�M�6�6�6�SU�V�		W��3��3��3r�c	�z�g}|jD]�\}}}d}t|�r%|djtt|��dzz
}|djd�|D��z
}t|�r%|ddjtt|��zz
}|j|���ddj|�zdzS)Nr�r�c3�BK�|]}|j�dz���y�wr�r�r�s  rQrRz-IgnoreSubstStatement.asFea.<locals>.<genexpr>�s����<��A�G�G�I��O�<�r�zignore sub rLr4r�r�s       rQr�zIgnoreSubstStatement.asFea�s�����&*�&8�&8�	!�"�F�F�F��C��6�{��s�x�x��E�6� 2�3�c�9�9���3�8�8�<�V�<�<�<�C��6�{��s�S�X�X�c�%��&8�9�9�9���O�O�C� �	!��t�y�y��2�2�S�8�8rVr�r�rrNrVrQr-r-{s��%�+�W�
9rVr-c�2��eZdZdZd�fd�	Zd�Zdd�Z�xZS)r.zAn ``include()`` statement.c�:��tt|�|�||_yr�)r�r.r��filename)r�r�r�r�s   �rQr�zIncludeStatement.__init__�s���
���.�x�8� ��
rVc�.�td|j��)NzqBuilding an include statement is not implemented yet. Instead, use Parser(..., followIncludes=True) for building.)rr�r�s rQr�zIncludeStatement.build�s���
J��M�M�
�	
rVc�&�|d|jzzS)Nzinclude(%s);)r�r�s  rQr�zIncludeStatement.asFea�s�������6�6�6rVr�r�)r�r�r�r�r�r�r�r�r�s@rQr.r.�s���%�!�
�7rVr.c�&�eZdZdZdd�Zd�Zdd�Zy)r/z*A ``language`` statement within a feature.Nc�z�tj||�t|�dk(sJ�||_||_||_y)N�)rBr�r�rk�include_defaultrw)r�rkr�rwr�s     rQr�zLanguageStatement.__init__�s:�����4��*��8�}��!�!�!� ��
�.��� ��
rVc�~�|j|j|j|j|j��y)z4Call the builder object's ``set_language`` callback.)r�rkr�rwN)�set_languager�rkr�rwr�s  rQr�zLanguageStatement.build�s3������]�]��]�]� �0�0��]�]�		�	
rVc��dj|jj��}|js|dz
}|jr|dz
}|dz
}|S)Nzlanguage {}z
 exclude_dfltz	 requiredr4)r�rkrr�rwr�s   rQr�zLanguageStatement.asFea�sQ���"�"�4�=�=�#6�#6�#8�9���#�#��?�"�C��=�=��;��C��s�
���
rV)TFNr�rrNrVrQr/r/�s��4�!�
�rVr/c�&�eZdZdZdd�Zd�Zdd�Zy)r0z)A top-level ``languagesystem`` statement.Nc�N�tj||�||c|_|_yr�)rBr�r{rk)r�r{rkr�s    rQr�z LanguageSystemStatement.__init__�s"�����4��*�&,�h�"���T�]rVc�f�|j|j|j|j�y)z<Calls the builder object's ``add_language_system`` callback.N)�add_language_systemr�r{rkr�s  rQr�zLanguageSystemStatement.build�s ���#�#�D�M�M�4�;�;��
�
�NrVc�j�dj|j|jj��S)Nzlanguagesystem {} {};)r�r{rkrr�s  rQr�zLanguageSystemStatement.asFea�s&��&�-�-�d�k�k�4�=�=�;N�;N�;P�Q�QrVr�r�rrNrVrQr0r0�s��3�8�O�RrVr0c�&�eZdZdZdd�Zd�Zdd�Zy)r*z�A ``head`` table ``FontRevision`` statement. ``revision`` should be a
    number, and will be formatted to three significant decimal places.Nc�>�tj||�||_yr�)rBr��revision)r�r�r�s   rQr�zFontRevisionStatement.__init__�s�����4��*� ��
rVc�P�|j|j|j�yr�)�set_font_revisionr�r�r�s  rQr�zFontRevisionStatement.build�s���!�!�$�-�-����?rVc�8�dj|j�S)NzFontRevision {:.3f};)r�r�r�s  rQr�zFontRevisionStatement.asFea�s��%�,�,�T�]�]�;�;rVr�r�rrNrVrQr*r*�s��J�!�@�<rVr*c�&�eZdZdZdd�Zd�Zdd�Zy)r1z�A ``GDEF`` table ``LigatureCaretByIndex`` statement. ``glyphs`` should be
    a `glyph-containing object`_, and ``carets`` should be a list of integers.Nc�N�tj||�||c|_|_yr��rBr�r��carets�r�r�r�r�s    rQr�z&LigatureCaretByIndexStatement.__init__��"�����4��*�$*�F� ���T�[rVc��|jj�}|j|j|t	|j
��y)zBCalls the builder object's ``add_ligatureCaretByIndex_`` callback.N)r�r��add_ligatureCaretByIndex_r��setr�ros   rQr�z#LigatureCaretByIndexStatement.build�s3�����%�%�'���)�)�$�-�-���T�[�[�AQ�RrVc��dj|jj�djd�|jD���S)NzLigatureCaretByIndex {} {};r�c3�2K�|]}t|����y�wr�rr�rOr_s  rQrRz6LigatureCaretByIndexStatement.asFea.<locals>.<genexpr>������)F�Q�#�a�&�)F�ru�r�r�r�rSr�r�s  rQr�z#LigatureCaretByIndexStatement.asFea�s:��,�3�3��K�K�������)F�$�+�+�)F�!F�
�	
rVr�r�rrNrVrQr1r1�s��R�4�S�

rVr1c�&�eZdZdZdd�Zd�Zdd�Zy)r2z�A ``GDEF`` table ``LigatureCaretByPos`` statement. ``glyphs`` should be
    a `glyph-containing object`_, and ``carets`` should be a list of integers.Nc�N�tj||�||c|_|_yr�r�r�s    rQr�z$LigatureCaretByPosStatement.__init__r�rVc��|jj�}|j|j|t	|j
��y)z@Calls the builder object's ``add_ligatureCaretByPos_`` callback.N)r�r��add_ligatureCaretByPos_r�r�r�ros   rQr�z!LigatureCaretByPosStatement.builds3�����%�%�'���'�'��
�
�v�s�4�;�;�?O�PrVc��dj|jj�djd�|jD���S)NzLigatureCaretByPos {} {};r�c3�2K�|]}t|����y�wr�rrr�s  rQrRz4LigatureCaretByPosStatement.asFea.<locals>.<genexpr>r�rur�r�s  rQr�z!LigatureCaretByPosStatement.asFea
s:��*�1�1��K�K�������)F�$�+�+�)F�!F�
�	
rVr�r�rrNrVrQr2r2�s��R�4�Q�

rVr2c�&�eZdZdZdd�Zd�Zdd�Zy)r3aSA chained contextual substitution statement.

    ``prefix``, ``glyphs``, and ``suffix`` should be lists of
    `glyph-containing objects`_; ``replacement`` should be a single
    `glyph-containing object`_.

    If ``forceChain`` is True, this is expressed as a chaining rule
    (e.g. ``sub f' i' by f_i``) even when no context is given.Nc�z�tj||�|||c|_|_|_||c|_|_yr�)rBr�rSr�rTrU�
forceChain)r�rSr�rTrUr�r�s       rQr�zLigatureSubstStatement.__init__s9�����4��*�17���-���T�[�$�+�,7��)���$�/rVc�t�|jD�cgc]}|j���}}|jD�cgc]}|j���}}|jD�cgc]}|j���}}|j	|j
||||j|j�ycc}wcc}wcc}wr�)rSr�r�rT�add_ligature_substr�rUr�r�s        rQr�zLigatureSubstStatement.builds���(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4��"�"��M�M�6�6�6�4�3C�3C�T�_�_�	
��5��4��4s�B+�B0�B5c�D�d}t|j�s!t|j�s|jr�t|j�r(|dj	d�|jD��dzz
}|dj	d�|j
D��z
}t|j�rN|ddj	d�|jD��zz
}n%|dj	d�|j
D��z
}|dz
}|t
|j�z
}|dz
}|S)	Nr[r�c3�<K�|]}|j����y�wr�r�r�s  rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>+r�rLc3�BK�|]}|j�dz���y�wr�r�r�s  rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>,s����A��A�G�G�I��O�A�r�c3�<K�|]}|j����y�wr�r�r�s  rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>.s����%E�A�a�g�g�i�%E�rLc3�<K�|]}|j����y�wr�r�r�s  rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>0s����;�!�A�G�G�I�;�rL� by r4)r�rSrTr�rSr�r�rUr�s   rQr�zLigatureSubstStatement.asFea's������t�{�{��s�4�;�;�/�4�?�?��4�;�;���s�x�x�?�4�;�;�?�?�#�E�E���3�8�8�A�T�[�[�A�A�A�C��4�;�;���s�S�X�X�%E����%E�E�E�E���3�8�8�;�t�{�{�;�;�;�C��v�
���u�T�%�%�&�&���s�
���
rVr�r�rrNrVrQr3r3s��B�D�

�
rVr3c�(�eZdZdZ	dd�Zd�Zdd�Zy)r4z�A ``lookupflag`` statement. The ``value`` should be an integer value
    representing the flags in use, but not including the ``markAttachment``
    class and ``markFilteringSet`` values, which must be specified as
    glyph-containing objects.Nc�Z�tj||�||_||_||_yr�)rBr�r�markAttachment�markFilteringSet)r�rr�r�r�s     rQr�zLookupFlagStatement.__init__=s+��	���4��*���
�,��� 0��rVc���d}|j�|jj�}d}|j�|jj�}|j|j|j
||�y)z8Calls the builder object's ``set_lookup_flag`` callback.N)r�r�r��set_lookup_flagr�r)r�r��
markAttach�
markFilters    rQr�zLookupFlagStatement.buildEsh���
����*��,�,�5�5�7�J��
�� � �,��.�.�7�7�9�J�����
�
�t�z�z�:�z�RrVc���g}gd�}d}tt|��D]-}|j|zdk7r|j||�|dz}�/|j�8|jdj|jj
���|j�8|jdj|jj
���|sdg}djdj|��S)	N)�RightToLeft�IgnoreBaseGlyphs�IgnoreLigatures�IgnoreMarksr�rzMarkAttachmentType {}zUseMarkFilteringSet {}�0zlookupflag {};r�)	�ranger�rr�r�r�r�r�rS)r�r�r��flagsr�r�s      rQr�zLookupFlagStatement.asFeaOs�����U�����s�5�z�"�	�A��z�z�D� �A�%��
�
�5��8�$��1�9�D�	����*��J�J�.�5�5�d�6I�6I�6O�6O�6Q�R�S�� � �,��J�J�/�6�6�t�7L�7L�7R�7R�7T�U�V���%�C��&�&�s�x�x��}�5�5rV)rNNNr�rrNrVrQr4r47s��!�MQ�1�S�6rVr4c�&�eZdZdZdd�Zd�Zdd�Zy)r5z�Represents a ``lookup ...;`` statement to include a lookup in a feature.

    The ``lookup`` should be a :class:`LookupBlock` object.Nc�N�tj||�||c|_|_yr�)rBr�r�rm)r�rmr�s   rQr�z!LookupReferenceStatement.__init__es"�����4��*�&.��"��
�t�{rVc�N�|j|jj�y)z8Calls the builder object's ``add_lookup_call`` callback.N)�add_lookup_callrmr�r�s  rQr�zLookupReferenceStatement.buildis�������� 0� 0�1rVc�L�dj|jj�S)Nz
lookup {};)r�rmr�r�s  rQr�zLookupReferenceStatement.asFeams���"�"�4�;�;�#3�#3�4�4rVr�r�rrNrVrQr5r5`s��?�8�2�5rVr5c�&�eZdZdZdd�Zd�Zdd�Zy)r6z�A mark-to-base positioning rule. The ``base`` should be a
    `glyph-containing object`_. The ``marks`` should be a list of
    (:class:`Anchor`, :class:`MarkClass`) tuples.Nc�N�tj||�||c|_|_yr�)rBr�r��marks)r�r�rr�s    rQr�zMarkBasePosStatement.__init__vs"�����4��*� $�e���	�4�:rVc��|j|j|jj�|j�y)z:Calls the builder object's ``add_mark_base_pos`` callback.N)�add_mark_base_posr�r�r�rr�s  rQr�zMarkBasePosStatement.buildzs)���!�!�$�-�-����1C�1C�1E�t�z�z�RrVc��dj|jj��}|jD]?\}}|d|ztzdj|j�|j
�zz
}�A|dz
}|S)Nzpos base {}r�{} mark @{}r4)r�r�r�rrr��r�r�r��a�ms     rQr�zMarkBasePosStatement.asFea~ss���"�"�4�9�9�?�?�#4�5���J�J�	S�D�A�q��4�&�=�5�(�=�+?�+?����	�1�6�6�+R�R�R�C�	S��s�
���
rVr�r�rrNrVrQr6r6qs��5�,�S�rVr6c�&�eZdZdZdd�Zd�Zdd�Zy)r7a�A mark-to-ligature positioning rule. The ``ligatures`` must be a
    `glyph-containing object`_. The ``marks`` should be a list of lists: each
    element in the top-level list represents a component glyph, and is made
    up of a list of (:class:`Anchor`, :class:`MarkClass`) tuples representing
    mark attachment points for that position.

    Example::

        m1 = MarkClass("TOP_MARKS")
        m2 = MarkClass("BOTTOM_MARKS")
        # ... add definitions to mark classes...

        glyph = GlyphName("lam_meem_jeem")
        marks = [
            [ (Anchor(625,1800), m1) ], # Attachments on 1st component (lam)
            [ (Anchor(376,-378), m2) ], # Attachments on 2nd component (meem)
            [ ]                         # No attachments on the jeem
        ]
        mlp = MarkLigPosStatement(glyph, marks)

        mlp.asFea()
        # pos ligature lam_meem_jeem <anchor 625 1800> mark @TOP_MARKS
        # ligComponent <anchor 376 -378> mark @BOTTOM_MARKS;

    Nc�N�tj||�||c|_|_yr�)rBr��	ligaturesr)r�rrr�s    rQr�zMarkLigPosStatement.__init__��"�����4��*�%.��"����
rVc��|j|j|jj�|j�y)z9Calls the builder object's ``add_mark_lig_pos`` callback.N)�add_mark_lig_posr�rr�rr�s  rQr�zMarkLigPosStatement.build�s)��� � �������0G�0G�0I�4�:�:�VrVc��dj|jj��}g}|jD]|}d}|�t	|�sd|zt
dzzdz}nG|D]B\}}|d|zt
dzzdj|j�|j�zz
}�D|j|��~|d|zt
zdzj|�z
}|dz
}|S)	Nzpos ligature {}r�rr�r�r�ligComponentr4)	r�rr�rr�rr�r�rS)r�r�r��ligs�l�temprrs        rQr�zMarkLigPosStatement.asFea�s����&�&�t�~�~�';�';�'=�>�������	�A��D��y��A���f�}�u�q�y�0�?�B����D�A�q��� �!��!�)�$�(�.�.�q�w�w�y�!�&�&�A�B��D��
�K�K���	�	��v�
��%��6�<�<�T�B�B���s�
���
rVr�r�rrNrVrQr7r7�s���46�W�rVr7c�&�eZdZdZdd�Zd�Zdd�Zy)r8z�A mark-to-mark positioning rule. The ``baseMarks`` must be a
    `glyph-containing object`_. The ``marks`` should be a list of
    (:class:`Anchor`, :class:`MarkClass`) tuples.Nc�N�tj||�||c|_|_yr�)rBr��	baseMarksr)r�r#rr�s    rQr�zMarkMarkPosStatement.__init__�rrVc��|j|j|jj�|j�y)z:Calls the builder object's ``add_mark_mark_pos`` callback.N)�add_mark_mark_posr�r#r�rr�s  rQr�zMarkMarkPosStatement.build�s)���!�!�$�-�-����1H�1H�1J�D�J�J�WrVc��dj|jj��}|jD]?\}}|d|ztzdj|j�|j
�zz
}�A|dz
}|S)Nzpos mark {}rrr4)r�r#r�rrr�rs     rQr�zMarkMarkPosStatement.asFea�su���"�"�4�>�>�#7�#7�#9�:���J�J�	S�D�A�q��4�&�=�5�(�=�+?�+?����	�1�6�6�+R�R�R�C�	S��s�
���
rVr�r�rrNrVrQr8r8�s��5�6�X�rVr8c�(�eZdZdZ	dd�Zd�Zdd�Zy)r9a�A multiple substitution statement.

    Args:
        prefix: a list of `glyph-containing objects`_.
        glyph: a single glyph-containing object.
        suffix: a list of glyph-containing objects.
        replacement: a list of glyph-containing objects.
        forceChain: If true, the statement is expressed as a chaining rule
            (e.g. ``sub f' i' by f_i``) even when no context is given.
    Nc�x�tj||�|||c|_|_|_||_||_yr�)rBr�rSr�rTrUr�)r�rSr�rTrUr�r�s       rQr�zMultipleSubstStatement.__init__�s9��	���4��*�/5�u�f�,���T�Z���&���$��rVc	��|jD�cgc]}|j���}}|jD�cgc]}|j���}}t|jd�r|jj�}n
|jg}t|�}g}|jD]T}	t|	d�r|	j�}
n|	g}
t|
�dk(rt|
�|k7r|
|z}
|j|
��Vtt|��}t�}t|�D]P\}}
|
|vs�|j|
�|j|j||
||xr||xsd|j��Rycc}wcc}w)z;Calls the builder object's ``add_multiple_subst`` callback.r�r�rNN)rSr�rTr�r�r�rUr�rW�zipr�r_�add�add_multiple_substr�r�)r�r�rYrSr�rT�	originals�count�replaces�r�replace�seen_originalsr�r�s              rQr�zMultipleSubstStatement.build�sU��(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4��4�:�:�z�*��
�
�+�+�-�I�����I��I������!�!�	%�A��q�*�%��*�*�,���#���7�|�q� �S��\�U�%:�!�E�/���O�O�G�$�	%���X��'�����$�Y�/�
	�K�A�x��~�-��"�"�8�,��*�*��M�M�����,��!��2���O�O�
�
	��'5��4s
�E7�E<c�x�d}t|j�s!t|j�s|jr�t|j�r/|dj	tt|j��dzz
}|t
|j�dzz
}t|j�rH|ddj	tt|j��zz
}n|t
|j�z
}|jxst�g}|dz
}|dj	tt|��z
}|dz
}|S)Nr[r�r\r�r4)
r�rSrTr�rSr�r�r�rUr�)r�r�r�rUs    rQr�zMultipleSubstStatement.asFeas������t�{�{��s�4�;�;�/�4�?�?��4�;�;���s�x�x��E�4�;�;� 7�8�3�>�>���5����$�s�*�*�C��4�;�;���s�S�X�X�c�%����&=�>�>�>���5����$�$�C��&�&�7�9�;�-���v�
���s�x�x��E�;�/�0�0���s�
���
rVrr�rrNrVrQr9r9�s��	�NR�%��BrVr9c�*�eZdZdZ		dd�Zd�Zdd�Zy)r<a�A pair positioning statement.

    ``glyphs1`` and ``glyphs2`` should be `glyph-containing objects`_.
    ``valuerecord1`` should be a :class:`ValueRecord` object;
    ``valuerecord2`` should be either a :class:`ValueRecord` object or ``None``.
    If ``enumerated`` is true, then this is expressed as an
    `enumerated pair <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#6.b.ii>`_.
    Nc�z�tj||�||_||c|_|_||c|_|_yr�)rBr��
enumerated�glyphs1�valuerecord1�glyphs2�valuerecord2)r�r7r8r9r:r6r�s       rQr�zPairPosStatement.__init__#s=��	���4��*�$���*1�<�'���d�'�*1�<�'���d�'rVc�F�|jr�|jj�|jj�g}d}t	j
|�D]:\}}d}|j
|j||j||j��<|std|j��yt|jt�xrt|jt�}|r\|j
|j|jj|j|jj|j�y|j|j|jj�|j|jj�|j�y)aMCalls a callback on the builder object:

        * If the rule is enumerated, calls ``add_specific_pair_pos`` on each
          combination of first and second glyphs.
        * If the glyphs are both single :class:`GlyphName` objects, calls
          ``add_specific_pair_pos``.
        * Else, calls ``add_class_pair_pos``.
        FTz%Empty glyph class in positioning ruleN)r6r7r�r9�	itertools�product�add_specific_pair_posr�r8r:rr�rr��add_class_pair_pos)r�r�r��	seen_pair�glyph1�glyph2�is_specifics       rQr�zPairPosStatement.build1sT���?�?����&�&�(�$�,�,�*?�*?�*A�B�A��I�"+�"3�"3�Q�"7�
���� �	��-�-��M�M�6�4�+<�+<�f�d�FW�FW��
�
�%�;�T�]�]���
� ����y�9�
�j��L�L�)�?
����)�)��
�
����"�"��!�!����"�"��!�!�
�
�&�&��
�
����%�%�'��!�!����%�%�'��!�!�
rVc���|jrdnd}|jry|dj|jj	�|j
j	�|jj	�|jj	��z
}|S|dj|jj	�|jj	�|j
j	��z
}|S)Nzenum r�zpos {} {} {} {};z
pos {} {} {};)r6r:r�r7r�r8r9r�s   rQr�zPairPosStatement.asFea\s������g�b������%�,�,����"�"�$��!�!�'�'�)����"�"�$��!�!�'�'�)�	�
�C��
�
�?�)�)����"�"�$�d�l�l�&8�&8�&:�D�<M�<M�<S�<S�<U��
�C��
rVrr�rrNrVrQr<r<s �����@�)�V
rVr<c�&�eZdZdZdd�Zd�Zdd�Zy)r=aPA reverse chaining substitution statement. You don't see those every day.

    Note the unusual argument order: ``suffix`` comes `before` ``glyphs``.
    ``old_prefix``, ``old_suffix``, ``glyphs`` and ``replacements`` should be
    lists of `glyph-containing objects`_. ``glyphs`` and ``replacements`` should
    be one-item lists.
    Nc�j�tj||�||c|_|_||_||_yr�)rBr��
old_prefix�
old_suffixr��replacements)r�rGrHr�rIr�s      rQr�z)ReverseChainSingleSubstStatement.__init__us1�����4��*�+5�z�(��������(��rVc���|jD�cgc]}|j���}}|jD�cgc]}|j���}}|jdj�}|jdj�}t|�dk(r|t|�z}|j
|j||tt||���ycc}wcc}w)Nrr�)
rGr�rHr�rIr��add_reverse_chain_single_substr��dictr*�r�r�rYrSr�rTr-r/s        rQr�z&ReverseChainSingleSubstStatement.build{s���(,���8�1�!�*�*�,�8��8�(,���8�1�!�*�*�,�8��8��K�K��N�+�+�-�	��$�$�Q�'�0�0�2���x�=�A���#�i�.�0�H��.�.��M�M�6�6�4��I�x�0H�+I�	
��
9��8s
�C�Cc�^�d}t|j�st|j�r�t|j�r(|djd�|jD��dzz
}|djd�|jD��z
}t|j�rU|ddjd�|jD��zz
}n,|djtt|j��z
}|djdjd�|jD���z
}|S)Nzrsub r�c3�2K�|]}t|����y�wr�r�r�s  rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>�s����B�Q��a��B�ruc3�8K�|]}t|�dz���y�wr�r�r�s  rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>������@�q�E�!�H�s�N�@���c3�2K�|]}t|����y�wr�r�r�s  rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>�s����%H�1�e�A�h�%H�ru� by {};c3�2K�|]}t|����y�wr�r�r�s  rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>������(M�a��q��(M�ru)	r�rGrHrSr�r�r�r�rIr�s   rQr�z&ReverseChainSingleSubstStatement.asFea�s������t����3�t���#7��4�?�?�#��s�x�x�B�$�/�/�B�B�S�H�H���3�8�8�@�D�K�K�@�@�@�C��4�?�?�#��s�S�X�X�%H����%H�H�H�H���3�8�8�C��t�{�{�3�4�4�C��y������(M�4�;L�;L�(M� M�N�N���
rVr�r�rrNrVrQr=r=ls���)�	
�rVr=c�&�eZdZdZdd�Zd�Zdd�Zy)r@a.A single substitution statement.

    Note the unusual argument order: ``prefix`` and suffix come `after`
    the replacement ``glyphs``. ``prefix``, ``suffix``, ``glyphs`` and
    ``replace`` should be lists of `glyph-containing objects`_. ``glyphs`` and
    ``replace`` should be one-item lists.
    Nc�x�tj||�||c|_|_||_||_||_yr�)rBr�rSrTr�r�rI)r�r�r1rSrTr�r�s       rQr�zSingleSubstStatement.__init__�s8�����4��*�#)�6� ���T�[�$������#��rVc���|jD�cgc]}|j���}}|jD�cgc]}|j���}}|jdj�}|jdj�}t|�dk(r|t|�z}|j
|j||tt||��|j�ycc}wcc}w)z9Calls the builder object's ``add_single_subst`` callback.rr�N)rSr�rTr�rIr��add_single_substr�rr*r�rMs        rQr�zSingleSubstStatement.build�s���(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4��K�K��N�+�+�-�	��$�$�Q�'�0�0�2���x�=�A���#�i�.�0�H�� � ��M�M�����I�x�0�1��O�O�	
��
5��4s
�C"�C'c�h�d}t|j�s!t|j�s|jr�t|j�r(|dj	d�|jD��dzz
}|dj	d�|j
D��z
}t|j�rN|ddj	d�|jD��zz
}n%|dj	d�|j
D��z
}|dj
dj	d�|jD���z
}|S)	Nr[r�c3�2K�|]}t|����y�wr�r�r�s  rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�s����>�Q��a��>�ruc3�8K�|]}t|�dz���y�wr�r�r�s  rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�rQrRc3�2K�|]}t|����y�wr�r�r�s  rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�s����%D�1�e�A�h�%D�ruc3�2K�|]}t|����y�wr�r�r�s  rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�s����:��E�!�H�:�rurTc3�2K�|]}t|����y�wr�r�r�s  rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�rVru)r�rSrTr�rSr�r�rIr�s   rQr�zSingleSubstStatement.asFea�s������t�{�{��s�4�;�;�/�4�?�?��4�;�;���s�x�x�>�$�+�+�>�>��D�D���3�8�8�@�D�K�K�@�@�@�C��4�;�;���s�S�X�X�%D����%D�D�D�D���3�8�8�:�d�k�k�:�:�:�C��y������(M�4�;L�;L�(M� M�N�N���
rVr�r�rrNrVrQr@r@�s���$�
� rVr@c�&�eZdZdZdd�Zd�Zdd�Zy)r>zA ``script`` statement.Nc�>�tj||�||_yr�)rBr�r{)r�r{r�s   rQr�zScriptStatement.__init__�s�����4��*���rVc�P�|j|j|j�y)z,Calls the builder's ``set_script`` callback.N)�
set_scriptr�r{r�s  rQr�zScriptStatement.build�s�����4�=�=�$�+�+�6rVc�T�dj|jj��S)Nz
script {};)r�r{rr�s  rQr�zScriptStatement.asFea�s ���"�"�4�;�;�#4�#4�#6�7�7rVr�r�rrNrVrQr>r>�s��!��7�8rVr>c�&�eZdZdZdd�Zd�Zdd�Zy)r?z�A single position statement. ``prefix`` and ``suffix`` should be
    lists of `glyph-containing objects`_.

    ``pos`` should be a one-element list containing a (`glyph-containing object`_,
    :class:`ValueRecord`) tuple.Nc�j�tj||�|||c|_|_|_||_yr�)rBr�rurSrTr�)r�rurSrTr�r�s      rQr�zSinglePosStatement.__init__�s/�����4��*�-0�&�&�*���$�+�t�{�$��rVc�n�|jD�cgc]}|j���}}|jD�cgc]}|j���}}|jD��cgc]\}}|j�|f��}}}|j	|j
||||j�ycc}wcc}wcc}}w)z7Calls the builder object's ``add_single_pos`` callback.N)rSr�rTru�add_single_posr�r�)	r�r�rYrSr�rTr�rrus	         rQr�zSinglePosStatement.build�s���(,���4�1�!�*�*�,�4��4�(,���4�1�!�*�*�,�4��4�59�X�X�>���E��
�
��e�$�>��>����t�}�}�f�f�c�4�?�?�S��5��4��>s�B'�B,�B1c
��d}t|j�s!t|j�s|jr�t|j�r/|dj	tt|j��dzz
}|dj	|jD�cgc]1}t
|d�dz|drd|dj
�zndz��3c}�z
}t|j�r�|ddj	tt|j��zz
}nV|dj	|jD�cgc].}t
|d�dz|dr|dj
�ndz��0c}�z
}|dz
}|Scc}wcc}w)Nr�r�rr\r�r�r4)r�rSrTr�rSr�r�ru)r�r�r�r_s    rQr�zSinglePosStatement.asFea�sD�����t�{�{��s�4�;�;�/�4�?�?��4�;�;���s�x�x��E�4�;�;� 7�8�3�>�>���3�8�8�"�X�X����!�A�$�K�#�%��1��#��!��
�
��*<�2�N���
�C��4�;�;���s�S�X�X�c�%����&=�>�>�>���3�8�8�MQ�X�X�V���q��t��s�"�a��d�a��d�j�j�l��C�V��
�C�	�s�
���
����Ws�6E8
�53E=
r�r�rrNrVrQr?r?�s��$�%�
T�rVr?c�&�eZdZdZdd�Zd�Zdd�Zy)rFzRepresents a subtable break.Nc�0�tj||�yr�)rBr�r�s  rQr�zSubtableStatement.__init__�s�����4��*rVc�:�|j|j�y)z<Calls the builder objects's ``add_subtable_break`` callback.N)�add_subtable_breakr�r�s  rQr�zSubtableStatement.build�s���"�"�4�=�=�1rVc��y)Nz	subtable;rNr�s  rQr�zSubtableStatement.asFeas��rVr�r�rrNrVrQrFrF�s��&�+�2�rVrFc�P�eZdZdZ										d	d�Zd�Zd�Zd�Zd
d�Zd�Z	e	Z
y)rHzRepresents a value record.Nc��tj||
�||c|_|_||c|_|_||c|_|_||c|_|_	|	|_
yr�)r'r��
xPlacement�
yPlacement�xAdvance�yAdvance�
xPlaDevice�
yPlaDevice�
xAdvDevice�
yAdvDevice�vertical)r�rrrsrtrurvrwrxryrzr�s           rQr�zValueRecord.__init__
s[��	���D�(�+�,6�
�(�����(0�(�$��
�t�}�,6�
�(�����,6�
�(����� ��
rVc�B�|j|jk(xr�|j|jk(xrj|j|jk(xrO|j|jk(xr4|j|jk(xr|j
|j
k(Sr�)rrrsrtrurvrx�r��others  rQ�__eq__zValueRecord.__eq__s����O�O�u�/�/�/�
4����5�#3�#3�3�
4��
�
����/�
4��
�
����/�
4����5�#3�#3�3�	
4�
���5�#3�#3�3�
	
rVc�&�|j|�Sr�)r~r|s  rQ�__ne__zValueRecord.__ne__(s���;�;�u�%�%�%rVc�`�t|j�t|j�zt|j�zt|j�zt|j
�zt|j�zt|j�zt|j�zSr�)	�hashrrrsrtrurvrwrxryr�s rQ�__hash__zValueRecord.__hash__+s�������!��4�?�?�#�
$��4�=�=�!�
"��4�=�=�!�
"��4�?�?�#�	
$�
�4�?�?�#�
$��4�?�?�#�

$��4�?�?�#�
$�		
rVc��|sy|j|j}}|j|j}}|j|j
}}|j|j}	}|j}
|� |�|�
|
rt|�S|�
|
st|�S|xsd}|xsd}|xsd}|xsd}|�|�|�|	�d|�d|�d|�d|�d�	Sd|�d|�d|�d|�dt|��dt|��dt|��dt|	��d�S)Nz<NULL>r�<r�rf)rrrsrtrurvrwrxryrzrsrU)r�r�r_r`rtrurvrwrxryrzs           rQr�zValueRecord.asFea7s����������1��!�]�]�D�M�M�(��!%���$�/�/�J�
�!%���$�/�/�J�
��=�=��
�9�����H��8�}�$��!�(��8�}�$�
�F���
�F����=�q���=�q��
���"��"��"�&'��H�h�?�?��
�
����:�&��:�&��:�&��:�&�	
�		
rVc�,��t�fd�dD��S)Nc3�:�K�|]}t�|�du���y�wr�)�getattr)rO�vr�s  �rQrRz'ValueRecord.__bool__.<locals>.<genexpr>ds%�����
��
�D�!��D�(�
�s�)rrrsrtrurvrwrxry)r�r�s`rQ�__bool__zValueRecord.__bool__cs����
�	�
�
�	
rV)
NNNNNNNNFNr�)r�r�r�r�r�r~r�r�r�r��__nonzero__rNrVrQrHrHsK��$�����������!�(
�&�

�*
�X

��KrVrHc� �eZdZdZdd�Zdd�Zy)rIz+Represents a named value record definition.Nc�L�tj||�||_||_yr�)rBr�r�r)r�r�rr�s    rQr�zValueRecordDefinition.__init__xs �����4��*���	���
rVc�j�dj|jj�|j�S)NzvalueRecordDef {} {};)r�rr�r�r�s  rQr�zValueRecordDefinition.asFea}s&��&�-�-�d�j�j�.>�.>�.@�$�)�)�L�LrVr�r�r�rNrVrQrIrIus��5��
MrVrIc�h�|dk(r|dk(r|dk(ry|dk(r|dk(r|dk(rydj|||�S)N�r�i	r�r�1�{} {} {}�r�)�pid�eid�lids   rQ�simplify_name_attributesr��sC��
�a�x�C�1�H�����	���c�Q�h�3�!�8��� � ��c�3�/�/rVc�&�eZdZdZdd�Zd�Zdd�Zy)r:z�Represents a name record. (`Section 9.e. <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.e>`_)Nc�v�tj||�||_||_||_||_||_yr�)rBr��nameID�
platformID�	platEncID�langID�string)r�r�r�r�r�r�r�s       rQr�zNameRecord.__init__�s5�����4��*����$���"��������rVc��|j|j|j|j|j|j
|j�y)z8Calls the builder object's ``add_name_record`` callback.N)�add_name_recordr�r�r�r�r�r�r�s  rQr�zNameRecord.build�s:������M�M��K�K��O�O��N�N��K�K��K�K�
	
rVc
��d�}t|j|j|j�}|�t	d|j
��t
|j|��}|dk(r\djtdt|�d�D�cgc],}|t||�dzt||d	z�zd
���.c}�}n/dj|D�cgc]}|t|�d���c}�}t|j|j|j�}|dk7r|dz
}d
j|j||�Scc}wcc}w)Nc�>�|dk\r|dkr|dvrt|�S||zS)N� �~)�"�\)�chr)rt�escape_patterns  rQ�escapez NameRecord.asFea.<locals>.escape�s*���D�y�Q�$�Y�1�L�+@��1�v�
�%��)�)rVzUnsupported encoding)�encoding�	utf_16_ber�rr��r�z\%04xz\%02xr�znameid {} {}"{}";)rr�r�r�rr�rr�rSrr�rr�r�r�)	r�r�r�r�r�r��escaped_string�b�plats	         rQr�zNameRecord.asFea�s ��	*��t���������L����!�"8�$�-�-�H�H��D�K�K�(�3���{�"��W�W�#�1�c�!�f�a�0����7�1�Q�4�=�3�.���1�q�5��1B�B�H�M���N� �W�W�A�%N�q�f�W�Q�Z��&B�%N�O�N�'����������U���2�:��C�K�D�"�)�)�$�+�+�t�^�L�L����&Os�1E�Er�r�rrNrVrQr:r:�s��K��	
�MrVr:c��eZdZdZd�Zdd�Zy)r(z4Represents a ``sizemenuname`` or ``name`` statement.c�f�tj||�|j|j�y)z8Calls the builder object's ``add_featureName`` callback.N)r:r��add_featureNamer�r�s  rQr�zFeatureNameStatement.build�s$������w�'�������,rVc���|jdk(rd}nd}t|j|j|j�}|dk7r|dz
}dj|||j�S)N�size�sizemenunamer�r�r�z
{} {}"{}";)r�r�r�r�r�r�r�)r�r�r�r�s    rQr�zFeatureNameStatement.asFea�s[���;�;�&� � �C��C�'����������U���2�:��C�K�D��"�"�3��d�k�k�:�:rVNr�)r�r�r�r�r�r�rNrVrQr(r(�s��>�-�
;rVr(c��eZdZdZdd�Zy)rEz+Represents a STAT table ``name`` statement.c��t|j|j|j�}|dk7r|dz
}dj	||j
�S�Nr�r�zname {}"{}";�r�r�r�r�r�r��r�r�r�s   rQr�zSTATNameStatement.asFea��C��'����������U���2�:��C�K�D��$�$�T�4�;�;�7�7rVNr�)r�r�r�r�r�rNrVrQrErE�s
��5�8rVrEc�&�eZdZdZdd�Zd�Zdd�Zy)rAzA ``parameters`` statement.Nc�h�tj||�||_||_||_||_yr�)rBr��
DesignSize�SubfamilyID�
RangeStart�RangeEnd)r�r�r�r�r�r�s      rQr�zSizeParameters.__init__�s/�����4��*�$���&���$��� ��
rVc��|j|j|j|j|j|j
�y)z<Calls the builder object's ``set_size_parameters`` callback.N)�set_size_parametersr�r�r�r�r�r�s  rQr�zSizeParameters.build�s5���#�#��M�M��O�O�����O�O��M�M�	
rVc��dj|j|j�}|jdk7s|jdk7rA|djt|jdz�t|jdz��z
}|dzS)Nzparameters {:.1f} {}rz {} {}�
r4)r�r�r�r�r��intr�s   rQr�zSizeParameters.asFea�sq��$�+�+�D�O�O�T�=M�=M�N���?�?�a��4�=�=�A�#5��8�?�?�3�t����';�#<�c�$�-�-�RT�BT�>U�V�V�C��S�y�rVr�r�rrNrVrQrArA�s��%�!�
�rVrAc�(�eZdZdZ	dd�Zd�Zdd�Zy)rz;Represent a name statement inside a ``cvParameters`` block.Nc	�J�tj|||||||��||_yr)r:r�r")r�r�r�r�r�r�r"r�s        rQr�z"CVParametersNameStatement.__init__�s/��	����&�*�i���(�	�	
�%��rVc�2�d}|jdk(r5dj|jj|jd��}|j|j�|j|j|zf|_tj||�y)z9Calls the builder object's ``add_cv_parameter`` callback.r�r$z_{}rN)r"r��cv_num_named_params_�getr��add_cv_parameterr:r�)r�r��items   rQr�zCVParametersNameStatement.build�st�����?�?�2�2��<�<�� <� <� @� @����a� P�Q�D�� � ����-��{�{�D�O�O�d�$:�;�������w�'rVc��t|j|j|j�}|dk7r|dz
}dj	||j
�Sr�r�r�s   rQr�zCVParametersNameStatement.asFear�rVr�r�rrNrVrQrr�s��E�SW�%�(�8rVrc�&�eZdZdZdd�Zd�Zdd�Zy)r"a
    Statement used in cvParameters blocks of Character Variant features (cvXX).
    The Unicode value may be written with either decimal or hexadecimal
    notation. The value must be preceded by '0x' if it is a hexadecimal value.
    The largest Unicode value allowed is 0xFFFFFF.
    Nc�L�tj||�||_||_yr�)rBr��	characterr�)r�r�r�r�s    rQr�zCharacterStatement.__init__s �����4��*�"�����rVc�P�|j|j|j�y)z9Calls the builder object's ``add_cv_character`` callback.N)�add_cv_characterr�r�r�s  rQr�zCharacterStatement.builds��� � �������:rVc�8�dj|j�S)NzCharacter {:#x};)r�r�r�s  rQr�zCharacterStatement.asFeas��!�(�(����8�8rVr�r�rrNrVrQr"r"s����
;�9rVr"c�&�eZdZdZdd�Zd�Zdd�Zy)rz�An axis definition, being either a ``VertAxis.BaseTagList/BaseScriptList``
    pair or a ``HorizAxis.BaseTagList/BaseScriptList`` pair.Nc�Z�tj||�||_||_||_yr�)rBr��bases�scriptsrz)r�r�r�rzr�s     rQr�zBaseAxis.__init__'s'�����4��*���
���� ��
rVc�f�|j|j|j|j�y)z6Calls the builder object's ``set_base_axis`` callback.N)�
set_base_axisr�r�rzr�s  rQr�zBaseAxis.build-s �����d�j�j�$�,�,��
�
�FrVc�F�|jrdnd}|jD�cgc];}dj|d|ddjt	t
|d�����=}}dj|dj|j�||d	j|��Scc}w)
N�Vert�Horizr�rr�r�r�z2{}Axis.BaseTagList {};
{}{}Axis.BaseScriptList {};rL)rzr�r�rSr�rsr�)r�r��	directionrr�s     rQr�zBaseAxis.asFea1s���"�m�m�F��	��\�\�
��
���a��d�A�a�D�#�(�(�3�s�A�a�D�>�*B�C�
��
�E�K�K��s�x�x��
�
�+�V�Y��	�	�'�@R�
�	
��	
s�ABr�r�rrNrVrQrr#s��@�!�G�
rVrc�&�eZdZdZdd�Zd�Zdd�Zy)r;z�An entry in the ``OS/2`` table. Most ``values`` should be numbers or
    strings, apart from when the key is ``UnicodeRange``, ``CodePageRange``
    or ``Panose``, in which case it should be an array of integers.Nc�L�tj||�||_||_yr��rBr�rr�r�rrr�s    rQr�zOS2Field.__init__A� �����4��*������
rVc�P�|j|j|j�y)z6Calls the builder object's ``add_os2_field`` callback.N)�
add_os2_fieldrrr�s  rQr�zOS2Field.buildFs�����d�h�h��
�
�3rVc��d�}d}d}t|D�cgc]}|j�|tgf��c}�}|j|D�cgc]}|j�||gf��c}�d|g|d<dd�g|d<|j|vrBd	j||jd
||jd|j��Sycc}wcc}w)
Nc�@�djtt|��S)Nr�)rSr�rs)r_s rQ�
intarr2strz"OS2Field.asFea.<locals>.intarr2strKs���8�8�C��Q�K�(�(rV)�FSType�TypoAscender�
TypoDescender�TypoLineGap�	winAscent�
winDescent�XHeight�	CapHeight�WeightClass�
WidthClass�LowerOpSize�UpperOpSize)�UnicodeRange�
CodePageRange�Panose�panose�Vendorc�$�dj|�S)Nz"{}"r�)r`s rQ�<lambda>z OS2Field.asFea.<locals>.<lambda>`s��&�-�-��2B�rV�vendor�{} {};rr�r�)rLr�rs�updaterr�r)r�r�r��numbers�rangesr_�keywordss       rQr�zOS2Field.asFeaJs���	)�

��3����@�1�!�'�'�)�a��X�.�@�A�����v�F�!�!�'�'�)�a��_�5�F�G�&�
�3����&�(B�C�����8�8�x���?�?�����"�1�%�'<�x����'9�!�'<�T�Z�Z�'H��
���A��Fs�C�C
r�r�rrNrVrQr;r;<s��G��
4�rVr;c�&�eZdZdZdd�Zd�Zdd�Zy)r+zAn entry in the ``hhea`` table.Nc�L�tj||�||_||_yr�r�r�s    rQr�zHheaField.__init__kr�rVc�P�|j|j|j�y)z7Calls the builder object's ``add_hhea_field`` callback.N)�add_hhea_fieldrrr�s  rQr�zHheaField.buildp������t�x�x����4rVc��d}t|D�cgc]}|j�|f��c}�}dj||j|j�Scc}w)N)�CaretOffset�Ascender�	Descender�LineGapr��rLr�r�rr�r�r��fieldsr_rs     rQr�zHheaField.asFeatsI��D����8�A�!�'�'�)�Q��8�9�����x����1�4�:�:�>�>��9��Ar�r�rrNrVrQr+r+h���)��
5�?rVr+c�&�eZdZdZdd�Zd�Zdd�Zy)rJzAn entry in the ``vhea`` table.Nc�L�tj||�||_||_yr�r�r�s    rQr�zVheaField.__init__}r�rVc�P�|j|j|j�y)z7Calls the builder object's ``add_vhea_field`` callback.N)�add_vhea_fieldrrr�s  rQr�zVheaField.build�rrVc��d}t|D�cgc]}|j�|f��c}�}dj||j|j�Scc}w)N)�VertTypoAscender�VertTypoDescender�VertTypoLineGapr�rr
s     rQr�zVheaField.asFea�sI��M����8�A�!�'�'�)�Q��8�9�����x����1�4�:�:�>�>��9rr�r�rrNrVrQrJrJzrrVrJc�&�eZdZdZdd�Zd�Zdd�Zy)rDz�A STAT table Design Axis

    Args:
        tag (str): a 4 letter axis tag
        axisOrder (int): an int
        names (list): a list of :class:`STATNameStatement` objects
    Nc�h�tj||�||_||_||_||_yr�)rBr�r��	axisOrder�namesr�)r�r�rrr�s     rQr�z STATDesignAxisStatement.__init__�s.�����4��*����"�����
� ��
rVc�<�|j||j�yr�)�
addDesignAxisr�r�s  rQr�zSTATDesignAxisStatement.build�s�����d�D�M�M�2rVc	���|tz
}d|j�d|j�d�}|d|zj|jD�cgc]}|j|����c}�dzz
}|dz
}|Scc}w)NzDesignAxis r�z { 
rr�};)rr�rrSrr��r�r�r�r�s    rQr�zSTATDesignAxisStatement.asFea�su���%����D�H�H�:�Q�t�~�~�&6�f�=����v�
�#�#�T�Z�Z�$P��Q�W�W�F�W�%;�$P�Q�TX�X�X���t����
��%Qs�A0
r�r�rrNrVrQrDrD�s���!�3�rVrDc�&�eZdZdZdd�Zd�Zdd�Zy)r%ziSTAT table ElidedFallbackName

    Args:
        names: a list of :class:`STATNameStatement` objects
    Nc�L�tj||�||_||_yr�)rBr�rr�)r�rr�s   rQr�zElidedFallbackName.__init__�� �����4��*���
� ��
rVc�P�|j|j|j�yr�)�setElidedFallbackNamerr�r�s  rQr�zElidedFallbackName.build�����%�%�d�j�j�$�-�-�@rVc	��|tz
}d}|d|zj|jD�cgc]}|j|����c}�dzz
}|dz
}|Scc}w)NzElidedFallbackName { 
rrr )rrSrr�r!s    rQr�zElidedFallbackName.asFea�s]���%���'����v�
�#�#�T�Z�Z�$P��Q�W�W�F�W�%;�$P�Q�TX�X�X���t����
��%Qs�A
r�r�rrNrVrQr%r%�s���!�
A�rVr%c�&�eZdZdZdd�Zd�Zdd�Zy)r&zpSTAT table ElidedFallbackNameID

    Args:
        value: an int pointing to an existing name table name ID
    Nc�L�tj||�||_||_yr�)rBr�rr�)r�rr�s   rQr�zElidedFallbackNameID.__init__�r$rVc�P�|j|j|j�yr�)r&rr�r�s  rQr�zElidedFallbackNameID.build�r'rVc�"�d|j�d�S)NzElidedFallbackNameID r4)rr�s  rQr�zElidedFallbackNameID.asFea�s��&�t�z�z�l�!�4�4rVr�r�rrNrVrQr&r&�s���!�
A�5rVr&c�&�eZdZdZdd�Zd�Zdd�Zy)rCz�A STAT table Axis Value Record

    Args:
        names (list): a list of :class:`STATNameStatement` objects
        locations (list): a list of :class:`AxisValueLocationStatement` objects
        flags (int): an int
    Nc�Z�tj||�||_||_||_yr�)rBr�r�	locationsr)r�rr/rr�s     rQr�zSTATAxisValueStatement.__init__�s'�����4��*���
�"�����
rVc�<�|j||j�yr�)�addAxisValueRecordr�r�s  rQr�zSTATAxisValueStatement.build�s���"�"�4����7rVc��d}|jD]}||j�z
}�|jD]}||j�z
}|dz
}�|jrdddg}g}d}t	t|��D]-}|j|zdk7r|j
||�|dz}�/|ddj|��d	�z
}|d
z
}|S)NzAxisValue {
r�OlderSiblingFontAttribute�ElidableAxisValueNamer�rzflag r��;
r )r/r�rrrr�r�rS)	r�r�r�r��
nameRecordr�flagStringsr�r�s	         rQr�zSTATAxisValueStatement.asFea�s��������	$�H��8�>�>�#�#�C�	$��*�*�	�J��:�#�#�%�%�C��4�K�C�	��:�:�0�2I�J�E��K��D��3�u�:�&�
!���:�:��$��)��&�&�u�Q�x�0��q�y��
!�
�U�3�8�8�K�0�1��5�5�C��t����
rVr�r�rrNrVrQrCrC�s����8�rVrCc� �eZdZdZdd�Zdd�Zy)rz�
    A STAT table Axis Value Location

    Args:
        tag (str): a 4 letter axis tag
        values (list): a list of ints and/or floats
    Nc�L�tj||�||_||_yr�)rBr�r��values)r�r�r:r�s    rQr�z#AxisValueLocationStatement.__init__s �����4��*������rVc�|�|d|j�d�z
}|djd�|jD���d�z
}|S)Nz	location r�c3�2K�|]}t|����y�wr�rr)rOr�s  rQrRz3AxisValueLocationStatement.asFea.<locals>.<genexpr>	s����7�a�3�q�6�7�rur5)r�rSr:)r�r�s  rQr�z AxisValueLocationStatement.asFeasC����4�8�8�*�A�&�&���#�(�(�7�4�;�;�7�7�8��<�<���
rVr�r�r�rNrVrQrr�s����
rVrc�&�eZdZdZdd�Zd�Zdd�Zy)r#z�
    A variable layout conditionset

    Args:
        name (str): the name of this conditionset
        conditions (dict): a dictionary mapping axis tags to a
            tuple of (min,max) userspace coordinates.
    Nc�L�tj||�||_||_yr�)rBr�r��
conditions)r�r�r?r�s    rQr�zConditionsetStatement.__init__s �����4��*���	�$��rVc�f�|j|j|j|j�yr�)�add_conditionsetr�r�r?r�s  rQr�zConditionsetStatement.builds ��� � �����	�	�4�?�?�KrVc	���||d|j�d�zdzz
}|jj�D] \}\}}||tz|�d|�d|�d�zz
}�"||dzd|j�d�zz
}|S)Nz
conditionset r�rr5�})r�r?rr)r�r�r�r��minvalue�maxvalues      rQr�zConditionsetStatement.asFeas����v�-��	�	�{�!�4�4�u�<�<��)-���)>�)>�)@�	F�%�C�%�(�H��6�E�>�s�e�1�X�J�a��z��$E�E�E�C�	F��v��|��$�)�)��C�0�0�0���
rVr�)r�r�rrNrVrQr#r#
s���%�
L�rVr#c�&�eZdZdZdd�Zd�Zdd�Zy)�VariationBlockzCA variation feature block, applicable in a given set of conditions.Nc�\�tj||�|||c|_|_|_yr�)rr�r��conditionsetr
)r�r�rIr
r�s     rQr�zVariationBlock.__init__*s,��
���t�X�&����	9��	�4�$�d�&8rVc�J�|j|j|j�|jdk7r;|j|jvr#td|j��|j��|j}i|_tj||�|jj�D]V\}}|jj|i�j|jg�}|j|�||vs�Rg||<�X||_|j�y)rr�z,variation block used undefined conditionset N)rr�r�rI�conditionsets_rrrr�r�feature_variations_rr�r)r�r�rrrrs      rQr�zVariationBlock.build2s��	���d�m�m�T�Y�Y�7�����'��!�!��)?�)?�?�!�>�t�?P�?P�>Q�R��
�
��
��$�$�����
���D�'�"�!�+�+�1�1�3�	#�J�C���/�/�:�:�3��C�N�N��!�!�2��E�
�L�L����(�"� "���
�
	#�%������rVc��|d|jj�zz}||jdzz
}|jr|dz
}|dz
}|tj||��z
}||d|jj�zzz
}|S)Nz
variation %s r�rrrr)r�rrIr
rr�r�s   rQr�zVariationBlock.asFeaNs����������):�:�:���t� � �3�&�&������?�"�C��u����u�{�{�4��{�/�/���v�	�D�I�I�O�O�$5�5�5�5���
rVrr�rrNrVrQrGrG's��M�
��8rVrG)X�fontTools.feaLib.errorr�fontTools.feaLib.locationr�fontTools.misc.encodingToolsr�fontTools.misc.textToolsrr�collectionsrr<r�__all__rUr�r�r��objectr	rBr'rr�rr
rrrrr
rrrrGrrrrrrrrr r!r$r)r,r-r.r/r0r*r1r2r3r4r5r6r7r8r9r<r=r@r>r?rFrHrIr�r:r(rErArr"rr;r+rJrDr%r&rCrr#rGrNrVrQ�<module>rUs���2�8�4�5�#����C��LF��5�7��t��f��,	��	�	��	�	�g�	��
��
!�
�
!� ;%��;%�|*�Z�*�")�J�)�"�Y��
�I�
�.	J�%�	J��5��@�%��*�%��.���
C�9�
C� 
�Y�
�<*��*�Z$
�)�$
�N"�i�"�J"�Z�"�J�y��
�i�
�&7�y�7�t7��7�tT�)�T�*6�	�6�!9��!9�H9�9�9�B7�y�7�&�	��:R�i�R�<�I�<�
�I�
�&
�)�
�&$�Y�$�N&6�)�&6�R5�y�5�"�9��*5�)�5�p�9��*C�Y�C�LP�y�P�f%�y�%�P+�9�+�\8�i�8�%��%�P�	��k�*�k�\	M�I�	M�0�.M��.M�b;�:�;�&8�
�8��Y��68�
�8�69��9�*
�y�
�2)�y�)�X?�	�?�$?�	�?�$�i��6���.5�9�5�&%�Y�%�P���(�I��4/�U�/rV

Youez - 2016 - github.com/yon3zu
LinuXploit