� ��gB!����ddlmZddlmZddlmZddlmZmZddl m Z ddl Z dZ 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��ZWdS)��)�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�N�|�dSdd�d�|D����zS)Nz <device NULL>z <device %s>�, c3� K�|] }d|zV�� dS)z%d %dN�)�.0�ts �d/home/asafur/pinokio/api/open-webui.git/app/env/lib/python3.11/site-packages/fontTools/feaLib/ast.py� <genexpr>z!deviceToString.<locals>.<genexpr>Ts&����(E�(E���1��(E�(E�(E�(E�(E�(E�)�join)�devices rQ�deviceToStringrVPs2�� �~����t�y�y�(E�(E�f�(E�(E�(E�E�E�E�ErS)4�anchor� anchordef�anon� anonymous�by�contour�cursiverU�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|���St|t��rAt |��dkr.t|d��dzt|d��zS|���t vrd|zS|S)N�asFea�rz - ��\)�hasattrr�� isinstance�tuple�len�lower� fea_keywords)�gs rQr�r��s����q�'�����w�w�y�y�� �A�u� � ��#�a�&�&�A�+�+��Q�q�T�{�{�U�"�U�1�Q�4�[�[�0�0� �����l� "� "��a�x���rSc�.�eZdZdZdd�Zd�Zd d�Zd�ZdS) r z8A base class representing "something" in a feature file.Nc�T�|rt|t��s t|�}||_dS�N)r�r�location��selfr�s rQ�__init__zElement.__init__�s1�� � 5�J�x�1C�D�D� 5�)�8�4�H� �� � � rSc��dSr�rN�r��builders rQ�buildz Element.build�s�� �rS�c��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 ��"�!rSc�*�|���Sr��r��r�s rQ�__str__zElement.__str__�s���z�z�|�|�rSr��r�)�__name__� __module__� __qualname__�__doc__r�r�r�r�rNrSrQr r �s`������B�B�!�!�!�!�  � � �"�"�"�"� ����rSr c��eZdZdS)rBN�r�r�r�rNrSrQrBrB���������DrSrBc��eZdZdS)r'Nr�rNrSrQr'r'�r�rSr'c�,��eZdZdZd�fd� Zdd�Z�xZS)r zA comment in a feature file.Nc�f��tt|���|��||_dSr�)�superr r��text)r�r�r�� __class__s �rQr�zComment.__init__�s,��� �g�t���%�%�h�/�/�/��� � � rSr�c��|jSr�)r�r�s rQr�z Comment.asFea�s ���y�rSr�r��r�r�r�r�r�r�� __classcell__�r�s@rQr r �sW�������&�&������� �������rSr c�(�eZdZdZdd�Zd�Zdd�ZdS) � NullGlyphz5The NULL glyph, used in glyph deletion substitutions.Nc�<�t�||��dSr�)r'r�r�s rQr�zNullGlyph.__init__�s�����D�(�+�+�+�+�+rSc��dS)�BThe glyphs in this class as a tuple of :class:`GlyphName` objects.rNrNr�s rQ�glyphSetzNullGlyph.glyphSet�s���rrSr�c��dS)N�NULLrNr�s rQr�zNullGlyph.asFea�s���vrSr�r��r�r�r�r�r�r�r�rNrSrQr�r��sQ������?�?�,�,�,�,���������rSr�c�(�eZdZdZdd�Zd�Zdd�ZdS) r z)A single glyph name, such as ``cedilla``.Nc�J�t�||��||_dSr�)r'r��glyph)r�r�r�s rQr�zGlyphName.__init__�s#�����D�(�+�+�+��� � � rSc��|jfS�r�)r�r�s rQr�zGlyphName.glyphSet�s ��� �}�rSr�c�*�t|j��Sr�)r�r�r�s rQr�zGlyphName.asFea�s���T�Z� � � rSr�r�r�rNrSrQr r �sQ������3�3����� ���!�!�!�!�!�!rSr c�F�eZdZdZd d�Zd�Zd d�Zd�Zd�Zd �Z d �Z d �Z dS)r z1A glyph class, such as ``[acute cedilla grave]``.Nc�n�t�||��|�|ng|_g|_d|_dS)Nr)r'r��glyphs�original�curr)r�r�r�s rQr�zGlyphClass.__init__�s:�����D�(�+�+�+� &� 2�f�f��� ��� ��� � � rSc�*�t|j��Sr�)r�r�r�s rQr�zGlyphClass.glyphSet�s���T�[�!�!�!rSr�c��t|j��r�|jt|j��krE|j�|j|jd���t|j��|_dd�t t|j����zdzSdd�t t|j����zdzS)N�[� �])r�r�r�r��extendrT�mapr�r�s rQr�zGlyphClass.asFea�s��� �t�}� � � A��y�3�t�{�+�+�+�+�� �$�$�T�[�����%=�>�>�>��� �,�,�� �����#�e�T�]�";�";�<�<�<�s�B� B�����#�e�T�[�"9�"9�:�:�:�S�@� @rSc�:�|j�|��dS)z6Add a list of :class:`GlyphName` objects to the class.N)r�r�)r�r�s rQr�zGlyphClass.extend�s�� � ���6�"�"�"�"�"rSc�:�|j�|��dS)z4Add a single :class:`GlyphName` object to the class.N)r��append)r�r�s rQr�zGlyphClass.appends�� � ���5�!�!�!�!�!rSc�6�|jt|j��kr,|j�|j|jd���|j�||f��|j�|��t|j��|_dS)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_ranges��� �9�s�4�;�'�'� '� '� �M� � ���T�Y�[�[�!9� :� :� :� � ���e�S�\�*�*�*� � ���6�"�"�"��� �$�$�� � � rSc��|jt|j��kr,|j�|j|jd���|j�d�|��d�|��f��|j�|��t|j��|_dS)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�s�4�;�'�'� '� '� �M� � ���T�Y�[�[�!9� :� :� :� � ���f�m�m�E�2�2�F�M�M�#�4F�4F�G�H�H�H� � ���6�"�"�"��� �$�$�� � � rSc�V�|jt|j��kr,|j�|j|jd���|j�|��|j�|�����t|j��|_dS)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_classs��� �9�s�4�;�'�'� '� '� �M� � ���T�Y�[�[�!9� :� :� :� � ���R� � � � � ���2�;�;�=�=�)�)�)��� �$�$�� � � rS�NNr�) r�r�r�r�r�r�r�r�r�r�r�r�rNrSrQr r �s�������;�;�����"�"�"�A�A�A�A�#�#�#�"�"�"� %� %� %�%�%�%�%�%�%�%�%rSr c�(�eZdZdZdd�Zd�Zdd�ZdS) rzyA glyph class name, such as ``@FRENCH_MARKS``. This must be instantiated with a :class:`GlyphClassDefinition` object.Nc�x�t�||��t|t��sJ�||_dSr�)r'r�r�r� glyphclass)r�r�r�s rQr�zGlyphClassName.__init__'s:�����D�(�+�+�+��*�&:�;�;�;�;�;�$����rSc�N�t|j�����Sr�)r�r�r�r�s rQr�zGlyphClassName.glyphSet,s���T�_�-�-�/�/�0�0�0rSr�c� �d|jjzS�N�@)r�r�r�s rQr�zGlyphClassName.asFea0s���T�_�)�)�)rSr�r�r�rNrSrQrr#sU������4�4�%�%�%�%� 1�1�1�*�*�*�*�*�*rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) rz�A mark class name, such as ``@FRENCH_MARKS`` defined with ``markClass``. This must be instantiated with a :class:`MarkClass` object.Nc�x�t�||��t|t��sJ�||_dSr�)r'r�r�r� markClass)r�r�r�s rQr�zMarkClassName.__init__8s9�����D�(�+�+�+��)�Y�/�/�/�/�/�"����rSc�4�|j���Sr�)r�r�r�s rQr�zMarkClassName.glyphSet=s���~�&�&�(�(�(rSr�c� �d|jjzSr�)r�r�r�s rQr�zMarkClassName.asFeaAs���T�^�(�(�(rSr�r�r�rNrSrQrr4sW������C�C�#�#�#�#� )�)�)�)�)�)�)�)�)rSrc�"�eZdZdZdd�Zdd�ZdS)rzAn anonymous data block.Nc�X�t�||��||_||_dSr�)rBr��tag�content)r�r�r�r�s rQr�zAnonymousBlock.__init__Hs*�����4��*�*�*������ � � rSr�c��d�|j��}||jz }|d�|j��z }|S)Nz anon {} {{ z}} {}; )r�r�r��r�r��ress rQr�zAnonymousBlock.asFeaMsB���#�#�D�H�-�-�� �t�|��� �|�"�"�4�8�,�,�,��� rSr�r��r�r�r�r�r�r�rNrSrQrrEsB������"�"����� �����rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) rz,A block of statements: feature, lookup, etc.Nc�J�t�||��g|_dSr�)rBr�� statementsr�s rQr�zBlock.__init__Ws#�����4��*�*�*�����rSc�D�|jD]}|�|���dS)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�z Block.build[s4���� � �A� �G�G�G� � � � � � rSr�c�v���tz ��d�z��fd�|jD����zdzS)N� c�<��g|]}|�������S��r�r��rOr�r�s �rQ� <listcomp>zBlock.asFea.<locals>.<listcomp>fs'���#T�#T�#T�q�A�G�G�6�G�$:�$:�#T�#T�#TrS)�SHIFTrTr�r�s `rQr�z Block.asFeabsN����%��� ��f�}�"�"�#T�#T�#T�#T�D�O�#T�#T�#T�U�U� V�� � rSr�r��r�r�r�r�r�r�r�rNrSrQrrTsQ������6�6�������� � � � � � rSrc� �eZdZdZd�Zdd�ZdS)r zpThe top-level element of the syntax tree, containing the whole feature file in its ``statements`` attribute.c�L�t�|d���i|_dS�N)r�)rr�� markClassesr�s rQr�zFeatureFile.__init__os&�� ���t�d��+�+�+�����rSr�c�P��d��fd�|jD����S)Nrc3�D�K�|]}|�����V��dS)rNr�rs �rQrRz$FeatureFile.asFea.<locals>.<genexpr>ts1�����I�I�A������/�/�I�I�I�I�I�IrS)rTr�r�s `rQr�zFeatureFile.asFeass,����y�y�I�I�I�I���I�I�I�I�I�IrSNr�r�rNrSrQr r ksG������-�-����J�J�J�J�J�JrSr c�(�eZdZdZdd�Zd�Zd d�ZdS) rzA named feature block.FNc�Z�t�||��||c|_|_dSr��rr�r�� use_extension�r�r�rr�s rQr�zFeatureBlock.__init__z�-�� ���t�X�&�&�&�(,�m�%�� �4�%�%�%rSc�^�|�|j|j��|j}i|_t�||��|j���D].\}}|�|g���|���/||_|� ��dS)��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�T�Y�7�7�7��$����� � � �D�'�"�"�"�!�+�1�1�3�3� 7� 7�J�C�� � � ��R� (� (� /� /�� 6� 6� 6� 6�$����������rSr�c���|d|j���zz}|jr|dz }|dz }|t�||���z }||d|j���zzz }|S)Nz feature %s � useExtension �{ r�} %s; )r��striprrr�r�s rQr�zFeatureBlock.asFea�sz���}�t�y���'8�'8�8�8�� � � #� �?� "�C� �u� �� �u�{�{�4��{�/�/�/�� �v� �D�I�O�O�$5�$5�5�5�5��� rS�FNr�rrNrSrQrrwsQ������ � �<�<�<�<� � � ������rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) rzYA block inside another block, for example when found inside a ``cvParameters`` block.Nc�X�t�||��||_||_dSr�)rr�r�� block_name)r�r�r&r�s rQr�zNestedBlock.__init__�s(�� ���t�X�&�&�&����$����rSc��t�||��|jdkr|�|j��dSdS)N�ParamUILabelNameID)rr�r&�add_to_cv_num_named_paramsr�r�s rQr�zNestedBlock.build�sH�� � � �D�'�"�"�"� �?�2� 2� 2� � .� .�t�x� 8� 8� 8� 8� 8� 3� 2rSr�c��d�||j��}|t�||���z }|d�|��z }|S)Nz{}{} {{ rz{}}}; )r�r&rr�r�s rQr�zNestedBlock.asFea�sP��� � ����9�9�� �u�{�{�4��{�/�/�/�� �y����'�'�'��� rSr�r�rrNrSrQrr�sU��������%�%�%�%� 9�9�9� �����rSrc�(�eZdZdZdd�Zd�Zd d�ZdS) rz*A named lookup, containing ``statements``.FNc�Z�t�||��||c|_|_dSr�rrs rQr�zLookupBlock.__init__�rrSc��|�|j|j��t�||��|���dSr�)�start_lookup_blockr�r�rr��end_lookup_blockr�s rQr�zLookupBlock.build�sH���"�"�4�=�$�)�<�<�<� � � �D�'�"�"�"�� � �"�"�"�"�"rSr�c���d�|j��}|jr|dz }|dz }|t�||���z }|d�||j��z }|S)Nz lookup {} rr rz {}}} {}; )r�r�rrr�r�s rQr�zLookupBlock.asFea�sp���!�!�$�)�,�,�� � � #� �?� "�C� �u� �� �u�{�{�4��{�/�/�/�� �|�"�"�6�4�9�5�5�5��� rSr#r�rrNrSrQrr�sQ������4�4�<�<�<�<�#�#�#� �����rSrc�,��eZdZdZdd�Zd�fd� Z�xZS)rGzA ``table ... { }`` block.Nc�J�t�||��||_dSr�)rr�r�)r�r�r�s rQr�zTableBlock.__init__�s!�� ���t�X�&�&�&��� � � rSr�c���d�|j�����}|tt|���|���z }|d�|j�����z }|S)Nz table {} {{ rz}} {}; )r�r�r"r�rGr�)r�r�r�r�s �rQr�zTableBlock.asFea�sp����$�$�T�Y�_�_�%6�%6�7�7�� �u�Z��&�&�,�,�F�,�;�;�;�� �z� � �����!2�!2�3�3�3��� rSr�r�r�r�s@rQrGrG�sW�������$�$��������������rSrGc�(�eZdZdZdd�Zd�Zdd�ZdS) rz!Example: ``@UPPERCASE = [A-Z];``.Nc�X�t�||��||_||_dSr�)rBr�r�r�)r�r�r�r�s rQr�zGlyphClassDefinition.__init__�s*�����4��*�*�*��� ��� � � rSc�N�t|j�����Sr�)r�r�r�r�s rQr�zGlyphClassDefinition.glyphSet�s���T�[�)�)�+�+�,�,�,rSr�c�V�d|jzdz|j���zdzS)Nr�z = �;)r�r�r�r�s rQr�zGlyphClassDefinition.asFea�s+���T�Y���&���):�):�)<�)<�<�s�B�BrSr�r�r�rNrSrQrr�sW������+�+����� -�-�-�C�C�C�C�C�CrSrc�*�eZdZdZ dd�Zd�Zdd�ZdS) rz�Example: ``GlyphClassDef @UPPERCASE, [B], [C], [D];``. The parameters must be either :class:`GlyphClass` or :class:`GlyphClassName` objects, or ``None``.Nc�v�t�||��||c|_|_||_||_dSr�)rBr�� baseGlyphs� markGlyphs�ligatureGlyphs�componentGlyphs)r�r;r<r=r>r�s rQr�zGlyphClassDefStatement.__init__�s@�� ���4��*�*�*�,6� �(�����,���.����rSc��|jr|j���n t��}|jr|j���n t��}|jr|j���n t��}|jr|j���n t��}|�|j||||��dS)z3Calls the builder's ``add_glyphClassDef`` callback.N)r;r�r�r=r<r>�add_glyphClassDefr�)r�r�r��ligaro�comps rQr�zGlyphClassDefStatement.build�s���-1�_�I�t��'�'�)�)�)�%�'�'��15�1D�Q�t�"�+�+�-�-�-�%�'�'��-1�_�I�t��'�'�)�)�)�%�'�'��26�2F�S�t�#�,�,�.�.�.�E�G�G���!�!�$�-��t�T�4�H�H�H�H�HrSr�c�2�d�|jr|j���nd|jr|j���nd|jr|j���nd|jr|j���nd��S)NzGlyphClassDef {}, {}, {}, {};r�)r�r;r�r=r<r>r�s rQr�zGlyphClassDefStatement.asFea�s���.�5�5�'+�� >�D�O� !� !� #� #� #�B�+/�+>� F�D� � %� %� '� '� '�B�'+�� >�D�O� !� !� #� #� #�B�,0�,@� H�D� � &� &� (� (� (�b�  � � rSr�r�rrNrSrQrr�s_�������� QU�/�/�/�/�I�I�I� � � � � � rSrc�,�eZdZdZd�Zd�Zd�Zdd�ZdS) 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�H�||_g|_t��|_dSr�)r�� definitionsrr�)r�r�s rQr�zMarkClass.__init__s ���� ����!�m�m�� � � rSc�*�t|t��sJ�|j�|��|���D]L}||jvr7|j|j}|�d}nd|��}td|�d|��|j���||j|<�MdS)z@Add a :class:`MarkClassDefinition` statement to this mark class.Nr�z at zGlyph z already defined)r�rrFr�r�r�r�r)r�� definitionr��otherLocr�s rQ� addDefinitionzMarkClass.addDefinitions����*�&9�:�:�:�:�:� ���� �+�+�+��(�(�*�*� ,� ,�E��� �#�#��;�u�-�6���#��C�C�+��+�+�C�%�o�49�E�E�3�3�?��AT����",�D�K�� � � ,� ,rSc�N�t|j�����Sr�)r�r��keysr�s rQr�zMarkClass.glyphSet#s���T�[�%�%�'�'�(�(�(rSr�c�N�d�d�|jD����}|S)Nrc3�>K�|]}|���V��dSr�r�)rO�ds rQrRz"MarkClass.asFea.<locals>.<genexpr>(s*����<�<�a���� � �<�<�<�<�<�<rS)rTrFr�s rQr�zMarkClass.asFea's*���i�i�<�<�4�+;�<�<�<�<�<��� rSNr�)r�r�r�r�r�rJr�r�rNrSrQrr�s_������ � �$�$�$� ,�,�,� )�)�)������rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) 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���t�||��t|t��sJ�t|t��rt|t ��sJ�|||c|_|_|_dSr�) rBr�r�rrr'r�rWr�)r�r�rWr�r�s rQr�zMarkClassDefinition.__init__Csm�����4��*�*�*��)�Y�/�/�/�/�/��&�&�)�)�L�j���.L�.L�L�L�L�3<�f�f�0���� �T�[�[�[rSc�4�|j���Sr�)r�r�r�s rQr�zMarkClassDefinition.glyphSetIs���{�#�#�%�%�%rSr�c��d�|j���|j���|jj��S)NzmarkClass {} {} @{};)r�r�r�rWr�r�r�s rQr�zMarkClassDefinition.asFeaMsB��%�,�,� �K� � � � ���!2�!2�!4�!4�d�n�6I� � � rSr�r�r�rNrSrQrr,sY��������,M�M�M�M� &�&�&� � � � � � rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) rz�A ``sub ... from ...`` statement. ``glyph`` and ``replacement`` should be `glyph-containing objects`_. ``prefix`` and ``suffix`` should be lists of `glyph-containing objects`_.Nc�v�t�||��|||c|_|_|_||_dSr�)rBr��prefixr��suffix� replacement)r�rVr�rWrXr�s rQr�z AlternateSubstStatement.__init__Ys<�����4��*�*�*�06��v�,�� �T�Z���&����rSc�N�|j���}t|��dks J|���t|��d}d�|jD��}d�|jD��}|j���}|�|j||||��dS)z5Calls the builder's ``add_alternate_subst`` callback.r�rc�6�g|]}|�����SrN�r��rO�ps rQrz1AlternateSubstStatement.build.<locals>.<listcomp>c� ��4�4�4�1�!�*�*�,�,�4�4�4rSc�6�g|]}|�����SrNr[�rOr�s rQrz1AlternateSubstStatement.build.<locals>.<listcomp>dr^rSN) r�r�r��listrVrWrX�add_alternate_substr�)r�r�r�rVrWrXs rQr�zAlternateSubstStatement.build^s���� �#�#�%�%���5�z�z�Q���������U� � �A���4�4�� �4�4�4��4�4�� �4�4�4���&�/�/�1�1� ��#�#�D�M�6�5�&�+�V�V�V�V�VrSr�c��d}t|j��st|j��r�t|j��r3|d�t t |j����dzz }|t |j��dzz }t|j��r3|dd�t t |j����zz }n|t |j��z }|dz }|t |j��z }|dz }|S)N�sub r��'z from r8)r�rVrWrTr�r�r�rXr�s rQr�zAlternateSubstStatement.asFeahs����� �t�{� � � %�s�4�;�/�/� %��4�;��� ?��s�x�x��E�4�;� 7� 7�8�8�3�>�>�� �5���$�$�s�*� *�C��4�;��� ?��s�S�X�X�c�%���&=�&=�>�>�>�>��� �5���$�$� $�C� �x��� �u�T�%�&�&�&�� �s� ��� rSr�r�rrNrSrQrrSsZ������Q�Q� '�'�'�'� W�W�W� � � � � � rSrc�,�eZdZdZ dd�Zdd�ZdS)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��t�||��||_|||c|_|_|_||c|_|_dSr�)r'r�r��x�y� contourpoint� xDeviceTable� yDeviceTable)r�rhrir�rjrkrlr�s rQr�zAnchor.__init__sP�� ���D�(�+�+�+��� �,-�q�,�)������)�/;�\�,���4�,�,�,rSr�c�f�|j�d�|j��Sd�|j|j��}|jr|d�|j��z }|js|jr8|dz }|t|j��z }|dz }|t|j��z }|dz }|S)Nz <anchor {}>z <anchor {} {}� contourpoint {}r��>)r�r�rhrirjrkrlrVr�s rQr�z Anchor.asFea�s��� �9� � �'�'�� �2�2� 2��$�$�T�V�T�V�4�4�� � � @� �%�,�,�T�->�?�?� ?�C� � � 5�� 1� 5� �3�J�C� �>�$�"3�4�4� 4�C� �3�J�C� �>�$�"3�4�4� 4�C� �s� ��� rS)NNNNNr�r�rNrSrQrrxs[������������� J� J� J� J� � � � � � rSrc�"�eZdZdZdd�Zdd�ZdS)rzCA named anchor definition. (2.e.viii). ``name`` should be a string.Nc�z�t�||��||||f\|_|_|_|_dSr�)rBr�r�rhrirj)r�r�rhrirjr�s rQr�zAnchorDefinition.__init__�s>�����4��*�*�*�7;�Q��<�7O�4�� �4�6�4�6�4�#4�#4�#4rSr�c���d�|j|j��}|jr|d�|j��z }|d�|j��z }|S)NzanchorDef {} {}rnz {};)r�rhrirjr�r�s rQr�zAnchorDefinition.asFea�s`���&�&�t�v�t�v�6�6�� � � @� �%�,�,�T�->�?�?� ?�C� �v�}�}�T�Y�'�'�'��� rSr�r�r�rNrSrQrr�sF������M�M�P�P�P�P������rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) rz&A ``GDEF`` table ``Attach`` statement.Nc�X�t�||��||_||_dSr�)rBr�r�� contourPoints)r�r�rur�s rQr�zAttachStatement.__init__�s-�����4��*�*�*��� �*����rSc�z�|j���}|�|j||j��dS)z3Calls the builder's ``add_attach_points`` callback.N)r�r��add_attach_pointsr�ru�r�r�r�s rQr�zAttachStatement.build�s8����%�%�'�'���!�!�$�-���9K�L�L�L�L�LrSr�c��d�|j���d�d�|jD������S)Nz Attach {} {};r�c3�4K�|]}t|��V��dSr���str)rO�cs rQrRz(AttachStatement.asFea.<locals>.<genexpr>�s(����)M�)M�Q�#�a�&�&�)M�)M�)M�)M�)M�)MrS)r�r�r�rTrur�s rQr�zAttachStatement.asFea�sK���%�%� �K� � � � ����)M�)M�$�:L�)M�)M�)M�!M�!M� � � rSr�r�rrNrSrQrr�sT������0�0�+�+�+�+� M�M�M�  � � � � � rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) 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��t�||��|||c|_|_|_t |��|_t|��D]0\}}|r) d�|D���#t$r|g|j|<Y�,wxYw�1dS)Nc3�K�|]}|V��dSr�rN�rO�_s rQrRz4ChainContextPosStatement.__init__.<locals>.<genexpr>��"����'�'�1�Q�'�'�'�'�'�'rS� rBr�rVr�rWra�lookupsr_� TypeError�r�rVr�rWr�r��irms rQr�z!ChainContextPosStatement.__init__�������4��*�*�*�06���-�� �T�[�$�+��G�}�}�� �"�7�+�+� /� /�I�A�v�� /�/�'�'��'�'�'�'�'�� �/�/�/�'-�h�D�L��O�O�O�/���� /� /� /�� A*�*B�Bc��d�|jD��}d�|jD��}d�|jD��}|�|j||||j��dS)z7Calls the builder's ``add_chain_context_pos`` callback.c�6�g|]}|�����SrNr[r\s rQrz2ChainContextPosStatement.build.<locals>.<listcomp>�r^rSc�6�g|]}|�����SrNr[�rOr�s rQrz2ChainContextPosStatement.build.<locals>.<listcomp>�r^rSc�6�g|]}|�����SrNr[r`s rQrz2ChainContextPosStatement.build.<locals>.<listcomp>�r^rSN)rVr�rW�add_chain_context_posr�r��r�r�rVr�rWs rQr�zChainContextPosStatement.build�sr��4�4�� �4�4�4��4�4�� �4�4�4��4�4�� �4�4�4���%�%� �M�6�6�6�4�<� � � � � rSr�c� �d}t|j��s3t|j��std�|jD�����rt|j��r*|d�d�|jD����dzz }t |j��D]i\}}||���dzz }|j|r|j|D]}|d|j zz }�|t|j��dz kr|dz }�jt|j��r3|dd�tt|j����zz }n0|d�tt|j ����z }|dz }|S) N�pos c��g|]}|du��Sr�rN�rOrhs rQrz2ChainContextPosStatement.asFea.<locals>.<listcomp>����8�8�8�a�A�T�M�8�8�8rSr�c3�>K�|]}|���V��dSr�r�r�s rQrRz1ChainContextPosStatement.asFea.<locals>.<genexpr>��*����?�?�a���� � �?�?�?�?�?�?rSre� lookup r�r8� r�rVrW�anyr�rTr_r�r�r�r�r��r�r�r�r�r��lus rQr�zChainContextPosStatement.asFea������ �� � � � 4��4�;��� 4��8�8�4�<�8�8�8�9�9� 4� �4�;��� F��s�x�x�?�?�4�;�?�?�?�?�?�#�E�E��!�$�+�.�.� � ���1��q�w�w�y�y�3��&���<��?�4�"�l�1�o�4�4���z�B�G�3�3����s�4�;�'�'�!�+�+�+��3�J�C���4�;��� ?��s�S�X�X�c�%���&=�&=�>�>�>�>��� �3�8�8�C��t�z�2�2�3�3� 3�C� �s� ��� rSr�r�rrNrSrQr r ��U������ � � /� /� /� /� � � ������rSr c�(�eZdZdZdd�Zd�Zdd�ZdS) 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��t�||��|||c|_|_|_t |��|_t|��D]0\}}|r) d�|D���#t$r|g|j|<Y�,wxYw�1dS)Nc3�K�|]}|V��dSr�rNr�s rQrRz6ChainContextSubstStatement.__init__.<locals>.<genexpr>r�rSr�r�s rQr�z#ChainContextSubstStatement.__init__r�r�c��d�|jD��}d�|jD��}d�|jD��}|�|j||||j��dS)z9Calls the builder's ``add_chain_context_subst`` callback.c�6�g|]}|�����SrNr[r\s rQrz4ChainContextSubstStatement.build.<locals>.<listcomp>r^rSc�6�g|]}|�����SrNr[r�s rQrz4ChainContextSubstStatement.build.<locals>.<listcomp>r^rSc�6�g|]}|�����SrNr[r`s rQrz4ChainContextSubstStatement.build.<locals>.<listcomp>r^rSN)rVr�rW�add_chain_context_substr�r�r�s rQr�z ChainContextSubstStatement.buildsr��4�4�� �4�4�4��4�4�� �4�4�4��4�4�� �4�4�4���'�'� �M�6�6�6�4�<� � � � � rSr�c� �d}t|j��s3t|j��std�|jD�����rt|j��r*|d�d�|jD����dzz }t |j��D]i\}}||���dzz }|j|r|j|D]}|d|j zz }�|t|j��dz kr|dz }�jt|j��r3|dd�tt|j����zz }n0|d�tt|j ����z }|dz }|S) Nrdc��g|]}|du��Sr�rNr�s rQrz4ChainContextSubstStatement.asFea.<locals>.<listcomp> r�rSr�c3�>K�|]}|���V��dSr�r�r�s rQrRz3ChainContextSubstStatement.asFea.<locals>.<genexpr>#r�rSrer�r�r8r�r�s rQr�z ChainContextSubstStatement.asFear�rSr�r�rrNrSrQr!r!�r�rSr!c�(�eZdZdZdd�Zd�Zdd�ZdS) r$znA cursive positioning statement. Entry and exit anchors can either be :class:`Anchor` objects or ``None``.Nc�h�t�||��||_||c|_|_dSr�)rBr�r�� entryAnchor� exitAnchor)r�r�r�r�r�s rQr�zCursivePosStatement.__init__7s4�����4��*�*�*�$���,7��)���$�/�/�/rSc��|�|j|j���|j|j��dS)z8Calls the builder object's ``add_cursive_pos`` callback.N)�add_cursive_posr�r�r�r�r�r�s rQr�zCursivePosStatement.build<sB����� �M�4�?�3�3�5�5�t�7G��� � � � � rSr�c���|jr|j���nd}|jr|j���nd}d�|j���||��S)N� <anchor NULL>zpos cursive {} {} {};)r�r�r�r�r�)r�r��entry�exits rQr�zCursivePosStatement.asFeaBsh��,0�,<�Q�� �&�&�(�(�(�/��*.�/�N�t��$�$�&�&�&���&�-�-�d�o�.C�.C�.E�.E�u�d�S�S�SrSr�r�rrNrSrQr$r$3s_������/�/�D�D�D�D�  � � � T�T�T�T�T�TrSr$c�(�eZdZdZdd�Zd�Zdd�ZdS) r)zExample: ``feature salt;``Nc�Z�t�||��||c|_|_dSr�)rBr�r�� featureName)r�r�r�s rQr�z"FeatureReferenceStatement.__init__Ks/�����4��*�*�*�+3�[�'�� �t�'�'�'rSc�F�|�|j|j��dS)z>Calls the builder object's ``add_feature_reference`` callback.N)�add_feature_referencer�r�r�s rQr�zFeatureReferenceStatement.buildOs#���%�%�d�m�T�5E�F�F�F�F�FrSr�c�6�d�|j��S)Nz feature {};)r�r�r�s rQr�zFeatureReferenceStatement.asFeaSs���#�#�D�$4�5�5�5rSr�r�rrNrSrQr)r)HsX������$�$�B�B�B�B�G�G�G�6�6�6�6�6�6rSr)c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�J�t�||��||_dSr��rBr�� chainContexts�r�r�r�s rQr�zIgnorePosStatement.__init__^�&�����4��*�*�*�*����rSc��|jD]H\}}}d�|D��}d�|D��}d�|D��}|�|j|||g���IdS)z[Calls the builder object's ``add_chain_context_pos`` callback on each rule context.c�6�g|]}|�����SrNr[r\s rQrz,IgnorePosStatement.build.<locals>.<listcomp>f� ��3�3�3�q�a�j�j�l�l�3�3�3rSc�6�g|]}|�����SrNr[r�s rQrz,IgnorePosStatement.build.<locals>.<listcomp>gr�rSc�6�g|]}|�����SrNr[r`s rQrz,IgnorePosStatement.build.<locals>.<listcomp>hr�rSN)r�r�r�r�s rQr�zIgnorePosStatement.buildbs���'+�&8� U� U� "�F�F�F�3�3�F�3�3�3�F�3�3�F�3�3�3�F�3�3�F�3�3�3�F� � )� )�$�-����QS� T� T� T� T�  U� UrSr�c �V�g}|jD�]\}}}d}t|��st|��r�t|��r.|d�tt|����dzz }|d�d�|D����z }t|��r.|dd�tt|����zz }n+|d�tt|����z }|�|����dd�|��zdzS)Nr�r�c3�DK�|]}|���dzV��dS�reNr�r�s rQrRz+IgnorePosStatement.asFea.<locals>.<genexpr>rs.����@�@�A���� � �C��@�@�@�@�@�@rSz ignore pos rLr8�r�r�rTr�r�r��r�r��contextsrVr�rWr�s rQr�zIgnorePosStatement.asFeaks����&*�&8� !� !� "�F�F�F��C��6�{�{� 4�c�&�k�k� 4��v�;�;�>��3�8�8�C��v�$6�$6�7�7�#�=�=�C��s�x�x�@�@��@�@�@�@�@�@���v�;�;�>��3����#�e�V�*<�*<�!=�!=�=�=�C���s�x�x��E�6� 2� 2�3�3�3�� �O�O�C� � � � ��t�y�y��2�2�2�S�8�8rSr�r�rrNrSrQr,r,WsX������%�%� +�+�+�+�U�U�U� 9� 9� 9� 9� 9� 9rSr,c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�J�t�||��||_dSr�r�r�s rQr�zIgnoreSubstStatement.__init__�r�rSc��|jD]H\}}}d�|D��}d�|D��}d�|D��}|�|j|||g���IdS)z]Calls the builder object's ``add_chain_context_subst`` callback on each rule context.c�6�g|]}|�����SrNr[r\s rQrz.IgnoreSubstStatement.build.<locals>.<listcomp>�r�rSc�6�g|]}|�����SrNr[r�s rQrz.IgnoreSubstStatement.build.<locals>.<listcomp>�r�rSc�6�g|]}|�����SrNr[r`s rQrz.IgnoreSubstStatement.build.<locals>.<listcomp>�r�rSN)r�r�r�r�s rQr�zIgnoreSubstStatement.build�s���'+�&8� W� W� "�F�F�F�3�3�F�3�3�3�F�3�3�F�3�3�3�F�3�3�F�3�3�3�F� � +� +�D�M�6�6�6�SU� V� V� V� V�  W� WrSr�c ��g}|jD]�\}}}d}t|��r.|d�tt|����dzz }|d�d�|D����z }t|��r.|dd�tt|����zz }|�|����dd�|��zdzS)Nr�r�c3�DK�|]}|���dzV��dSr�r�r�s rQrRz-IgnoreSubstStatement.asFea.<locals>.<genexpr>�s.����<�<��A�G�G�I�I��O�<�<�<�<�<�<rSz ignore sub rLr8r�r�s rQr�zIgnoreSubstStatement.asFea�s�����&*�&8� !� !� "�F�F�F��C��6�{�{� :��s�x�x��E�6� 2� 2�3�3�c�9�9�� �3�8�8�<�<�V�<�<�<�<�<� <�C��6�{�{� :��s�S�X�X�c�%��&8�&8�9�9�9�9�� �O�O�C� � � � ��t�y�y��2�2�2�S�8�8rSr�r�rrNrSrQr-r-{sX������%�%� +�+�+�+�W�W�W� 9� 9� 9� 9� 9� 9rSr-c�2��eZdZdZd�fd� Zd�Zdd�Z�xZS) r.zAn ``include()`` statement.Nc�f��tt|���|��||_dSr�)r�r.r��filename)r�r�r�r�s �rQr�zIncludeStatement.__init__�s-��� ���%�%�.�.�x�8�8�8� �� � � rSc�,�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� � � rSr�c��|d|jzzS)Nz include(%s);)r�r�s rQr�zIncludeStatement.asFea�s������6�6�6rSr�r�)r�r�r�r�r�r�r�r�r�s@rQr.r.�sf�������%�%�!�!�!�!�!�!� � � �7�7�7�7�7�7�7�7rSr.c�(�eZdZdZd d�Zd�Zd d�ZdS) r/z*A ``language`` statement within a feature.TFNc��t�||��t|��dksJ�||_||_||_dS)N�)rBr�r�rk�include_defaultrw)r�rkr�rwr�s rQr�zLanguageStatement.__init__�sI�����4��*�*�*��8�}�}��!�!�!�!� �� �.��� �� � � rSc�`�|�|j|j|j|j���dS)z4Call the builder object's ``set_language`` callback.)r�rkr�rwN)� set_languager�rkr�rwr�s rQr�zLanguageStatement.build�s>������]��]� �0��]� � � � � � rSr�c��d�|j�����}|js|dz }|jr|dz }|dz }|S)Nz language {}z exclude_dfltz requiredr8)r�rkr"r�rwr�s rQr�zLanguageStatement.asFea�sZ���"�"�4�=�#6�#6�#8�#8�9�9���#� #� �?� "�C� �=� � �;� �C� �s� ��� rS)TFNr�rrNrSrQr/r/�sQ������4�4�!�!�!�!� � � ������rSr/c�(�eZdZdZdd�Zd�Zdd�ZdS) r0z)A top-level ``languagesystem`` statement.Nc�Z�t�||��||c|_|_dSr�)rBr�r{rk)r�r{rkr�s rQr�z LanguageSystemStatement.__init__�s,�����4��*�*�*�&,�h�"�� �T�]�]�]rSc�R�|�|j|j|j��dS)z<Calls the builder object's ``add_language_system`` callback.N)�add_language_systemr�r{rkr�s rQr�zLanguageSystemStatement.build�s&���#�#�D�M�4�;�� �N�N�N�N�NrSr�c�f�d�|j|j�����S)Nzlanguagesystem {} {};)r�r{rkr"r�s rQr�zLanguageSystemStatement.asFea�s(��&�-�-�d�k�4�=�;N�;N�;P�;P�Q�Q�QrSr�r�rrNrSrQr0r0�sZ������3�3�8�8�8�8�O�O�O�R�R�R�R�R�RrSr0c�(�eZdZdZdd�Zd�Zdd�ZdS) r*z�A ``head`` table ``FontRevision`` statement. ``revision`` should be a number, and will be formatted to three significant decimal places.Nc�J�t�||��||_dSr�)rBr��revision)r�r�r�s rQr�zFontRevisionStatement.__init__�s#�����4��*�*�*� �� � � rSc�F�|�|j|j��dSr�)�set_font_revisionr�r�r�s rQr�zFontRevisionStatement.build�s"���!�!�$�-���?�?�?�?�?rSr�c�6�d�|j��S)NzFontRevision {:.3f};)r�r�r�s rQr�zFontRevisionStatement.asFea�s��%�,�,�T�]�;�;�;rSr�r�rrNrSrQr*r*�sZ������J�J�!�!�!�!�@�@�@�<�<�<�<�<�<rSr*c�(�eZdZdZdd�Zd�Zdd�ZdS) r1z�A ``GDEF`` table ``LigatureCaretByIndex`` statement. ``glyphs`` should be a `glyph-containing object`_, and ``carets`` should be a list of integers.Nc�Z�t�||��||c|_|_dSr��rBr�r��carets�r�r�r�r�s rQr�z&LigatureCaretByIndexStatement.__init__��,�����4��*�*�*�$*�F� �� �T�[�[�[rSc��|j���}|�|j|t |j����dS)zBCalls the builder object's ``add_ligatureCaretByIndex_`` callback.N)r�r��add_ligatureCaretByIndex_r��setr�rxs rQr�z#LigatureCaretByIndexStatement.build�s?����%�%�'�'���)�)�$�-���T�[�AQ�AQ�R�R�R�R�RrSr�c��d�|j���d�d�|jD������S)NzLigatureCaretByIndex {} {};r�c3�4K�|]}t|��V��dSr�r{r�s rQrRz6LigatureCaretByIndexStatement.asFea.<locals>.<genexpr>��(����)F�)F�Q�#�a�&�&�)F�)F�)F�)F�)F�)FrS�r�r�r�rTr�r�s rQr�z#LigatureCaretByIndexStatement.asFea�sJ��,�3�3� �K� � � � ����)F�)F�$�+�)F�)F�)F�!F�!F� � � rSr�r�rrNrSrQr1r1�sZ������R�R�4�4�4�4�S�S�S�  � � � � � rSr1c�(�eZdZdZdd�Zd�Zdd�ZdS) r2z�A ``GDEF`` table ``LigatureCaretByPos`` statement. ``glyphs`` should be a `glyph-containing object`_, and ``carets`` should be a list of integers.Nc�Z�t�||��||c|_|_dSr�r�r�s rQr�z$LigatureCaretByPosStatement.__init__r�rSc��|j���}|�|j|t |j����dS)z@Calls the builder object's ``add_ligatureCaretByPos_`` callback.N)r�r��add_ligatureCaretByPos_r�r�r�rxs rQr�z!LigatureCaretByPosStatement.builds?����%�%�'�'���'�'�� �v�s�4�;�?O�?O�P�P�P�P�PrSr�c��d�|j���d�d�|jD������S)NzLigatureCaretByPos {} {};r�c3�4K�|]}t|��V��dSr�r{r�s rQrRz4LigatureCaretByPosStatement.asFea.<locals>.<genexpr> r�rSr�r�s rQr�z!LigatureCaretByPosStatement.asFea sJ��*�1�1� �K� � � � ����)F�)F�$�+�)F�)F�)F�!F�!F� � � rSr�r�rrNrSrQr2r2�sZ������R�R�4�4�4�4�Q�Q�Q�  � � � � � rSr2c�(�eZdZdZdd�Zd�Zdd�ZdS) 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��t�||��|||c|_|_|_||c|_|_dSr�)rBr�rVr�rWrX� forceChain)r�rVr�rWrXrr�s rQr�zLigatureSubstStatement.__init__sC�����4��*�*�*�17���-�� �T�[�$�+�,7��)���$�/�/�/rSc��d�|jD��}d�|jD��}d�|jD��}|�|j||||j|j��dS)Nc�6�g|]}|�����SrNr[r\s rQrz0LigatureSubstStatement.build.<locals>.<listcomp> r^rSc�6�g|]}|�����SrNr[r�s rQrz0LigatureSubstStatement.build.<locals>.<listcomp>!r^rSc�6�g|]}|�����SrNr[r`s rQrz0LigatureSubstStatement.build.<locals>.<listcomp>"r^rS)rVr�rW�add_ligature_substr�rXrr�s rQr�zLigatureSubstStatement.buildsw��4�4�� �4�4�4��4�4�� �4�4�4��4�4�� �4�4�4���"�"� �M�6�6�6�4�3C�T�_� � � � � rSr�c�@�d}t|j��st|j��s|jr�t|j��r*|d�d�|jD����dzz }|d�d�|jD����z }t|j��r*|dd�d�|jD����zz }n'|d�d�|jD����z }|dz }|t |j��z }|dz }|S) Nrdr�c3�>K�|]}|���V��dSr�r�r�s rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>+r�rSc3�DK�|]}|���dzV��dSr�r�r�s rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>,s.����A�A��A�G�G�I�I��O�A�A�A�A�A�ArSc3�>K�|]}|���V��dSr�r�r�s rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>.s*����%E�%E�A�a�g�g�i�i�%E�%E�%E�%E�%E�%ErSc3�>K�|]}|���V��dSr�r�r�s rQrRz/LigatureSubstStatement.asFea.<locals>.<genexpr>0s*����;�;�!�A�G�G�I�I�;�;�;�;�;�;rS� by r8)r�rVrWrrTr�r�rXr�s rQr�zLigatureSubstStatement.asFea's,���� �t�{� � � <�s�4�;�/�/� <�4�?� <��4�;��� F��s�x�x�?�?�4�;�?�?�?�?�?�#�E�E�� �3�8�8�A�A�T�[�A�A�A�A�A� A�C��4�;��� F��s�S�X�X�%E�%E���%E�%E�%E�E�E�E�E��� �3�8�8�;�;�t�{�;�;�;�;�;� ;�C� �v� �� �u�T�%�&�&�&�� �s� ��� rSr�r�rrNrSrQr3r3s[������B�B�D�D�D�D�  � � � � � � � � rSr3c�*�eZdZdZ dd�Zd�Zd d�ZdS) 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.rNc�f�t�||��||_||_||_dSr�)rBr�r�markAttachment�markFilteringSet)r�rrrr�s rQr�zLookupFlagStatement.__init__=s7�� ���4��*�*�*��� �,��� 0����rSc���d}|j�|j���}d}|j�|j���}|�|j|j||��dS)z8Calls the builder object's ``set_lookup_flag`` callback.N)rr�r�set_lookup_flagr�r)r�r�� markAttach� markFilters rQr�zLookupFlagStatement.buildEsj��� � � � *��,�5�5�7�7�J�� � � � ,��.�7�7�9�9�J����� �t�z�:�z�R�R�R�R�RrSr�c��g}gd�}d}tt|����D]0}|j|zdkr|�||��|dz}�1|j�?|�d�|j�������|j�?|�d�|j�������|sdg}d�d�|����S) N)� RightToLeft�IgnoreBaseGlyphs�IgnoreLigatures� IgnoreMarksr�rzMarkAttachmentType {}zUseMarkFilteringSet {}�0zlookupflag {};r�) �ranger�rr�rr�r�rrT)r�r�r��flagsr�r�s rQr�zLookupFlagStatement.asFeaOs����U�U�U�����s�5�z�z�"�"� � �A��z�D� �A�%�%�� � �5��8�$�$�$��1�9�D�D� � � *� �J�J�.�5�5�d�6I�6O�6O�6Q�6Q�R�R� S� S� S� � � ,� �J�J�/�6�6�t�7L�7R�7R�7T�7T�U�U� V� V� V�� ��%�C��&�&�s�x�x��}�}�5�5�5rS)rNNNr�rrNrSrQr4r47s_������!�!� MQ�1�1�1�1�S�S�S�6�6�6�6�6�6rSr4c�(�eZdZdZdd�Zd�Zdd�ZdS) r5z�Represents a ``lookup ...;`` statement to include a lookup in a feature. The ``lookup`` should be a :class:`LookupBlock` object.Nc�Z�t�||��||c|_|_dSr�)rBr�r�rm)r�rmr�s rQr�z!LookupReferenceStatement.__init__es,�����4��*�*�*�&.��"�� �t�{�{�{rSc�D�|�|jj��dS)z8Calls the builder object's ``add_lookup_call`` callback.N)�add_lookup_callrmr�r�s rQr�zLookupReferenceStatement.buildis!������ � 0�1�1�1�1�1rSr�c�@�d�|jj��S)Nz lookup {};)r�rmr�r�s rQr�zLookupReferenceStatement.asFeams���"�"�4�;�#3�4�4�4rSr�r�rrNrSrQr5r5`sU������?�?�8�8�8�8�2�2�2�5�5�5�5�5�5rSr5c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�Z�t�||��||c|_|_dSr�)rBr�r��marks)r�r�r#r�s rQr�zMarkBasePosStatement.__init__vs,�����4��*�*�*� $�e��� �4�:�:�:rSc�v�|�|j|j���|j��dS)z:Calls the builder object's ``add_mark_base_pos`` callback.N)�add_mark_base_posr�r�r�r#r�s rQr�zMarkBasePosStatement.buildzs2���!�!�$�-���1C�1C�1E�1E�t�z�R�R�R�R�RrSr�c���d�|j�����}|jD]C\}}|d|ztzd�|���|j��zz }�D|dz }|S)Nz pos base {}r� {} mark @{}r8)r�r�r�r#rr��r�r�r��a�ms rQr�zMarkBasePosStatement.asFea~sz���"�"�4�9�?�?�#4�#4�5�5���J� S� S�D�A�q� �4�&�=�5�(�=�+?�+?���� � �1�6�+R�+R�R� R�C�C� �s� ��� rSr�r�rrNrSrQr6r6qsX������5�5�,�,�,�,�S�S�S������rSr6c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�Z�t�||��||c|_|_dSr�)rBr�� ligaturesr#)r�r-r#r�s rQr�zMarkLigPosStatement.__init__��,�����4��*�*�*�%.��"���� � � rSc�v�|�|j|j���|j��dS)z9Calls the builder object's ``add_mark_lig_pos`` callback.N)�add_mark_lig_posr�r-r�r#r�s rQr�zMarkLigPosStatement.build�s2��� � �����0G�0G�0I�0I�4�:�V�V�V�V�VrSr�c���d�|j�����}g}|jD]�}d}|�t |��sd|zt dzzdz}nI|D]F\}}|d|zt dzzd�|���|j��zz }�G|�|����|d|zt zdz�|��z }|dz }|S) Nzpos ligature {}r�rr�r�r'� ligComponentr8) r�r-r�r#r�rr�r�rT)r�r�r��ligs�l�tempr)r*s rQr�zMarkLigPosStatement.asFea�s ���&�&�t�~�';�';�'=�'=�>�>������ � �A��D��y��A���y��f�}�u�q�y�0�?�B������D�A�q��� �!��!�)�$�(�.�.�q�w�w�y�y�!�&�A�A�B��D�D� �K�K�� � � � � ��v� ��%��6�<�<�T�B�B�B�� �s� ��� rSr�r�rrNrSrQr7r7�sX��������46�6�6�6�W�W�W������rSr7c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�Z�t�||��||c|_|_dSr�)rBr�� baseMarksr#)r�r8r#r�s rQr�zMarkMarkPosStatement.__init__�r.rSc�v�|�|j|j���|j��dS)z:Calls the builder object's ``add_mark_mark_pos`` callback.N)�add_mark_mark_posr�r8r�r#r�s rQr�zMarkMarkPosStatement.build�s2���!�!�$�-���1H�1H�1J�1J�D�J�W�W�W�W�WrSr�c���d�|j�����}|jD]C\}}|d|ztzd�|���|j��zz }�D|dz }|S)Nz pos mark {}rr'r8)r�r8r�r#rr�r(s rQr�zMarkMarkPosStatement.asFea�s|���"�"�4�>�#7�#7�#9�#9�:�:���J� S� S�D�A�q� �4�&�=�5�(�=�+?�+?���� � �1�6�+R�+R�R� R�C�C� �s� ��� rSr�r�rrNrSrQr8r8�sX������5�5�6�6�6�6�X�X�X������rSr8c�*�eZdZdZ dd�Zd�Zd d�ZdS) 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. FNc��t�||��|||c|_|_|_||_||_dSr�)rBr�rVr�rWrXr)r�rVr�rWrXrr�s rQr�zMultipleSubstStatement.__init__�sC�� ���4��*�*�*�/5�u�f�,�� �T�Z���&���$����rSc ��d�|jD��}d�|jD��}t|jd��r|j���}n|jg}t |��}g}|jD]j}t|d��r|���}n|g}t |��dkrt |��|kr||z}|�|���ktt|���}t��} t|��D]L\} } | | vrC| � | ��|� |j|| ||r|| pd|j���MdS)z;Calls the builder object's ``add_multiple_subst`` callback.c�6�g|]}|�����SrNr[r\s rQrz0MultipleSubstStatement.build.<locals>.<listcomp>�r^rSc�6�g|]}|�����SrNr[r`s rQrz0MultipleSubstStatement.build.<locals>.<listcomp>�r^rSr�r�rNN)rVrWr�r�r�r�rXr�ra�zipr�r_�add�add_multiple_substr�r) r�r�rVrW� originals�count�replaces�r�replace�seen_originalsr�r�s rQr�zMultipleSubstStatement.build�s���4�4�� �4�4�4��4�4�� �4�4�4�� �4�:�z� *� *� %�� �+�+�-�-�I�I��� �I��I�������!� %� %�A��q�*�%�%� ��*�*�,�,����#���7�|�|�q� � �S��\�\�U�%:�%:�!�E�/�� �O�O�G� $� $� $� $���X��'�'������$�Y�/�/� � �K�A�x��~�-�-��"�"�8�,�,�,��*�*��M�����,��!��2���O� ���� � rSr�c�~�d}t|j��st|j��s|jr�t|j��r3|d�t t |j����dzz }|t |j��dzz }t|j��r3|dd�t t |j����zz }n|t |j��z }|jpt��g}|dz }|d�t t |����z }|dz }|S)Nrdr�rer r8) r�rVrWrrTr�r�r�rXr�)r�r�r�rXs rQr�zMultipleSubstStatement.asFeas���� �t�{� � � %�s�4�;�/�/� %�4�?� %��4�;��� ?��s�x�x��E�4�;� 7� 7�8�8�3�>�>�� �5���$�$�s�*� *�C��4�;��� ?��s�S�X�X�c�%���&=�&=�>�>�>�>��� �5���$�$� $�C��&�7�9�;�;�-� � �v� �� �s�x�x��E�;�/�/�0�0�0�� �s� ��� rSr#r�rrNrSrQr9r9�s]������ � �NR�%�%�%�%����B�����rSr9c�,�eZdZdZ dd�Zd�Zd d�ZdS) 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>`_. FNc��t�||��||_||c|_|_||c|_|_dSr�)rBr�� enumerated�glyphs1� valuerecord1�glyphs2� valuerecord2)r�rNrOrPrQrMr�s rQr�zPairPosStatement.__init__#sI�� ���4��*�*�*�$���*1�<�'�� �d�'�*1�<�'�� �d�'�'�'rSc��|jr�|j���|j���g}d}t j|�D]/\}}d}|�|j||j||j ���0|std|j���dSt|jt��ot|jt��}|r>|�|j|jj |j|jj |j ��dS|�|j|j���|j|j���|j ��dS)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)rMrNr�rP� itertools�product�add_specific_pair_posr�rOrQrr�r r��add_class_pair_pos)r�r�r�� seen_pair�glyph1�glyph2� is_specifics rQr�zPairPosStatement.build1s��� �?� ���&�&�(�(�$�,�*?�*?�*A�*A�B�A��I�"+�"3�Q�"7� � ���� � ��-�-��M�6�4�+<�f�d�FW������ �%�;�T�]���� �F� ���y�9�9� �j� �L�)�? �? � � � � � )� )�� �� �"��!�� �"��!�  � � � � � � &� &�� �� �%�%�'�'��!�� �%�%�'�'��!�  � � � � rSr�c���|jrdnd}|jrx|d�|j���|j���|j���|j�����z }n_|d�|j���|j���|j�����z }|S)Nzenum r�zpos {} {} {} {};z pos {} {} {};)rMrQr�rNr�rOrPr�s rQr�zPairPosStatement.asFea\s�����0�g�g�b�� � � � �%�,�,�� �"�"�$�$��!�'�'�)�)�� �"�"�$�$��!�'�'�)�)� �� �C�C� �?�)�)�� �"�"�$�$�d�l�&8�&8�&:�&:�D�<M�<S�<S�<U�<U��� �C�� rSr#r�rrNrSrQr<r<sb���������� @� @� @� @�)�)�)�V � � � � � rSr<c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�v�t�||��||c|_|_||_||_dSr�)rBr�� old_prefix� old_suffixr�� replacements)r�r^r_r�r`r�s rQr�z)ReverseChainSingleSubstStatement.__init__us=�����4��*�*�*�+5�z�(������� �(����rSc ��d�|jD��}d�|jD��}|jd���}|jd���}t |��dkr|t |��z}|�|j||tt||������dS)Nc�6�g|]}|�����SrNr[r\s rQrz:ReverseChainSingleSubstStatement.build.<locals>.<listcomp>|� ��8�8�8�1�!�*�*�,�,�8�8�8rSc�6�g|]}|�����SrNr[r`s rQrz:ReverseChainSingleSubstStatement.build.<locals>.<listcomp>}rcrSrr�) r^r_r�r�r`r��add_reverse_chain_single_substr��dictrA�r�r�rVrWrDrFs rQr�z&ReverseChainSingleSubstStatement.build{s���8�8���8�8�8��8�8���8�8�8���K��N�+�+�-�-� ��$�Q�'�0�0�2�2�� �x�=�=�A� � ��#�i�.�.�0�H��.�.� �M�6�6�4��I�x�0H�0H�+I�+I� � � � � rSr�c�v�d}t|j��st|j��r�t|j��r*|d�d�|jD����dzz }|d�d�|jD����z }t|j��r*|dd�d�|jD����zz }n0|d�t t |j����z }|d�d�d�|jD������z }|S)Nzrsub r�c3�4K�|]}t|��V��dSr�r�r�s rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>�s(����B�B�Q��a���B�B�B�B�B�BrSc3�:K�|]}t|��dzV��dSr�r�r�s rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>��,����@�@�q�E�!�H�H�s�N�@�@�@�@�@�@rSc3�4K�|]}t|��V��dSr�r�r�s rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>�s(����%H�%H�1�e�A�h�h�%H�%H�%H�%H�%H�%HrS� by {};c3�4K�|]}t|��V��dSr�r�r�s rQrRz9ReverseChainSingleSubstStatement.asFea.<locals>.<genexpr>��(����(M�(M�a��q���(M�(M�(M�(M�(M�(MrS) r�r^r_rTr�r�r�r�r`r�s rQr�z&ReverseChainSingleSubstStatement.asFea�s-���� �t�� � � 5�3�t��#7�#7� 5��4�?�#�#� I��s�x�x�B�B�$�/�B�B�B�B�B�S�H�H�� �3�8�8�@�@�D�K�@�@�@�@�@� @�C��4�?�#�#� I��s�S�X�X�%H�%H���%H�%H�%H�H�H�H�H��� �3�8�8�C��t�{�3�3�4�4� 4�C� �y������(M�(M�4�;L�(M�(M�(M� M� M�N�N�N��� rSr�r�rrNrSrQr=r=lsU��������)�)�)�)�  �  �  � � � � � � rSr=c�(�eZdZdZdd�Zd�Zdd�ZdS) 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��t�||��||c|_|_||_||_||_dSr�)rBr�rVrWrr�r`)r�r�rHrVrWrr�s rQr�zSingleSubstStatement.__init__�sD�����4��*�*�*�#)�6� �� �T�[�$����� �#����rSc ��d�|jD��}d�|jD��}|jd���}|jd���}t |��dkr|t |��z}|�|j||tt||����|j ��dS)z9Calls the builder object's ``add_single_subst`` callback.c�6�g|]}|�����SrNr[r\s rQrz.SingleSubstStatement.build.<locals>.<listcomp>�r^rSc�6�g|]}|�����SrNr[r`s rQrz.SingleSubstStatement.build.<locals>.<listcomp>�r^rSrr�N) rVrWr�r�r`r��add_single_substr�rrArrgs rQr�zSingleSubstStatement.build�s���4�4�� �4�4�4��4�4�� �4�4�4���K��N�+�+�-�-� ��$�Q�'�0�0�2�2�� �x�=�=�A� � ��#�i�.�.�0�H�� � � �M� � � ��I�x�0�0� 1� 1� �O�  � � � � rSr�c�r�d}t|j��st|j��s|jr�t|j��r*|d�d�|jD����dzz }|d�d�|jD����z }t|j��r*|dd�d�|jD����zz }n'|d�d�|jD����z }|d�d�d�|jD������z }|S) Nrdr�c3�4K�|]}t|��V��dSr�r�r�s rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�s(����>�>�Q��a���>�>�>�>�>�>rSc3�:K�|]}t|��dzV��dSr�r�r�s rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�rkrSc3�4K�|]}t|��V��dSr�r�r�s rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�s(����%D�%D�1�e�A�h�h�%D�%D�%D�%D�%D�%DrSc3�4K�|]}t|��V��dSr�r�r�s rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�s(����:�:��E�!�H�H�:�:�:�:�:�:rSrmc3�4K�|]}t|��V��dSr�r�r�s rQrRz-SingleSubstStatement.asFea.<locals>.<genexpr>�rorS)r�rVrWrrTr�r�r`r�s rQr�zSingleSubstStatement.asFea�s;���� �t�{� � � ;�s�4�;�/�/� ;�4�?� ;��4�;��� E��s�x�x�>�>�$�+�>�>�>�>�>��D�D�� �3�8�8�@�@�D�K�@�@�@�@�@� @�C��4�;��� E��s�S�X�X�%D�%D�� �%D�%D�%D�D�D�D�D��� �3�8�8�:�:�d�k�:�:�:�:�:� :�C� �y������(M�(M�4�;L�(M�(M�(M� M� M�N�N�N��� rSr�r�rrNrSrQr@r@�sU��������$�$�$�$� � � � � � � � � rSr@c�(�eZdZdZdd�Zd�Zdd�ZdS) r>zA ``script`` statement.Nc�J�t�||��||_dSr�)rBr�r{)r�r{r�s rQr�zScriptStatement.__init__�s#�����4��*�*�*��� � � rSc�F�|�|j|j��dS)z,Calls the builder's ``set_script`` callback.N)� set_scriptr�r{r�s rQr�zScriptStatement.build�s"�����4�=�$�+�6�6�6�6�6rSr�c�Z�d�|j�����S)Nz script {};)r�r{r"r�s rQr�zScriptStatement.asFea�s$���"�"�4�;�#4�#4�#6�#6�7�7�7rSr�r�rrNrSrQr>r>�sQ������!�!�����7�7�7�8�8�8�8�8�8rSr>c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�v�t�||��|||c|_|_|_||_dSr�)rBr�rurVrWr)r�rurVrWrr�s rQr�zSinglePosStatement.__init__�s9�����4��*�*�*�-0�&�&�*���$�+�t�{�$����rSc��d�|jD��}d�|jD��}d�|jD��}|�|j||||j��dS)z7Calls the builder object's ``add_single_pos`` callback.c�6�g|]}|�����SrNr[r\s rQrz,SinglePosStatement.build.<locals>.<listcomp>�r^rSc�6�g|]}|�����SrNr[r`s rQrz,SinglePosStatement.build.<locals>.<listcomp>�r^rSc�@�g|]\}}|���|f��SrNr[)rOr�rs rQrz,SinglePosStatement.build.<locals>.<listcomp>�s)��>�>�>���E�� � � � �e�$�>�>�>rSN)rVrWru�add_single_posr�r)r�r�rVrWrus rQr�zSinglePosStatement.build�sg��4�4�� �4�4�4��4�4�� �4�4�4��>�>�T�X�>�>�>�����t�}�f�f�c�4�?�S�S�S�S�SrSr�c�,�d}t|j��st|j��s|jr�t|j��r3|d�t t |j����dzz }|d�d�|jD����z }t|j��r3|dd�t t |j����zz }n'|d�d�|jD����z }|dz }|S)Nr�r�c��g|]B}t|d��dz|drd|d���zndz��CS)rrer�r�r�r�r�s rQrz,SinglePosStatement.asFea.<locals>.<listcomp>�s[�������!�A�$�K�K�#�%��1��)M�#��!�� � � � �*<�*<�2�N���rSc��g|]?}t|d��dz|dr|d���ndz��@S)rr�r�r�r�r�s rQrz,SinglePosStatement.asFea.<locals>.<listcomp>�sE��V�V�V���q��t���s�"�a��d�&B�a��d�j�j�l�l�l��C�V�V�VrSr8)r�rVrWrrTr�r�rur�s rQr�zSinglePosStatement.asFea�s���� �t�{� � � �s�4�;�/�/� �4�?� ��4�;��� ?��s�x�x��E�4�;� 7� 7�8�8�3�>�>�� �3�8�8���!�X������ �C� �4�;��� ?��s�S�X�X�c�%���&=�&=�>�>�>�>��� �3�8�8�V�V�T�X�V�V�V��� �C� �s� ��� rSr�r�rrNrSrQr?r?�sX������$�$� %�%�%�%� T�T�T������rSr?c�(�eZdZdZdd�Zd�Zdd�ZdS) rFzRepresents a subtable break.Nc�<�t�||��dSr�)rBr�r�s rQr�zSubtableStatement.__init__�s�����4��*�*�*�*�*rSc�:�|�|j��dS)z<Calls the builder objects's ``add_subtable_break`` callback.N)�add_subtable_breakr�r�s rQr�zSubtableStatement.build�s���"�"�4�=�1�1�1�1�1rSr�c��dS)Nz subtable;rNr�s rQr�zSubtableStatement.asFeas���{rSr�r�rrNrSrQrFrF�sQ������&�&�+�+�+�+�2�2�2������rSrFc�R�eZdZdZ d d�Zd�Zd�Zd�Zd d �Zd �Z e Z dS) rHzRepresents a value record.NFc ���t�|| ��||c|_|_||c|_|_||c|_|_||c|_|_ | |_ dSr�) r'r�� xPlacement� yPlacement�xAdvance�yAdvance� xPlaDevice� yPlaDevice� xAdvDevice� yAdvDevice�vertical) r�r�r�r�r�r�r�r�r�r�r�s rQr�zValueRecord.__init__ se�� ���D�(�+�+�+�,6� �(�����(0�(�$�� �t�}�,6� �(�����,6� �(����� �� � � rSc���|j|jkoO|j|jko?|j|jko/|j|jko|j|jko|j|jkSr�)r�r�r�r�r�r��r��others rQ�__eq__zValueRecord.__eq__sr�� �O�u�/� /� 4���5�#3�3� 4�� ���/� 4�� ���/� 4���5�#3�3�  4� ��5�#3�3�  rSc�.�|�|�� Sr�)r�r�s rQ�__ne__zValueRecord.__ne__(s���;�;�u�%�%�%�%rSc�P�t|j��t|j��z t|j��z t|j��z t|j��z t|j��z t|j��z t|j��z Sr�) �hashr�r�r�r�r�r�r�r�r�s rQ�__hash__zValueRecord.__hash__+s��� ��� !� !��4�?�#�#� $��4�=�!�!� "��4�=�!�!� "��4�?�#�#�  $� �4�?�#�#�  $� �4�?�#�#�  $��4�?�#�#� $� rSr�c���|sdS|j|j}}|j|j}}|j|j}}|j|j} }|j} |�(|�&|�| rt|��S|�| st|��S|pd}|pd}|pd}|pd}|�|�|�| �d|�d|�d|�d|�d� Sd|�d|�d|�d|�dt|���dt|���dt|���dt| ���d�S)Nz<NULL>r�<r�ro) r�r�r�r�r�r�r�r�r�r|rV) r�r�rhrir�r�r�r�r�r�r�s rQr�zValueRecord.asFea7sR��� ��8�����1��!�]�D�M�(��!%��$�/�J� �!%��$�/�J� ��=�� �9�����H���8�}�}�$��!�(�!��8�}�}�$� �F��� �F����=�q���=�q�� � ��"��"��"�"�&'�a�a����H�H�H�h�h�h�?� ?�� �A�A� �A�A� �H�H� �H�H� �:� &� &� &� &� �:� &� &� &� &� �:� &� &� &� &� �:� &� &� &� &�  � rSc�:��t�fd�dD����S)Nc3�<�K�|]}t�|��duV��dSr�)�getattr)rO�vr�s �rQrRz'ValueRecord.__bool__.<locals>.<genexpr>dsF�����  �  �� �D�!� � �D� (�  �  �  �  �  �  rS)r�r�r�r�r�r�r�r�)r�r�s`rQ�__bool__zValueRecord.__bool__cs=����  �  �  �  � �  �  �  �  �  � rS) NNNNNNNNFNr�) r�r�r�r�r�r�r�r�r�r�� __nonzero__rNrSrQrHrHs�������$�$�����������!�!�!�!�( � � �&�&�&�  �  �  �* �* �* �* �X  �  �  ��K�K�KrSrHc�"�eZdZdZdd�Zdd�ZdS)rIz+Represents a named value record definition.Nc�X�t�||��||_||_dSr�)rBr�r�r)r�r�rr�s rQr�zValueRecordDefinition.__init__xs*�����4��*�*�*��� ��� � � rSr�c�f�d�|j���|j��S)NzvalueRecordDef {} {};)r�rr�r�r�s rQr�zValueRecordDefinition.asFea}s(��&�-�-�d�j�.>�.>�.@�.@�$�)�L�L�LrSr�r�r�rNrSrQrIrIusH������5�5����� M�M�M�M�M�MrSrIc��|dkr|dkr|dkrdS|dkr|dkr|dkrdSd�|||��S)N�r�i r�r�1�{} {} {}�r�)�pid�eid�lids rQ�simplify_name_attributesr��sV�� �a�x�x�C�1�H�H������r� ����c�Q�h�h�3�!�8�8��s�� � ��c�3�/�/�/rSc�(�eZdZdZdd�Zd�Zdd�ZdS) r:z�Represents a name record. (`Section 9.e. <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.e>`_)Nc��t�||��||_||_||_||_||_dSr�)rBr��nameID� platformID� platEncID�langID�string)r�r�r�r�r�r�r�s rQr�zNameRecord.__init__�s?�����4��*�*�*��� �$���"����� ��� � � rSc�v�|�|j|j|j|j|j|j��dS)z8Calls the builder object's ``add_name_record`` callback.N)�add_name_recordr�r�r�r�r�r�r�s rQr�zNameRecord.build�sB����� �M� �K� �O� �N� �K� �K�  � � � � rSr�c ����d��t|j|j|j��}|�t d|j���t |j|����|dkr?d���fd�tdt���d��D����}n!d��fd ��D����}t|j|j|j��}|dkr|d z }d � |j ||��S) Nc�J�|dkr|dkr|dvrt|��S||zS)N� �~)�"�\)�chr)r}�escape_patterns rQ�escapez NameRecord.asFea.<locals>.escape�s3���D�y�y�Q�$�Y�Y�1�L�+@�+@��1�v�v� �%��)�)rSzUnsupported encoding)�encoding� utf_16_ber�c ���g|]=}�t�|��dzt�|dz��zd����>S)�r�z\%04x�r)rOr�r�r�s ��rQrz$NameRecord.asFea.<locals>.<listcomp>�sY��������F�7�1�Q�4�=�=�3�.���1�q�5��1B�1B�B�H�M�M���rSrr�c�B��g|]}�t|��d����S)z\%02xr�)rO�br�s �rQrz$NameRecord.asFea.<locals>.<listcomp>�s+���%N�%N�%N�q�f�f�W�Q�Z�Z��&B�&B�%N�%N�%NrSr�znameid {} {}"{}";)rr�r�r�rr�rr�rTrr�r�r�r�)r�r�r��escaped_string�platr�r�s @@rQr�zNameRecord.asFea�s!���� *� *� *��t����� �L�L�� � �!�"8�$�-�H�H� H� �D�K�(� 3� 3� 3�� �{� "� "��W�W������"�1�c�!�f�f�a�0�0������N�N� �W�W�%N�%N�%N�%N�A�%N�%N�%N�O�O�N�'�������U�U�� �2�:�:� �C�K�D�"�)�)�$�+�t�^�L�L�LrSr�r�rrNrSrQr:r:�s]������K�K�����  �  �  �M�M�M�M�M�MrSr:c� �eZdZdZd�Zdd�ZdS)r(z4Represents a ``sizemenuname`` or ``name`` statement.c�p�t�||��|�|j��dS)z8Calls the builder object's ``add_featureName`` callback.N)r:r��add_featureNamer�r�s rQr�zFeatureNameStatement.build�s4������w�'�'�'����� �,�,�,�,�,rSr�c��|jdkrd}nd}t|j|j|j��}|dkr|dz }d�|||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��C�'�������U�U�� �2�:�:� �C�K�D��"�"�3��d�k�:�:�:rSNr�)r�r�r�r�r�r�rNrSrQr(r(�s=������>�>�-�-�-� ;�;�;�;�;�;rSr(c��eZdZdZdd�ZdS)rEz+Represents a STAT table ``name`` statement.r�c��t|j|j|j��}|dkr|dz }d�||j��S�Nr�r�z name {}"{}";�r�r�r�r�r�r��r�r�r�s rQr�zSTATNameStatement.asFea��C��'�������U�U�� �2�:�:� �C�K�D��$�$�T�4�;�7�7�7rSNr�)r�r�r�r�r�rNrSrQrErE�s.������5�5�8�8�8�8�8�8rSrEc�(�eZdZdZdd�Zd�Zdd�ZdS) rAzA ``parameters`` statement.Nc�t�t�||��||_||_||_||_dSr�)rBr�� DesignSize� SubfamilyID� RangeStart�RangeEnd)r�r�r�r�r�r�s rQr�zSizeParameters.__init__�s9�����4��*�*�*�$���&���$��� �� � � rSc�j�|�|j|j|j|j|j��dS)z<Calls the builder object's ``set_size_parameters`` callback.N)�set_size_parametersr�r�r�r�r�r�s rQr�zSizeParameters.build�s>���#�#� �M� �O� � � �O� �M�  � � � � rSr�c���d�|j|j��}|jdks |jdkrC|d�t |jdz��t |jdz����z }|dzS)Nzparameters {:.1f} {}rz {} {}� r8)r�r�r�r�r��intr�s rQr�zSizeParameters.asFea�sv��$�+�+�D�O�T�=M�N�N�� �?�a� � �4�=�A�#5�#5� �8�?�?�3�t���';�#<�#<�c�$�-�RT�BT�>U�>U�V�V� V�C��S�y�rSr�r�rrNrSrQrArA�sQ������%�%�!�!�!�!� � � ������rSrAc�*�eZdZdZ dd�Zd�Zdd�ZdS) rz;Represent a name statement inside a ``cvParameters`` block.Nc �V�t�|||||||���||_dSr )r:r�r&)r�r�r�r�r�r�r&r�s rQr�z"CVParametersNameStatement.__init__�s=�� ��� �&�*�i���(� � � � �%����rSc��d}|jdkr3d�|j�|jd����}|�|j��|j|j|zf|_t �||��dS)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�s����� �?�2� 2� 2��<�<�� <� @� @���a� P� P�Q�Q�D�� � ���-�-�-��{�D�O�d�$:�;�� �����w�'�'�'�'�'rSr�c��t|j|j|j��}|dkr|dz }d�||j��Sr�r�r�s rQr�zCVParametersNameStatement.asFear�rSr�r�rrNrSrQrr�sX������E�E�SW�%�%�%�%�(�(�(�8�8�8�8�8�8rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) 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�X�t�||��||_||_dSr�)rBr�� characterr�)r�r�r�r�s rQr�zCharacterStatement.__init__s*�����4��*�*�*�"�������rSc�F�|�|j|j��dS)z9Calls the builder object's ``add_cv_character`` callback.N)�add_cv_characterr�r�r�s rQr�zCharacterStatement.builds"��� � �����:�:�:�:�:rSr�c�6�d�|j��S)NzCharacter {:#x};)r�r�r�s rQr�zCharacterStatement.asFeas��!�(�(���8�8�8rSr�r�rrNrSrQr"r"sU������������ ;�;�;�9�9�9�9�9�9rSr"c�(�eZdZdZdd�Zd�Zdd�ZdS) rz�An axis definition, being either a ``VertAxis.BaseTagList/BaseScriptList`` pair or a ``HorizAxis.BaseTagList/BaseScriptList`` pair.Nc�t�t�||��||_||_||_g|_dSr�)rBr��bases�scriptsr��minmax)r�r�r�r�r�r�s rQr�zBaseAxis.__init__'s8�����4��*�*�*��� ��� � �� ��� � � rSc�^�|�|j|j|j|j��dS)z6Calls the builder object's ``set_base_axis`` callback.N)� set_base_axisr�r�r�r�r�s rQr�zBaseAxis.build.s*�����d�j�$�,�� �t�{�S�S�S�S�SrSr�c ���|jrdnd�d�|jD��}�fd�|jD��}d��d�|j��|�d�|����d�|��zS) N�Vert�Horizc ��g|]Q}d�|d|dd�tt|d��������RS)r�rr�r�r�)r�rTr�r|)rOr)s rQrz"BaseAxis.asFea.<locals>.<listcomp>4sZ�� � � �� � � �a��d�A�a�D�#�(�(�3�s�A�a�D�>�>�*B�*B� C� C� � � rSc �r��g|]3}d��|d|d|d|d����4S)z {}Axis.MinMax {} {} {}, {};rr�r�r�r�)rOr)� directions �rQrz"BaseAxis.asFea.<locals>.<listcomp>8sR��� � � �� ,� 2� 2�9�a��d�A�a�D�!�A�$�PQ�RS�PT� U� U� � � rSz2{}Axis.BaseTagList {}; {}{}Axis.BaseScriptList {};r�rLr)r�r�r�r�rTr�)r�r�r��minmaxesrs @rQr�zBaseAxis.asFea2s����"�m�8�F�F�� � � ��\� � � �� � � � ��[� � � ��E�K�K� �s�x�x�� �+�+�V�Y�� � �'�@R�@R� � � �I�I�h� � � � rSr�r�rrNrSrQrr#sZ������@�@�����T�T�T�  �  �  �  �  �  rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) 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�X�t�||��||_||_dSr��rBr�rr�r�rrr�s rQr�zOS2Field.__init__F�*�����4��*�*�*������ � � rSc�F�|�|j|j��dS)z6Calls the builder object's ``add_os2_field`` callback.N)� add_os2_fieldrrr�s rQr�zOS2Field.buildKs"�����d�h�� �3�3�3�3�3rSr�c�F��d��d}d}td�|D����}|��fd�|D����d�g|d<dd �g|d <|j|vrFd �||jd ||jd |j����SdS)Nc�R�d�tt|����S)Nr�)rTr�r|)rhs rQ� intarr2strz"OS2Field.asFea.<locals>.intarr2strPs���8�8�C��Q�K�K�(�(� (rS) �FSType� TypoAscender� TypoDescender� TypoLineGap� winAscent� winDescent�XHeight� CapHeight� WeightClass� WidthClass� LowerOpSize� UpperOpSize)� UnicodeRange� CodePageRangec�H�g|]}|���|tgf�� SrN)r�r|r�s rQrz"OS2Field.asFea.<locals>.<listcomp>bs)��@�@�@�1�!�'�'�)�)�a��X�.�@�@�@rSc�@��g|]}|���|�gf��SrN�r�)rOrhrs �rQrz"OS2Field.asFea.<locals>.<listcomp>cs*���F�F�F�!�!�'�'�)�)�a��_�5�F�F�FrS�Panose�panose�Vendorc�,�d�|��S)Nz"{}"r�)ris rQ�<lambda>z OS2Field.asFea.<locals>.<lambda>es��&�-�-��2B�2B�rS�vendor�{} {};rr�r�)rf�updaterr�r)r�r��numbers�ranges�keywordsrs @rQr�zOS2Field.asFeaOs���� )� )� )�  ��3���@�@��@�@�@�A�A�����F�F�F�F�v�F�F�F�G�G�G�&� �3����&�(B�(B�C���� �8�x� � ��?�?����"�1�%�'<�x���'9�!�'<�T�Z�'H�'H��� ��rrSr�r�rrNrSrQr;r;AsW������G�G����� 4�4�4������rSr;c�(�eZdZdZdd�Zd�Zdd�ZdS) r+zAn entry in the ``hhea`` table.Nc�X�t�||��||_||_dSr�rr s rQr�zHheaField.__init__pr rSc�F�|�|j|j��dS)z7Calls the builder object's ``add_hhea_field`` callback.N)�add_hhea_fieldrrr�s rQr�zHheaField.buildu�"�����t�x���4�4�4�4�4rSr�c��d}td�|D����}d�||j|j��S)N)� CaretOffset�Ascender� Descender�LineGapc�:�g|]}|���|f��SrNr r�s rQrz#HheaField.asFea.<locals>.<listcomp>{�$��8�8�8�A�!�'�'�)�)�Q��8�8�8rSr'�rfr�rr�r�r��fieldsr+s rQr�zHheaField.asFeays@��D���8�8��8�8�8�9�9�����x���1�4�:�>�>�>rSr�r�rrNrSrQr+r+m�Q������)�)����� 5�5�5�?�?�?�?�?�?rSr+c�(�eZdZdZdd�Zd�Zdd�ZdS) rJzAn entry in the ``vhea`` table.Nc�X�t�||��||_||_dSr�rr s rQr�zVheaField.__init__�r rSc�F�|�|j|j��dS)z7Calls the builder object's ``add_vhea_field`` callback.N)�add_vhea_fieldrrr�s rQr�zVheaField.build�r0rSr�c��d}td�|D����}d�||j|j��S)N)�VertTypoAscender�VertTypoDescender�VertTypoLineGapc�:�g|]}|���|f��SrNr r�s rQrz#VheaField.asFea.<locals>.<listcomp>�r7rSr'r8r9s rQr�zVheaField.asFea�s@��M���8�8��8�8�8�9�9�����x���1�4�:�>�>�>rSr�r�rrNrSrQrJrJr;rSrJc�(�eZdZdZdd�Zd�Zdd�ZdS) 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�t�t�||��||_||_||_||_dSr�)rBr�r�� axisOrder�namesr�)r�r�rGrHr�s rQr�z STATDesignAxisStatement.__init__�s8�����4��*�*�*����"����� � �� � � rSc�<�|�||j��dSr�)� addDesignAxisr�r�s rQr�zSTATDesignAxisStatement.build�s �����d�D�M�2�2�2�2�2rSr�c����tz �d|j�d|j�d�}|d�z��fd�|jD����dzz }|dz }|S)Nz DesignAxis r�z { rc�<��g|]}|�������Srr�rs �rQrz1STATDesignAxisStatement.asFea.<locals>.<listcomp>��'���$P�$P�$P��Q�W�W�F�W�%;�%;�$P�$P�$PrS�};)rr�rGrTrHr�s ` rQr�zSTATDesignAxisStatement.asFea�so����%���=�D�H�=�=�t�~�=�=�=�� ��v� �#�#�$P�$P�$P�$P�T�Z�$P�$P�$P�Q�Q�TX�X�X�� �t� ��� rSr�r�rrNrSrQrDrD�sU��������!�!�!�!�3�3�3������rSrDc�(�eZdZdZdd�Zd�Zdd�ZdS) r%ziSTAT table ElidedFallbackName Args: names: a list of :class:`STATNameStatement` objects Nc�X�t�||��||_||_dSr�)rBr�rHr�)r�rHr�s rQr�zElidedFallbackName.__init__��*�����4��*�*�*��� � �� � � rSc�F�|�|j|j��dSr�)�setElidedFallbackNamerHr�r�s rQr�zElidedFallbackName.build��"���%�%�d�j�$�-�@�@�@�@�@rSr�c����tz �d}|d�z��fd�|jD����dzz }|dz }|S)NzElidedFallbackName { rc�<��g|]}|�������Srr�rs �rQrz,ElidedFallbackName.asFea.<locals>.<listcomp>�rMrSrN)rrTrHr�s ` rQr�zElidedFallbackName.asFea�sX����%���'�� ��v� �#�#�$P�$P�$P�$P�T�Z�$P�$P�$P�Q�Q�TX�X�X�� �t� ��� rSr�r�rrNrSrQr%r%�sX�������� !�!�!�!� A�A�A������rSr%c�(�eZdZdZdd�Zd�Zdd�ZdS) r&zpSTAT table ElidedFallbackNameID Args: value: an int pointing to an existing name table name ID Nc�X�t�||��||_||_dSr�)rBr�rr�)r�rr�s rQr�zElidedFallbackNameID.__init__�rQrSc�F�|�|j|j��dSr�)rSrr�r�s rQr�zElidedFallbackNameID.build�rTrSr�c��d|j�d�S)NzElidedFallbackNameID r8)rr�s rQr�zElidedFallbackNameID.asFea�s��4�t�z�4�4�4�4rSr�r�rrNrSrQr&r&�sX�������� !�!�!�!� A�A�A�5�5�5�5�5�5rSr&c�(�eZdZdZdd�Zd�Zdd�ZdS) 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�f�t�||��||_||_||_dSr�)rBr�rH� locationsr)r�rHr]rr�s rQr�zSTATAxisValueStatement.__init__�s1�����4��*�*�*��� �"����� � � rSc�<�|�||j��dSr�)�addAxisValueRecordr�r�s rQr�zSTATAxisValueStatement.build�s ���"�"�4���7�7�7�7�7rSr�c��d}|jD]}||���z }�|jD]}||���z }|dz }�|jrqddg}g}d}t t |����D]0}|j|zdkr|�||��|dz}�1|dd�|���d �z }|d z }|S) Nz AxisValue { r�OlderSiblingFontAttribute�ElidableAxisValueNamer�rzflag r��; rN)r]r�rHrrr�r�rT) r�r�r�r�� nameRecordr� flagStringsr�r�s rQr�zSTATAxisValueStatement.asFea�s������ $� $�H� �8�>�>�#�#� #�C�C��*� � �J� �:�#�#�%�%� %�C� �4�K�C�C� �:� 6�0�2I�J�E��K��D��3�u�:�:�&�&� !� !���:��$��)�)��&�&�u�Q�x�0�0�0��q�y��� �5�3�8�8�K�0�0�5�5�5� 5�C� �t� ��� rSr�r�rrNrSrQrCrC�sU������������ 8�8�8������rSrCc�"�eZdZdZdd�Zdd�ZdS)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�X�t�||��||_||_dSr�)rBr�r��values)r�r�rhr�s rQr�z#AxisValueLocationStatement.__init__s*�����4��*�*�*������ � � rSr�c�v�|d|j�d�z }|d�d�|jD�����d�z }|S)Nz location r�c3�4K�|]}t|��V��dSr�r{)rOr�s rQrRz3AxisValueLocationStatement.asFea.<locals>.<genexpr>s(����7�7�a�3�q�6�6�7�7�7�7�7�7rSrc)r�rTrh)r�r�s rQr�z AxisValueLocationStatement.asFea sO�� �&�4�8�&�&�&�&�� �#�(�(�7�7�4�;�7�7�7�7�7�<�<�<�<��� rSr�r�r�rNrSrQrr�sF������������ �����rSrc�(�eZdZdZdd�Zd�Zdd�ZdS) 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�X�t�||��||_||_dSr�)rBr�r�� conditions)r�r�rmr�s rQr�zConditionsetStatement.__init__s*�����4��*�*�*��� �$����rSc�R�|�|j|j|j��dSr�)�add_conditionsetr�r�rmr�s rQr�zConditionsetStatement.build!s&��� � ���� �4�?�K�K�K�K�KrSr�c ���||d|j�d�zdzz }|j���D]!\}\}}||tz|�d|�d|�d�zz }�"||dzd|j�d�zz }|S)Nz conditionset r�r rc�})r�rmrr)r�r�r�r��minvalue�maxvalues rQr�zConditionsetStatement.asFea$s��� �v�4�� �4�4�4�4�u�<�<��)-��)>�)>�)@�)@� F� F� %�C�%�(�H� �6�E�>�s�$E�$E�X�$E�$E��$E�$E�$E�E� E�C�C� �v��|�0�$�)�0�0�0�0�0��� rSr�)r�r�rrNrSrQr#r#sX��������%�%�%�%� L�L�L������rSr#c�(�eZdZdZdd�Zd�Zd d�ZdS) �VariationBlockzCA variation feature block, applicable in a given set of conditions.FNc�h�t�||��|||c|_|_|_dSr�)rr�r�� conditionsetr)r�r�rwrr�s rQr�zVariationBlock.__init__/s8�� ���t�X�&�&�&� � � � 9�� �4�$�d�&8�&8�&8rSc��|�|j|j��|jdkr+|j|jvrt d|j��|j���|j}i|_t�||��|j� ��D]W\}}|j � |i��� |jg��}|� |��||vrg||<�X||_|� ��dS)rr�z,variation block used undefined conditionset N)rr�r�rw�conditionsets_rrrr�r�feature_variations_rr�r)r�r�rrrrs rQr�zVariationBlock.build7s#�� ���d�m�T�Y�7�7�7� � �� '� '��!��)?�?�?�!�R�t�?P�R�R�� ��� ��$����� � � �D�'�"�"�"�!�+�1�1�3�3� #� #�J�C���/�:�:�3��C�C�N�N��!�2���E� �L�L�� � � ��(�"�"� "��� ��$����������rSr�c��|d|j���zz}||jdzz }|jr|dz }|dz }|t�||���z }||d|j���zzz }|S)Nz variation %s r�rr rr!)r�r"rwrrr�r�s rQr�zVariationBlock.asFeaSs���������):�):�:�:�� �t� �3�&�&�� � � #� �?� "�C� �u� �� �u�{�{�4��{�/�/�/�� �v� �D�I�O�O�$5�$5�5�5�5��� rSr#r�rrNrSrQruru,sQ������M�M� � � � ����8�����rSru)X�fontTools.feaLib.errorr�fontTools.feaLib.locationr�fontTools.misc.encodingToolsr�fontTools.misc.textToolsrr� collectionsrrSr�__all__rVr�r�r��objectr rBr'r r�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#rurNrSrQ�<module>r�sn ��2�2�2�2�2�2�8�8�8�8�8�8�4�4�4�4�4�4�5�5�5�5�5�5�5�5�#�#�#�#�#�#�������C �C �C ��LF�F�F��s�5�5�5�7�7� �t��������f����, � � � � �� � � � � � � � �� � � � � � � � �g� � � � � � � � � � � � � !� !� !� !� !� � !� !� !� ;%�;%�;%�;%�;%��;%�;%�;%�|*�*�*�*�*�Z�*�*�*�")�)�)�)�)�J�)�)�)�" � � � � �Y� � � � � � � � �I� � � �. J� J� J� J� J�%� J� J� J������5����@�����%����*�����%����. � � � � �� � � � C� C� C� C� C�9� C� C� C�  � � � � �Y� � � �<*�*�*�*�*��*�*�*�Z$ �$ �$ �$ �$ �)�$ �$ �$ �N"�"�"�"�"�i�"�"�"�J"�"�"�"�"�Z�"�"�"�J � � � � �y� � � � � � � � �i� � � �&7�7�7�7�7�y�7�7�7�t7�7�7�7�7��7�7�7�tT�T�T�T�T�)�T�T�T�* 6� 6� 6� 6� 6� � 6� 6� 6�!9�!9�!9�!9�!9��!9�!9�!9�H9�9�9�9�9�9�9�9�9�B7�7�7�7�7�y�7�7�7�&����� ����: R� R� R� R� R�i� R� R� R� <� <� <� <� <�I� <� <� <� � � � � �I� � � �& � � � � �)� � � �&$�$�$�$�$�Y�$�$�$�N&6�&6�&6�&6�&6�)�&6�&6�&6�R5�5�5�5�5�y�5�5�5�"�����9����*5�5�5�5�5�)�5�5�5�p�����9����*C�C�C�C�C�Y�C�C�C�LP�P�P�P�P�y�P�P�P�f%�%�%�%�%�y�%�%�%�P+�+�+�+�+�9�+�+�+�\ 8� 8� 8� 8� 8�i� 8� 8� 8�%�%�%�%�%��%�%�%�P � � � � � � � � �k�k�k�k�k�*�k�k�k�\ M� M� M� M� M�I� M� M� M�0�0�0�.M�.M�.M�.M�.M��.M�.M�.M�b;�;�;�;�;�:�;�;�;�&8�8�8�8�8� �8�8�8������Y����68�8�8�8�8� �8�8�8�69�9�9�9�9��9�9�9�* � � � � �y� � � �<)�)�)�)�)�y�)�)�)�X?�?�?�?�?� �?�?�?�$?�?�?�?�?� �?�?�?�$�����i����6���������.5�5�5�5�5�9�5�5�5�&%�%�%�%�%�Y�%�%�%�P���������(�����I����4/�/�/�/�/�U�/�/�/�/�/rS
Memory