B ¶ôJdRãB@s ddlmZddlmZddlmZddlmZmZddl m Z ddl Z dZ dd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;dd?d@dAdBdCdDdEdFdGdHdIgBZ dJdK„ZedLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dg4ƒZd€d„ZGd‚d„deƒZGdƒdA„dAeƒZGd„d&„d&eƒZGd…d „d eƒZGd†d‡„d‡eƒZGdˆd „d eƒZGd‰d „d eƒZGdŠd „d eƒZGd‹d„deƒZGdŒd„deƒZGdd„deƒZGdŽd „d eƒZGdd„deƒZGdd„deƒZ Gd‘d„deƒZ!Gd’dF„dFeƒZ"Gd“d„deƒZ#Gd”d„deƒZ$Gd•d„deƒZ%Gd–d„deƒZ&Gd—d„deƒZ'Gd˜d„deƒZ(Gd™d„deƒZ)Gdšd„deƒZ*Gd›d„deƒZ+Gdœd „d eƒZ,Gdd#„d#eƒZ-Gdžd(„d(eƒZ.GdŸd+„d+eƒZ/Gd d,„d,eƒZ0Gd¡d-„d-eƒZ1Gd¢d.„d.eƒZ2Gd£d/„d/eƒZ3Gd¤d)„d)eƒZ4Gd¥d0„d0eƒZ5Gd¦d1„d1eƒZ6Gd§d2„d2eƒZ7Gd¨d3„d3eƒZ8Gd©d4„d4eƒZ9Gdªd5„d5eƒZ:Gd«d6„d6eƒZ;Gd¬d7„d7eƒZGd¯d<„d„d>eƒZBGd³dE„dEeƒZCGd´dG„dGeƒZDGdµdH„dHeƒZEd¶d·„ZFGd¸d9„d9eƒZGGd¹d'„d'eGƒZHGdºdD„dDeGƒZIGd»d@„d@eƒZJGd¼d„deGƒZKGd½d!„d!eƒZLGd¾d„deƒZMGd¿d:„d:eƒZNGdÀd*„d*eƒZOGdÁdI„dIeƒZPGdÂdC„dCeƒZQGdÃd$„d$eƒZRGdÄd%„d%eƒZSGdÅdB„dBeƒZTGdÆd„deƒZUGdÇd"„d"eƒZVGdÈdÉ„dÉeƒZWdS)Êé)ÚFeatureLibError)ÚFeatureLibLocation)Ú getEncoding)ÚbyteordÚtobytes)Ú OrderedDictNz Ú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Ú VheaFieldcCs(|dkr dSdd dd„|Dƒ¡SdS)Nz z z, css|]}d|VqdS)z%d %dN©)Ú.0ÚtrJrJúF/var/www/html/venv/lib/python3.7/site-packages/fontTools/feaLib/ast.pyú Tsz!deviceToString..)Újoin)ÚdevicerJrJrMÚdeviceToStringPsrQÚanchorZ anchordefZanonZ anonymousZbyZcontourZcursiverPÚenumÚ enumerateZ excludedfltZ exclude_dfltÚfeatureÚfromÚignoreZignorebaseglyphsZignoreligaturesZ ignoremarksÚincludeZ includedfltZ include_dfltÚlanguageZlanguagesystemÚlookupZ lookupflagÚmarkZmarkattachmenttypeZ markclassZnameidÚnullÚ parametersÚposÚpositionÚrequiredZ righttoleftZ reversesubZrsubÚscriptÚsubÚ substituteZsubtableÚtableZusemarkfilteringsetZ useextensionZvaluerecorddefÚbaseZgdefÚheadZhheaÚnameZvheaZvmtxcCs`t|dƒr| ¡St|tƒrDt|ƒdkrDt|dƒdt|dƒS| ¡tkrXd|S|SdS)NÚasFeaérz - éú\)ÚhasattrrhÚ isinstanceÚtupleÚlenÚlowerÚ fea_keywords)ÚgrJrJrMrh‘s  rhc@s4eZdZdZd dd„Zdd„Zd dd „Zd d „ZdS)rz8A base class representing "something" in a feature file.NcCs |rt|tƒst|Ž}||_dS)N)rmrÚlocation)ÚselfrsrJrJrMÚ__init__ŸszElement.__init__cCsdS)NrJ)rtÚbuilderrJrJrMÚbuild¥sz Element.buildÚcCst‚dS)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.N)ÚNotImplementedError)rtÚindentrJrJrMrh¨sz Element.asFeacCs| ¡S)N)rh)rtrJrJrMÚ__str__®szElement.__str__)N)rx)Ú__name__Ú __module__Ú __qualname__Ú__doc__rurwrhr{rJrJrJrMrœs   c@s eZdZdS)rAN)r|r}r~rJrJrJrMrA²sc@s eZdZdS)r&N)r|r}r~rJrJrJrMr&¶scs,eZdZdZd‡fdd„ Zd dd„Z‡ZS) r zA comment in a feature file.Ncstt|ƒ |¡||_dS)N)Úsuperr ruÚtext)rtrrs)Ú __class__rJrMru½szComment.__init__rxcCs|jS)N)r)rtrzrJrJrMrhÂsz Comment.asFea)N)rx)r|r}r~rrurhÚ __classcell__rJrJ)r‚rMr ºsc@s,eZdZdZd dd„Zdd„Zd dd „ZdS) Ú NullGlyphz5The NULL glyph, used in glyph deletion substitutions.NcCst ||¡dS)N)r&ru)rtrsrJrJrMruÉszNullGlyph.__init__cCsdS)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.rJrJ)rtrJrJrMÚglyphSetÍszNullGlyph.glyphSetrxcCsdS)NÚNULLrJ)rtrzrJrJrMrhÑszNullGlyph.asFea)N)rx)r|r}r~rrur…rhrJrJrJrMr„Æs r„c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r z)A single glyph name, such as ``cedilla``.NcCst ||¡||_dS)N)r&ruÚglyph)rtr‡rsrJrJrMruØs zGlyphName.__init__cCs|jfS)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)r‡)rtrJrJrMr…ÝszGlyphName.glyphSetrxcCs t|jƒS)N)rhr‡)rtrzrJrJrMrhászGlyphName.asFea)N)rx)r|r}r~rrur…rhrJrJrJrMr Õs c@sTeZdZdZddd„Zdd„Zddd „Zd d „Zd d „Zdd„Z dd„Z dd„Z dS)r z1A glyph class, such as ``[acute cedilla grave]``.NcCs.t ||¡|dk r|ng|_g|_d|_dS)Nr)r&ruÚglyphsÚoriginalÚcurr)rtrˆrsrJrJrMruès zGlyphClass.__init__cCs t|jƒS)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)rnrˆ)rtrJrJrMr…ïszGlyphClass.glyphSetrxcCsvt|jƒrX|jt|jƒkr>|j |j|jd…¡t|jƒ|_dd tt|jƒ¡dSdd tt|jƒ¡dSdS)Nú[ú ú])ror‰rŠrˆÚextendrOÚmaprh)rtrzrJrJrMrhós   zGlyphClass.asFeacCs|j |¡dS)z6Add a list of :class:`GlyphName` objects to the class.N)rˆrŽ)rtrˆrJrJrMrŽüszGlyphClass.extendcCs|j |¡dS)z4Add a single :class:`GlyphName` object to the class.N)rˆÚappend)rtr‡rJrJrMrszGlyphClass.appendcCsT|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Šrorˆr‰rŽr)rtÚstartÚendrˆrJrJrMÚ add_ranges  zGlyphClass.add_rangecCs`|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Šrorˆr‰rŽrÚformat)rtr‘r’rˆrJrJrMÚ add_cid_ranges  zGlyphClass.add_cid_rangecCsT|jt|jƒkr(|j |j|jd…¡|j |¡|j | ¡¡t|jƒ|_dS)zNAdd glyphs from the given :class:`GlyphClassName` object to the class.N)rŠrorˆr‰rŽrr…)rtÚgcrJrJrMÚ add_classs  zGlyphClass.add_class)NN)rx) r|r}r~rrur…rhrŽrr“r•r—rJrJrJrMr ås    c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r zyA glyph class name, such as ``@FRENCH_MARKS``. This must be instantiated with a :class:`GlyphClassDefinition` object.NcCs$t ||¡t|tƒst‚||_dS)N)r&rurmrÚAssertionErrorÚ glyphclass)rtr™rsrJrJrMru's zGlyphClassName.__init__cCst|j ¡ƒS)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)rnr™r…)rtrJrJrMr…,szGlyphClassName.glyphSetrxcCs d|jjS)Nú@)r™rg)rtrzrJrJrMrh0szGlyphClassName.asFea)N)rx)r|r}r~rrur…rhrJrJrJrMr #s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rzˆA mark class name, such as ``@FRENCH_MARKS`` defined with ``markClass``. This must be instantiated with a :class:`MarkClass` object.NcCs$t ||¡t|tƒst‚||_dS)N)r&rurmrr˜Ú markClass)rtr›rsrJrJrMru8s zMarkClassName.__init__cCs |j ¡S)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)r›r…)rtrJrJrMr…=szMarkClassName.glyphSetrxcCs d|jjS)Nrš)r›rg)rtrzrJrJrMrhAszMarkClassName.asFea)N)rx)r|r}r~rrur…rhrJrJrJrMr4s c@s$eZdZdZddd„Zd dd„ZdS) rzAn anonymous data block.NcCst ||¡||_||_dS)N)rAruÚtagÚcontent)rtrœrrsrJrJrMruHs zAnonymousBlock.__init__rxcCs*d |j¡}||j7}|d |j¡7}|S)Nz anon {} {{ z}} {}; )r”rœr)rtrzÚresrJrJrMrhMs  zAnonymousBlock.asFea)N)rx)r|r}r~rrurhrJrJrJrMrEs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rz,A block of statements: feature, lookup, etc.NcCst ||¡g|_dS)N)rAruÚ statements)rtrsrJrJrMruWs zBlock.__init__cCsx|jD]}| |¡qWdS)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Ÿrw)rtrvÚsrJrJrMrw[s z Block.buildrxcs.ˆt7‰ˆdˆ ‡fdd„|jDƒ¡dS)NÚ csg|]}|jˆd‘qS))rz)rh)rKr )rzrJrMú fszBlock.asFea..)ÚSHIFTrOrŸ)rtrzrJ)rzrMrhbsz Block.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrTs c@s"eZdZdZdd„Zddd„ZdS) r zpThe top-level element of the syntax tree, containing the whole feature file in its ``statements`` attribute.cCstj|ddi|_dS)N)rs)rruZ markClasses)rtrJrJrMruoszFeatureFile.__init__rxcsd ‡fdd„|jDƒ¡S)Nr¡c3s|]}|jˆdVqdS))rzN)rh)rKr )rzrJrMrNtsz$FeatureFile.asFea..)rOrŸ)rtrzrJ)rzrMrhsszFeatureFile.asFeaN)rx)r|r}r~rrurhrJrJrJrMr ksc@s,eZdZdZd dd„Zdd„Zd d d „ZdS) rzA named feature block.FNcCst ||¡|||_|_dS)N)rrurgÚ use_extension)rtrgr¤rsrJrJrMruzs zFeatureBlock.__init__cCsd| |j|j¡|j}i|_t ||¡x(|j ¡D]\}}| |g¡ |¡q4W||_|  ¡dS)z‹Call the ``start_feature`` callback on the builder object, visit all the statements in this feature, and then call ``end_feature``.N) Ú start_featurersrgÚ features_rrwÚitemsÚ setdefaultrŽÚ end_feature)rtrvÚfeaturesÚkeyÚvaluerJrJrMrw~s zFeatureBlock.buildrxcCsT|d|j ¡}|jr |d7}|d7}|tj||d7}||d|j ¡7}|S)Nz feature %s z useExtension z{ )rzz} %s; )rgÚstripr¤rrh)rtrzržrJrJrMrhszFeatureBlock.asFea)FN)rx)r|r}r~rrurwrhrJrJrJrMrws c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rzYA block inside another block, for example when found inside a ``cvParameters`` block.NcCst ||¡||_||_dS)N)rrurœÚ block_name)rtrœr®rsrJrJrMru›s zNestedBlock.__init__cCs&t ||¡|jdkr"| |j¡dS)NÚParamUILabelNameID)rrwr®Zadd_to_cv_num_named_paramsrœ)rtrvrJrJrMrw s  zNestedBlock.buildrxcCs2d ||j¡}|tj||d7}|d |¡7}|S)Nz{}{} {{ )rzz{}}}; )r”r®rrh)rtrzržrJrJrMrh¥szNestedBlock.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr—s c@s,eZdZdZd dd„Zdd„Zd d d „ZdS) rz*A named lookup, containing ``statements``.FNcCst ||¡|||_|_dS)N)rrurgr¤)rtrgr¤rsrJrJrMru¯s zLookupBlock.__init__cCs(| |j|j¡t ||¡| ¡dS)N)Zstart_lookup_blockrsrgrrwZend_lookup_block)rtrvrJrJrMrw³s zLookupBlock.buildrxcCsJd |j¡}|jr|d7}|d7}|tj||d7}|d ||j¡7}|S)Nz lookup {} z useExtension z{ )rzz {}}} {}; )r”rgr¤rrh)rtrzržrJrJrMrh¹s zLookupBlock.asFea)FN)rx)r|r}r~rrurwrhrJrJrJrMr¬s cs,eZdZdZddd„Zd ‡fdd„ Z‡ZS) rFzA ``table ... { }`` block.NcCst ||¡||_dS)N)rrurg)rtrgrsrJrJrMruÆs zTableBlock.__init__rxcs>d |j ¡¡}|tt|ƒj|d7}|d |j ¡¡7}|S)Nz table {} {{ )rzz}} {}; )r”rgr­r€rFrh)rtrzrž)r‚rJrMrhÊszTableBlock.asFea)N)rx)r|r}r~rrurhrƒrJrJ)r‚rMrFÃs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rz!Example: ``@UPPERCASE = [A-Z];``.NcCst ||¡||_||_dS)N)rArurgrˆ)rtrgrˆrsrJrJrMruÔs zGlyphClassDefinition.__init__cCst|j ¡ƒS)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)rnrˆr…)rtrJrJrMr…ÙszGlyphClassDefinition.glyphSetrxcCsd|jd|j ¡dS)Nršz = ú;)rgrˆrh)rtrzrJrJrMrhÝszGlyphClassDefinition.asFea)N)rx)r|r}r~rrur…rhrJrJrJrMrÑs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rz¡Example: ``GlyphClassDef @UPPERCASE, [B], [C], [D];``. The parameters must be either :class:`GlyphClass` or :class:`GlyphClassName` objects, or ``None``.NcCs*t ||¡|||_|_||_||_dS)N)rAruÚ baseGlyphsÚ markGlyphsÚligatureGlyphsÚcomponentGlyphs)rtr±r²r³r´rsrJrJrMruæs zGlyphClassDefStatement.__init__cCsp|jr|j ¡ntƒ}|jr&|j ¡ntƒ}|jr<|j ¡ntƒ}|jrR|j ¡ntƒ}| |j||||¡dS)z3Calls the builder's ``add_glyphClassDef`` callback.N)r±r…rnr³r²r´Zadd_glyphClassDefrs)rtrvreZligar[ÚcomprJrJrMrwîs zGlyphClassDefStatement.buildrxcCsPd |jr|j ¡nd|jr&|j ¡nd|jr8|j ¡nd|jrJ|j ¡nd¡S)NzGlyphClassDef {}, {}, {}, {};rx)r”r±rhr³r²r´)rtrzrJrJrMrhös zGlyphClassDefStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrás c@s2eZdZdZdd„Zdd„Zdd„Zd d d „Zd S) 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] @FRENCH_ACCENTS; markClass [cedilla] @FRENCH_ACCENTS; The ``MarkClass`` object is therefore just a container for a list of :class:`MarkClassDefinition` statements. cCs||_g|_tƒ|_dS)N)rgÚ definitionsrrˆ)rtrgrJrJrMruszMarkClass.__init__cCs|t|tƒst‚|j |¡x\| ¡D]P}||jkrj|j|j}|dkrLd}n d|›}td||f|jƒ‚||j|<q$WdS)z@Add a :class:`MarkClassDefinition` statement to this mark class.Nrxz at zGlyph %s already defined%s) rmrr˜r¶rr…rˆrsr)rtZ definitionr‡ZotherLocr’rJrJrMÚ addDefinitions    zMarkClass.addDefinitioncCst|j ¡ƒS)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)rnrˆÚkeys)rtrJrJrMr…#szMarkClass.glyphSetrxcCsd dd„|jDƒ¡}|S)Nr¡css|]}| ¡VqdS)N)rh)rKÚdrJrJrMrN(sz"MarkClass.asFea..)rOr¶)rtrzržrJrJrMrh'szMarkClass.asFeaN)rx)r|r}r~rrur·r…rhrJrJrJrMrÿs  c@s,eZdZdZd dd„Zdd„Zd dd „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] @FRENCH_ACCENTS; # markClass [cedilla] @FRENCH_ACCENTS; NcCsLt ||¡t|tƒst‚t|tƒr.t|tƒs2t‚||||_|_|_ dS)N) rArurmrr˜rr&r›rRrˆ)rtr›rRrˆrsrJrJrMruCs zMarkClassDefinition.__init__cCs |j ¡S)zBThe glyphs in this class as a tuple of :class:`GlyphName` objects.)rˆr…)rtrJrJrMr…IszMarkClassDefinition.glyphSetrxcCsd |j ¡|j ¡|jj¡S)NzmarkClass {} {} @{};)r”rˆrhrRr›rg)rtrzrJrJrMrhMszMarkClassDefinition.asFea)N)rx)r|r}r~rrur…rhrJrJrJrMr,s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rzºA ``sub ... from ...`` statement. ``prefix``, ``glyph``, ``suffix`` and ``replacement`` should be lists of `glyph-containing objects`_. ``glyph`` should be a `one element list`.NcCs,t ||¡||||_|_|_||_dS)N)rAruÚprefixr‡ÚsuffixÚ replacement)rtrºr‡r»r¼rsrJrJrMruYs z AlternateSubstStatement.__init__cCsl|j ¡}t|ƒdkst|ƒ‚t|ƒd}dd„|jDƒ}dd„|jDƒ}|j ¡}| |j ||||¡dS)z5Calls the builder's ``add_alternate_subst`` callback.rjrcSsg|] }| ¡‘qSrJ)r…)rKÚprJrJrMr¢csz1AlternateSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢dsN) r‡r…ror˜Úlistrºr»r¼Zadd_alternate_substrs)rtrvr‡rºr»r¼rJrJrMrw^s   zAlternateSubstStatement.buildrxcCs¤d}t|jƒst|jƒrtt|jƒr<|d tt|jƒ¡d7}|t|jƒd7}t|jƒr‚|dd tt|jƒ¡7}n|t|jƒ7}|d7}|t|jƒ7}|d7}|S)Nzsub rŒú'z from r°)rorºr»rOrrhr‡r¼)rtrzržrJrJrMrhhs  zAlternateSubstStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrSs  c@s$eZdZdZddd„Zd dd„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. NcCs:t ||¡||_||||_|_|_|||_|_dS)N)r&rurgÚxÚyÚ contourpointÚ xDeviceTableÚ yDeviceTable)rtrÀrÁrgrÂrÃrÄrsrJrJrMrus zAnchor.__init__rxcCs€|jdk rd |j¡Sd |j|j¡}|jr<|d |j¡7}|jsH|jrt|d7}|t|jƒ7}|d7}|t|jƒ7}|d7}|S)Nz z )rgr”rÀrÁrÂrÃrÄrQ)rtrzržrJrJrMrhŽs   z Anchor.asFea)NNNNN)rx)r|r}r~rrurhrJrJrJrMrxs c@s$eZdZdZddd„Zd dd„ZdS) rzCA named anchor definition. (2.e.viii). ``name`` should be a string.NcCs,t ||¡||||f\|_|_|_|_dS)N)rArurgrÀrÁrÂ)rtrgrÀrÁrÂrsrJrJrMru s zAnchorDefinition.__init__rxcCs:d |j|j¡}|jr&|d |j¡7}|d |j¡7}|S)NzanchorDef {} {}z contourpoint {}z {};)r”rÀrÁrÂrg)rtrzržrJrJrMrh¤s zAnchorDefinition.asFea)NN)rx)r|r}r~rrurhrJrJrJrMrs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rz&A ``GDEF`` table ``Attach`` statement.NcCst ||¡||_||_dS)N)rArurˆÚ contourPoints)rtrˆrÆrsrJrJrMru¯s zAttachStatement.__init__cCs |j ¡}| |j||j¡dS)z3Calls the builder's ``add_attach_points`` callback.N)rˆr…Zadd_attach_pointsrsrÆ)rtrvrˆrJrJrMrw´s zAttachStatement.buildrxcCs$d |j ¡d dd„|jDƒ¡¡S)Nz Attach {} {};rŒcss|]}t|ƒVqdS)N)Ústr)rKÚcrJrJrMrN»sz(AttachStatement.asFea..)r”rˆrhrOrÆ)rtrzrJrJrMrh¹szAttachStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr¬s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) ra@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 Cs~t ||¡||||_|_|_t|ƒ|_xLt|ƒD]@\}}|r6ydd„|DƒWq6tk rt|g|j|<Yq6Xq6WdS)Ncss|] }|VqdS)NrJ)rKÚ_rJrJrMrNÔsz4ChainContextPosStatement.__init__..) rArurºrˆr»r¾ÚlookupsrTÚ TypeError)rtrºrˆr»rÊrsÚirZrJrJrMruÍs  z!ChainContextPosStatement.__init__cCsJdd„|jDƒ}dd„|jDƒ}dd„|jDƒ}| |j||||j¡dS)z7Calls the builder's ``add_chain_context_pos`` callback.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢Úsz2ChainContextPosStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKrrrJrJrMr¢ÛscSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢ÜsN)rºrˆr»Úadd_chain_context_posrsrÊ)rtrvrºrˆr»rJrJrMrwØs zChainContextPosStatement.buildrxcCs d}t|jƒs,t|jƒs,tdd„|jDƒƒrèt|jƒrT|d dd„|jDƒ¡d7}xlt|jƒD]^\}}|| ¡d7}|j|r¤x |j|D]}|d|j 7}qŽW|t|jƒd kr`|d7}q`Wt|jƒrþ|dd t t|jƒ¡7}n|d t t|j ƒ¡7}|d 7}|S) Nzpos cSsg|] }|dk ‘qS)NrJ)rKrÀrJrJrMr¢æsz2ChainContextPosStatement.asFea..rŒcss|]}| ¡VqdS)N)rh)rKrrrJrJrMrNész1ChainContextPosStatement.asFea..r¿z lookup rjr°) rorºr»ÚanyrÊrOrTrˆrhrgrr‡)rtrzržrÌrrÚlurJrJrMrhás$      zChainContextPosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr¿s   c@s,eZdZdZd dd„Zdd„Zd dd „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 Cs~t ||¡||||_|_|_t|ƒ|_xLt|ƒD]@\}}|r6ydd„|DƒWq6tk rt|g|j|<Yq6Xq6WdS)Ncss|] }|VqdS)NrJ)rKrÉrJrJrMrNsz6ChainContextSubstStatement.__init__..) rArurºrˆr»r¾rÊrTrË)rtrºrˆr»rÊrsrÌrZrJrJrMrus  z#ChainContextSubstStatement.__init__cCsJdd„|jDƒ}dd„|jDƒ}dd„|jDƒ}| |j||||j¡dS)z9Calls the builder's ``add_chain_context_subst`` callback.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢sz4ChainContextSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKrrrJrJrMr¢scSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢sN)rºrˆr»Úadd_chain_context_substrsrÊ)rtrvrºrˆr»rJrJrMrws z ChainContextSubstStatement.buildrxcCs d}t|jƒs,t|jƒs,tdd„|jDƒƒrèt|jƒrT|d dd„|jDƒ¡d7}xlt|jƒD]^\}}|| ¡d7}|j|r¤x |j|D]}|d|j 7}qŽW|t|jƒd kr`|d7}q`Wt|jƒrþ|dd t t|jƒ¡7}n|d t t|j ƒ¡7}|d 7}|S) Nzsub cSsg|] }|dk ‘qS)NrJ)rKrÀrJrJrMr¢ sz4ChainContextSubstStatement.asFea..rŒcss|]}| ¡VqdS)N)rh)rKrrrJrJrMrN#sz3ChainContextSubstStatement.asFea..r¿z lookup rjr°) rorºr»rÎrÊrOrTrˆrhrgrr‡)rtrzržrÌrrrÏrJrJrMrhs$      z ChainContextSubstStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr ùs   c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r#znA cursive positioning statement. Entry and exit anchors can either be :class:`Anchor` objects or ``None``.NcCs$t ||¡||_|||_|_dS)N)rArur™Ú entryAnchorÚ exitAnchor)rtr™rÑrÒrsrJrJrMru7s zCursivePosStatement.__init__cCs | |j|j ¡|j|j¡dS)z8Calls the builder object's ``add_cursive_pos`` callback.N)Zadd_cursive_posrsr™r…rÑrÒ)rtrvrJrJrMrw<szCursivePosStatement.buildrxcCs<|jr|j ¡nd}|jr$|j ¡nd}d |j ¡||¡S)Nz zpos cursive {} {} {};)rÑrhrÒr”r™)rtrzÚentryÚexitrJrJrMrhBszCursivePosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr#3s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r(zExample: ``feature salt;``NcCst ||¡|||_|_dS)N)rArursÚ featureName)rtrÕrsrJrJrMruKs z"FeatureReferenceStatement.__init__cCs| |j|j¡dS)z>Calls the builder object's ``add_feature_reference`` callback.N)Zadd_feature_referencersrÕ)rtrvrJrJrMrwOszFeatureReferenceStatement.buildrxcCs d |j¡S)Nz feature {};)r”rÕ)rtrzrJrJrMrhSszFeatureReferenceStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr(Hs c@s,eZdZdZd dd„Zdd„Zd dd „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`_ .NcCst ||¡||_dS)N)rAruÚ chainContexts)rtrÖrsrJrJrMru^s zIgnorePosStatement.__init__cCsXxR|jD]H\}}}dd„|Dƒ}dd„|Dƒ}dd„|Dƒ}| |j|||g¡qWdS)z[Calls the builder object's ``add_chain_context_pos`` callback on each rule context.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢fsz,IgnorePosStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKrrrJrJrMr¢gscSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢hsN)rÖrÍrs)rtrvrºrˆr»rJrJrMrwbs zIgnorePosStatement.buildrxcCs¸g}x |jD]–\}}}d}t|ƒs*t|ƒr„t|ƒrJ|d tt|ƒ¡d7}|d dd„|Dƒ¡7}t|ƒr˜|dd tt|ƒ¡7}n|d tt|ƒ¡7}| |¡q Wdd |¡dS)NrxrŒcss|]}| ¡dVqdS)r¿N)rh)rKrrrJrJrMrNrsz+IgnorePosStatement.asFea..z ignore pos z, r°)rÖrorOrrhr)rtrzÚcontextsrºrˆr»ržrJrJrMrhkszIgnorePosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr+Ws  c@s,eZdZdZd dd„Zdd„Zd dd „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`_ .NcCst ||¡||_dS)N)rArurÖ)rtrÖrsrJrJrMru‚s zIgnoreSubstStatement.__init__cCsXxR|jD]H\}}}dd„|Dƒ}dd„|Dƒ}dd„|Dƒ}| |j|||g¡qWdS)z]Calls the builder object's ``add_chain_context_subst`` callback on each rule context.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢Šsz.IgnoreSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKrrrJrJrMr¢‹scSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢ŒsN)rÖrÐrs)rtrvrºrˆr»rJrJrMrw†s zIgnoreSubstStatement.buildrxcCs¸g}x |jD]–\}}}d}t|ƒs*t|ƒr„t|ƒrJ|d tt|ƒ¡d7}|d dd„|Dƒ¡7}t|ƒr˜|dd tt|ƒ¡7}n|d tt|ƒ¡7}| |¡q Wdd |¡dS)NrxrŒcss|]}| ¡dVqdS)r¿N)rh)rKrrrJrJrMrN–sz-IgnoreSubstStatement.asFea..z ignore sub z, r°)rÖrorOrrhr)rtrzr×rºrˆr»ržrJrJrMrhszIgnoreSubstStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr,{s  cs4eZdZdZd ‡fdd„ Zdd„Zd dd „Z‡ZS) r-zAn ``include()`` statement.Ncstt|ƒ |¡||_dS)N)r€r-ruÚfilename)rtrØrs)r‚rJrMru¢szIncludeStatement.__init__cCstd|jƒ‚dS)NzqBuilding an include statement is not implemented yet. Instead, use Parser(..., followIncludes=True) for building.)rrs)rtrJrJrMrw¦szIncludeStatement.buildrxcCs|d|jS)Nz include(%s);)rØ)rtrzrJrJrMrh®szIncludeStatement.asFea)N)rx)r|r}r~rrurwrhrƒrJrJ)r‚rMr-Ÿsc@s,eZdZdZd dd„Zdd„Zd d d „ZdS)r.z*A ``language`` statement within a feature.TFNcCs2t ||¡t|ƒdkst‚||_||_||_dS)Né)rAruror˜rYÚinclude_defaultr`)rtrYrÚr`rsrJrJrMruµs  zLanguageStatement.__init__cCs|j|j|j|j|jddS)z4Call the builder object's ``set_language`` callback.)rsrYrÚr`N)Z set_languagersrYrÚr`)rtrvrJrJrMrw¼s zLanguageStatement.buildrxcCs8d |j ¡¡}|js|d7}|jr,|d7}|d7}|S)Nz language {}z exclude_dfltz requiredr°)r”rYr­rÚr`)rtrzržrJrJrMrhÅszLanguageStatement.asFea)TFN)rx)r|r}r~rrurwrhrJrJrJrMr.²s  c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r/z)A top-level ``languagesystem`` statement.NcCst ||¡|||_|_dS)N)rArurarY)rtrarYrsrJrJrMruÒs z LanguageSystemStatement.__init__cCs| |j|j|j¡dS)z.)r”rˆrhrOrÜ)rtrzrJrJrMrhúsz#LigatureCaretByIndexStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr0ís c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r1z–A ``GDEF`` table ``LigatureCaretByPos`` statement. ``glyphs`` should be a `glyph-containing object`_, and ``carets`` should be a list of integers.NcCst ||¡|||_|_dS)N)rArurˆrÜ)rtrˆrÜrsrJrJrMrus z$LigatureCaretByPosStatement.__init__cCs$|j ¡}| |j|t|jƒ¡dS)z@Calls the builder object's ``add_ligatureCaretByPos_`` callback.N)rˆr…Zadd_ligatureCaretByPos_rsrÝrÜ)rtrvrˆrJrJrMrws z!LigatureCaretByPosStatement.buildrxcCs$d |j ¡d dd„|jDƒ¡¡S)NzLigatureCaretByPos {} {};rŒcss|]}t|ƒVqdS)N)rÇ)rKrÀrJrJrMrNsz4LigatureCaretByPosStatement.asFea..)r”rˆrhrOrÜ)rtrzrJrJrMrh sz!LigatureCaretByPosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr1s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r2aSA 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.NcCs4t ||¡||||_|_|_|||_|_dS)N)rArurºrˆr»r¼Ú forceChain)rtrºrˆr»r¼rÞrsrJrJrMrus zLigatureSubstStatement.__init__cCsNdd„|jDƒ}dd„|jDƒ}dd„|jDƒ}| |j||||j|j¡dS)NcSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢#sz0LigatureSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKrrrJrJrMr¢$scSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢%s)rºrˆr»Zadd_ligature_substrsr¼rÞ)rtrvrºrˆr»rJrJrMrw"s zLigatureSubstStatement.buildrxcCsÆd}t|jƒst|jƒs|jrŠt|jƒrF|d dd„|jDƒ¡d7}|d dd„|jDƒ¡7}t|jƒr¤|dd dd„|jDƒ¡7}n|d dd„|jDƒ¡7}|d7}|t|jƒ7}|d 7}|S) Nzsub rŒcss|]}| ¡VqdS)N)rh)rKrrrJrJrMrN.sz/LigatureSubstStatement.asFea..css|]}| ¡dVqdS)r¿N)rh)rKrrrJrJrMrN/scss|]}| ¡VqdS)N)rh)rKrrrJrJrMrN1scss|]}| ¡VqdS)N)rh)rKrrrJrJrMrN3sz by r°)rorºr»rÞrOrˆrhr¼)rtrzržrJrJrMrh*s   zLigatureSubstStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr2s c@s,eZdZdZd dd„Zdd„Zd d d „ZdS) r3zô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.rNcCs"t ||¡||_||_||_dS)N)rArur¬ÚmarkAttachmentÚmarkFilteringSet)rtr¬rßràrsrJrJrMru@s zLookupFlagStatement.__init__cCsHd}|jdk r|j ¡}d}|jdk r0|j ¡}| |j|j||¡dS)z8Calls the builder object's ``set_lookup_flag`` callback.N)rßr…ràZset_lookup_flagrsr¬)rtrvZ markAttachZ markFilterrJrJrMrwHs    zLookupFlagStatement.buildrxcCs¨g}ddddg}d}x8tt|ƒƒD](}|j|@dkrB| ||¡|d>}q"W|jdk rn| d |j ¡¡¡|jdk rŽ| d |j ¡¡¡|s˜d g}d  d  |¡¡S) NZ RightToLeftZIgnoreBaseGlyphsZIgnoreLigaturesZ IgnoreMarksrjrzMarkAttachmentType {}zUseMarkFilteringSet {}Ú0zlookupflag {};rŒ) Úrangeror¬rrßr”rhràrO)rtrzržÚflagsrŠrÌrJrJrMrhRs    zLookupFlagStatement.asFea)rNNN)rx)r|r}r~rrurwrhrJrJrJrMr3:s  c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r4z…Represents a ``lookup ...;`` statement to include a lookup in a feature. The ``lookup`` should be a :class:`LookupBlock` object.NcCst ||¡|||_|_dS)N)rArursrZ)rtrZrsrJrJrMruhs z!LookupReferenceStatement.__init__cCs| |jj¡dS)z8Calls the builder object's ``add_lookup_call`` callback.N)Zadd_lookup_callrZrg)rtrvrJrJrMrwlszLookupReferenceStatement.buildrxcCsd |jj¡S)Nz lookup {};)r”rZrg)rtrzrJrJrMrhpszLookupReferenceStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr4cs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r5z­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.NcCst ||¡|||_|_dS)N)rArureÚmarks)rtrerärsrJrJrMruys zMarkBasePosStatement.__init__cCs| |j|j ¡|j¡dS)z:Calls the builder object's ``add_mark_base_pos`` callback.N)Zadd_mark_base_posrsrer…rä)rtrvrJrJrMrw}szMarkBasePosStatement.buildrxcCsRd |j ¡¡}x4|jD]*\}}|d|td | ¡|j¡7}qW|d7}|S)Nz pos base {}r¡z {} mark @{}r°)r”rerhrär£rg)rtrzržÚaÚmrJrJrMrhs &zMarkBasePosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr5ts c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r6aÙ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 mark @TOP_MARKS # ligComponent mark @BOTTOM_MARKS; NcCst ||¡|||_|_dS)N)rAruÚ ligaturesrä)rtrçrärsrJrJrMru¤s zMarkLigPosStatement.__init__cCs| |j|j ¡|j¡dS)z9Calls the builder object's ``add_mark_lig_pos`` callback.N)Zadd_mark_lig_posrsrçr…rä)rtrvrJrJrMrw¨szMarkLigPosStatement.buildrxcCs¶d |j ¡¡}g}xz|jD]p}d}|dks4t|ƒsJd|tdd}n8x6|D].\}}|d|tdd | ¡|j¡7}qPW| |¡qW|d|td |¡7}|d7}|S) Nzpos ligature {}rxr¡riz z {} mark @{}Z ligComponentr°) r”rçrhräror£rgrrO)rtrzržZligsÚlÚtemprårærJrJrMrh¬s (zMarkLigPosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr6‰s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r7z°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.NcCst ||¡|||_|_dS)N)rAruÚ baseMarksrä)rtrêrärsrJrJrMruÆs zMarkMarkPosStatement.__init__cCs| |j|j ¡|j¡dS)z:Calls the builder object's ``add_mark_mark_pos`` callback.N)Zadd_mark_mark_posrsrêr…rä)rtrvrJrJrMrwÊszMarkMarkPosStatement.buildrxcCsRd |j ¡¡}x4|jD]*\}}|d|td | ¡|j¡7}qW|d7}|S)Nz pos mark {}r¡z {} mark @{}r°)r”rêrhrär£rg)rtrzržrårærJrJrMrhÎs &zMarkMarkPosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr7Ás c@s,eZdZdZd dd„Zdd„Zd d d „ZdS) r8a™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. FNcCs2t ||¡||||_|_|_||_||_dS)N)rArurºr‡r»r¼rÞ)rtrºr‡r»r¼rÞrsrJrJrMruâs zMultipleSubstStatement.__init__c Cs‚dd„|jDƒ}dd„|jDƒ}|jsbt|jdƒrbxJ|j ¡D]}| |j||||j|j¡q>Wn| |j||j||j|j¡dS)z;Calls the builder object's ``add_multiple_subst`` callback.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢ìsz0MultipleSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢ísr…N) rºr»r¼rlr‡r…Zadd_multiple_substrsrÞ)rtrvrºr»r‡rJrJrMrwês$zMultipleSubstStatement.buildrxcCs¾d}t|jƒst|jƒs|jrzt|jƒrB|d tt|jƒ¡d7}|t|jƒd7}t|jƒrˆ|dd tt|jƒ¡7}n|t|jƒ7}|jp”t ƒg}|d7}|d tt|ƒ¡7}|d7}|S)Nzsub rŒr¿z by r°) rorºr»rÞrOrrhr‡r¼r„)rtrzržr¼rJrJrMrhs  zMultipleSubstStatement.asFea)FN)rx)r|r}r~rrurwrhrJrJrJrMr8Ös  c@s,eZdZdZd dd„Zdd„Zd d 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 `_. FNcCs2t ||¡||_|||_|_|||_|_dS)N)rAruÚ enumeratedÚglyphs1Ú valuerecord1Úglyphs2Ú valuerecord2)rtrìrírîrïrërsrJrJrMrus zPairPosStatement.__init__cCsÌ|jrf|j ¡|j ¡g}d}x2tj|ŽD]$\}}d}| |j||j||j ¡q*W|sbt d|jƒ‚dSt |jt ƒo|t |jt ƒ}|r¤| |j|jj |j|jj |j ¡n$| |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)rërìr…rîÚ itertoolsÚproductZadd_specific_pair_posrsrírïrrmr r‡Zadd_class_pair_pos)rtrvrrZ seen_pairZglyph1Zglyph2Z is_specificrJrJrMrw+s4    zPairPosStatement.buildrxcCsj|jr dnd}|jrB|d |j ¡|j ¡|j ¡|j ¡¡7}n$|d |j ¡|j ¡|j ¡¡7}|S)Nzenum rxzpos {} {} {} {};z pos {} {} {};)rërïr”rìrhrírî)rtrzržrJrJrMrhVszPairPosStatement.asFea)FN)rx)r|r}r~rrurwrhrJrJrJrMr;s  +c@s,eZdZdZd dd„Zdd„Zd dd „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. NcCs*t ||¡|||_|_||_||_dS)N)rAruÚ old_prefixÚ old_suffixrˆÚ replacements)rtròrórˆrôrsrJrJrMruos z)ReverseChainSingleSubstStatement.__init__c Cstdd„|jDƒ}dd„|jDƒ}|jd ¡}|jd ¡}t|ƒdkrT|t|ƒ}| |j||tt ||ƒƒ¡dS)NcSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢vsz:ReverseChainSingleSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢wsrrj) ròrórˆr…rôroZadd_reverse_chain_single_substrsÚdictÚzip)rtrvrºr»Ú originalsÚreplacesrJrJrMrwus  z&ReverseChainSingleSubstStatement.buildrxcCs¾d}t|jƒst|jƒr„t|jƒr@|d dd„|jDƒ¡d7}|d dd„|jDƒ¡7}t|jƒrš|dd dd„|jDƒ¡7}n|d tt|jƒ¡7}|d d dd„|jDƒ¡¡7}|S) Nzrsub rŒcss|]}t|ƒVqdS)N)rh)rKrrrJrJrMrN„sz9ReverseChainSingleSubstStatement.asFea..css|]}t|ƒdVqdS)r¿N)rh)rKrrrJrJrMrN…scss|]}t|ƒVqdS)N)rh)rKrrrJrJrMrN‡sz by {};css|]}t|ƒVqdS)N)rh)rKrrrJrJrMrNŠs) roròrórOrˆrrhr”rô)rtrzržrJrJrMrh€s    z&ReverseChainSingleSubstStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr<fs  c@s,eZdZdZd dd„Zdd„Zd dd „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. NcCs0t ||¡|||_|_||_||_||_dS)N)rArurºr»rÞrˆrô)rtrˆÚreplacerºr»rÞrsrJrJrMru—s  zSingleSubstStatement.__init__c Csxdd„|jDƒ}dd„|jDƒ}|jd ¡}|jd ¡}t|ƒdkrT|t|ƒ}| |j||tt ||ƒƒ|j ¡dS)z9Calls the builder object's ``add_single_subst`` callback.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢ sz.SingleSubstStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢¡srrjN) rºr»rˆr…rôroZadd_single_substrsrrörÞ)rtrvrºr»r÷rørJrJrMrwžs   zSingleSubstStatement.buildrxcCsÈd}t|jƒst|jƒs|jrŠt|jƒrF|d dd„|jDƒ¡d7}|d dd„|jDƒ¡7}t|jƒr¤|dd dd„|jDƒ¡7}n|d dd„|jDƒ¡7}|d d d d„|jDƒ¡¡7}|S) Nzsub rŒcss|]}t|ƒVqdS)N)rh)rKrrrJrJrMrN²sz-SingleSubstStatement.asFea..css|]}t|ƒdVqdS)r¿N)rh)rKrrrJrJrMrN³scss|]}t|ƒVqdS)N)rh)rKrrrJrJrMrNµscss|]}t|ƒVqdS)N)rh)rKrrrJrJrMrN·sz by {};css|]}t|ƒVqdS)N)rh)rKrrrJrJrMrN¸s)rorºr»rÞrOrˆr”rô)rtrzržrJrJrMrh®s    zSingleSubstStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr?Žs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r=zA ``script`` statement.NcCst ||¡||_dS)N)rArura)rtrarsrJrJrMru¿s zScriptStatement.__init__cCs| |j|j¡dS)z,Calls the builder's ``set_script`` callback.N)Z set_scriptrsra)rtrvrJrJrMrwÃszScriptStatement.buildrxcCsd |j ¡¡S)Nz script {};)r”rar­)rtrzrJrJrMrhÇszScriptStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr=¼s c@s,eZdZdZd dd„Zdd„Zd dd „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.NcCs,t ||¡||||_|_|_||_dS)N)rArur^rºr»rÞ)rtr^rºr»rÞrsrJrJrMruÒs zSinglePosStatement.__init__cCsJdd„|jDƒ}dd„|jDƒ}dd„|jDƒ}| |j||||j¡dS)z7Calls the builder object's ``add_single_pos`` callback.cSsg|] }| ¡‘qSrJ)r…)rKr½rJrJrMr¢Ùsz,SinglePosStatement.build..cSsg|] }| ¡‘qSrJ)r…)rKr rJrJrMr¢ÚscSsg|]\}}| ¡|f‘qSrJ)r…)rKrrr¬rJrJrMr¢ÛsN)rºr»r^Zadd_single_posrsrÞ)rtrvrºr»r^rJrJrMrw×szSinglePosStatement.buildrxcCs¨d}t|jƒst|jƒs|jr‚t|jƒrB|d tt|jƒ¡d7}|d dd„|jDƒ¡7}t|jƒrœ|dd tt|jƒ¡7}n|d dd„|jDƒ¡7}|d7}|S)Nzpos rŒcSs8g|]0}t|dƒd|dr.d|d ¡nd‘qS)rr¿rjrŒrx)rh)rKrÀrJrJrMr¢åsz,SinglePosStatement.asFea..cSs4g|],}t|dƒd|dr*|d ¡nd‘qS)rrŒrjrx)rh)rKrÀrJrJrMr¢ísr°)rorºr»rÞrOrrhr^)rtrzržrJrJrMrhÞs  zSinglePosStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr>Ës c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rEzRepresents a subtable break.NcCst ||¡dS)N)rAru)rtrsrJrJrMruöszSubtableStatement.__init__cCs| |j¡dS)zrz <%s %s %s %s>z<%s %s %s %s %s %s %s %s>) rúrûrürýrþrÿrrrrÇrQ) rtrzrÀrÁrürýrþrÿrrrrJrJrMrh1s<  zValueRecord.asFeacst‡fdd„dDƒƒS)Nc3s|]}tˆ|ƒdk VqdS)N)Úgetattr)rKÚv)rtrJrMrN_sz'ValueRecord.__bool__..)rúrûrürýrþrÿrr)rÎ)rtrJ)rtrMÚ__bool__]s zValueRecord.__bool__) NNNNNNNNFN)rx) r|r}r~rrurrrrhr Ú __nonzero__rJrJrJrMrGs"   ,c@s$eZdZdZddd„Zd dd„ZdS) rHz+Represents a named value record definition.NcCst ||¡||_||_dS)N)rArurgr¬)rtrgr¬rsrJrJrMrurs zValueRecordDefinition.__init__rxcCsd |j ¡|j¡S)NzvalueRecordDef {} {};)r”r¬rhrg)rtrzrJrJrMrhwszValueRecordDefinition.asFea)N)rx)r|r}r~rrurhrJrJrJrMrHos cCsJ|dkr|dkr|dkrdS|dkr8|dkr8|dkr8dSd |||¡SdS)Nérji rxrÚ1z{} {} {})r”)ÚpidZeidÚlidrJrJrMÚsimplify_name_attributes{s rc@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r9z€Represents a name record. (`Section 9.e. `_)NcCs.t ||¡||_||_||_||_||_dS)N)rAruÚnameIDÚ platformIDÚ platEncIDÚlangIDÚstring)rtrrrrrrsrJrJrMru‡s  zNameRecord.__init__cCs$| |j|j|j|j|j|j¡dS)z8Calls the builder object's ``add_name_record`` callback.N)Zadd_name_recordrsrrrrr)rtrvrJrJrMrwszNameRecord.buildrxcs¶dd„‰t|j|j|jƒ}|dkr.td|jƒ‚t|j|d‰|dkrld ‡‡fdd„t d t ˆƒd ƒDƒ¡}nd ‡fd d„ˆDƒ¡}t |j|j|jƒ}|dkr¦|d 7}d   |j ||¡S)NcSs,|dkr |dkr |dkr t|ƒS||SdS)Né é~)é"é\)Úchr)rÈZescape_patternrJrJrMÚescape›sz NameRecord.asFea..escapezUnsupported encoding)ÚencodingÚ utf_16_berxcs2g|]*}ˆtˆ|ƒdtˆ|dƒdƒ‘qS)érjz\%04x)r)rKrÌ)rr rJrMr¢©sz$NameRecord.asFea..rricsg|]}ˆt|ƒdƒ‘qS)z\%02x)r)rKÚb)rrJrMr¢®srŒznameid {} {}"{}";)rrrrrrsrrrOrârorr”r)rtrzrZescaped_stringÚplatrJ)rr rMrhšs  zNameRecord.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr9„s  c@s"eZdZdZdd„Zddd„ZdS) r'z4Represents a ``sizemenuname`` or ``name`` statement.cCst ||¡| |j¡dS)z8Calls the builder object's ``add_featureName`` callback.N)r9rwZadd_featureNamer)rtrvrJrJrMrw¸s zFeatureNameStatement.buildrxcCsF|jdkrd}nd}t|j|j|jƒ}|dkr6|d7}d |||j¡S)NÚsizeZ sizemenunamergrxrŒz {} {}"{}";)rrrrrr”r)rtrzrœr rJrJrMrh½s zFeatureNameStatement.asFeaN)rx)r|r}r~rrwrhrJrJrJrMr'µsc@seZdZdZddd„ZdS)rDz+Represents a STAT table ``name`` statement.rxcCs0t|j|j|jƒ}|dkr"|d7}d ||j¡S)NrxrŒz name {}"{}";)rrrrr”r)rtrzr rJrJrMrhËszSTATNameStatement.asFeaN)rx)r|r}r~rrhrJrJrJrMrDÈsc@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r@zA ``parameters`` statement.NcCs(t ||¡||_||_||_||_dS)N)rAruÚ DesignSizeÚ SubfamilyIDÚ RangeStartÚRangeEnd)rtr"r#r$r%rsrJrJrMruÕs  zSizeParameters.__init__cCs | |j|j|j|j|j¡dS)z|jr dnd}dd„|jDƒ}d |d |j¡||d |¡¡S)NZVertZHorizc Ss2g|]*}d |d|dd tt|dƒ¡¡‘qS)z{} {} {}rrjrŒri)r”rOrrÇ)rKrårJrJrMr¢.sz"BaseAxis.asFea..z2{}Axis.BaseTagList {}; {}{}Axis.BaseScriptList {};rŒz, )rr,r”rOr+)rtrzÚ directionr,rJrJrMrh+s  zBaseAxis.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrs c@s,eZdZdZd dd„Zdd„Zd dd „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.NcCst ||¡||_||_dS)N)rArur«r¬)rtr«r¬rsrJrJrMru;s zOS2Field.__init__cCs| |j|j¡dS)z6Calls the builder object's ``add_os2_field`` callback.N)Z add_os2_fieldr«r¬)rtrvrJrJrMrw@szOS2Field.buildrxcsŠdd„‰d}d}tdd„|Dƒƒ}| ‡fdd„|Dƒ¡dˆg|d <d d d „g|d <|j|kr†d ||jd||jd|jƒ¡SdS)NcSsd tt|ƒ¡S)NrŒ)rOrrÇ)rÀrJrJrMÚ intarr2strEsz"OS2Field.asFea..intarr2str) ZFSTypeZ TypoAscenderZ TypoDescenderZ TypoLineGapZ winAscentZ winDescentZXHeightZ CapHeightZ WeightClassZ WidthClassZ LowerOpSizeZ UpperOpSize)Z UnicodeRangeZ CodePageRangecSsg|]}| ¡|tgf‘qSrJ)rprÇ)rKrÀrJrJrMr¢Wsz"OS2Field.asFea..csg|]}| ¡|ˆgf‘qSrJ)rp)rKrÀ)r.rJrMr¢XsZPanoseZpanoseZVendorcSs d |¡S)Nz"{}")r”)rÁrJrJrMÚZóz OS2Field.asFea..Úvendorz{} {};rrjrx)rõÚupdater«r”r¬)rtrzÚnumbersÚrangesÚkeywordsrJ)r.rMrhDs   "zOS2Field.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr:6s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r*zAn entry in the ``hhea`` table.NcCst ||¡||_||_dS)N)rArur«r¬)rtr«r¬rsrJrJrMrues zHheaField.__init__cCs| |j|j¡dS)z7Calls the builder object's ``add_hhea_field`` callback.N)Zadd_hhea_fieldr«r¬)rtrvrJrJrMrwjszHheaField.buildrxcCs*d}tdd„|Dƒƒ}d ||j|j¡S)N)Z CaretOffsetZAscenderZ DescenderZLineGapcSsg|]}| ¡|f‘qSrJ)rp)rKrÀrJrJrMr¢psz#HheaField.asFea..z{} {};)rõr”r«r¬)rtrzÚfieldsr5rJrJrMrhnszHheaField.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr*bs c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rIzAn entry in the ``vhea`` table.NcCst ||¡||_||_dS)N)rArur«r¬)rtr«r¬rsrJrJrMruws zVheaField.__init__cCs| |j|j¡dS)z7Calls the builder object's ``add_vhea_field`` callback.N)Zadd_vhea_fieldr«r¬)rtrvrJrJrMrw|szVheaField.buildrxcCs*d}tdd„|Dƒƒ}d ||j|j¡S)N)ZVertTypoAscenderZVertTypoDescenderZVertTypoLineGapcSsg|]}| ¡|f‘qSrJ)rp)rKrÀrJrJrMr¢‚sz#VheaField.asFea..z{} {};)rõr”r«r¬)rtrzr6r5rJrJrMrh€szVheaField.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrIts c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rCz²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 NcCs(t ||¡||_||_||_||_dS)N)rArurœÚ axisOrderÚnamesrs)rtrœr7r8rsrJrJrMrus  z STATDesignAxisStatement.__init__cCs| ||j¡dS)N)Z addDesignAxisrs)rtrvrJrJrMrw–szSTATDesignAxisStatement.buildrxcsPˆt7‰d|j›d|j›d}|dˆ ‡fdd„|jDƒ¡d7}|d7}|S)Nz DesignAxis rŒz { r¡csg|]}|jˆd‘qS))rz)rh)rKr )rzrJrMr¢œsz1STATDesignAxisStatement.asFea..z};)r£rœr7rOr8)rtrzržrJ)rzrMrh™s &zSTATDesignAxisStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrC†s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r$ziSTAT table ElidedFallbackName Args: names: a list of :class:`STATNameStatement` objects NcCst ||¡||_||_dS)N)rArur8rs)rtr8rsrJrJrMru¨s zElidedFallbackName.__init__cCs| |j|j¡dS)N)ÚsetElidedFallbackNamer8rs)rtrvrJrJrMrw­szElidedFallbackName.buildrxcs>ˆt7‰d}|dˆ ‡fdd„|jDƒ¡d7}|d7}|S)NzElidedFallbackName { r¡csg|]}|jˆd‘qS))rz)rh)rKr )rzrJrMr¢³sz,ElidedFallbackName.asFea..z};)r£rOr8)rtrzržrJ)rzrMrh°s &zElidedFallbackName.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr$¡s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) r%zpSTAT table ElidedFallbackNameID Args: value: an int pointing to an existing name table name ID NcCst ||¡||_||_dS)N)rArur¬rs)rtr¬rsrJrJrMru¿s zElidedFallbackNameID.__init__cCs| |j|j¡dS)N)r9r¬rs)rtrvrJrJrMrwÄszElidedFallbackNameID.buildrxcCsd|j›dS)NzElidedFallbackNameID r°)r¬)rtrzrJrJrMrhÇszElidedFallbackNameID.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMr%¸s c@s,eZdZdZd dd„Zdd„Zd dd „ZdS) rBzÝ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 NcCs"t ||¡||_||_||_dS)N)rArur8Ú locationsrã)rtr8r:rãrsrJrJrMruÔs zSTATAxisValueStatement.__init__cCs| ||j¡dS)N)ZaddAxisValueRecordrs)rtrvrJrJrMrwÚszSTATAxisValueStatement.buildrxc Cs¶d}x|jD]}|| ¡7}q Wx"|jD]}|| ¡7}|d7}q(W|jrªddg}g}d}x8tt|ƒƒD](}|j|@dkrˆ| ||¡|d>}qhW|dd |¡›d 7}|d 7}|S) Nz AxisValue { r¡ZOlderSiblingFontAttributeZElidableAxisValueNamerjrzflag rŒz; z};)r:rhr8rãrârorrO) rtrzržrsZ nameRecordrãZ flagStringsrŠrÌrJrJrMrhÝs"     zSTATAxisValueStatement.asFea)N)rx)r|r}r~rrurwrhrJrJrJrMrBËs c@s$eZdZdZddd„Zd dd„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 NcCst ||¡||_||_dS)N)rArurœÚvalues)rtrœr;rsrJrJrMruüs z#AxisValueLocationStatement.__init__rxcCs6|d|j›d7}|d dd„|jDƒ¡›d7}|S)Nz location rŒcss|]}t|ƒVqdS)N)rÇ)rKrÌrJrJrMrNsz3AxisValueLocationStatement.asFea..z; )rœrOr;)rtržrJrJrMrhs z AxisValueLocationStatement.asFea)N)rx)r|r}r~rrurhrJrJrJrMrós c@s,eZdZdZd dd„Zdd„Zd dd „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. NcCst ||¡||_||_dS)N)rArurgÚ conditions)rtrgr<rsrJrJrMrus zConditionsetStatement.__init__cCs| |j|j¡dS)N)Zadd_conditionsetrgr<)rtrvrJrJrMrwszConditionsetStatement.buildrxc Csv||d|j›dd7}x<|j ¡D].\}\}}||t|›d|›d|›d7}q&W||dd|j›d7}|S)Nz conditionset rŒz{ z; Ú})rgr<r§r£)rtržrzrœZminvalueZmaxvaluerJrJrMrhs &zConditionsetStatement.asFea)N)rxrx)r|r}r~rrurwrhrJrJrJrMr"s c@s,eZdZdZd dd„Zdd„Zd d d „ZdS) ÚVariationBlockzCA variation feature block, applicable in a given set of conditions.FNcCs&t ||¡||||_|_|_dS)N)rrurgÚ conditionsetr¤)rtrgr?r¤rsrJrJrMru$s zVariationBlock.__init__cCs®| |j|j¡|jdkr:|j|jkr:td|j›|jƒ‚|j}i|_t ||¡xH|j  ¡D]:\}}|j   |i¡  |jg¡}|  |¡||kr^g||<q^W||_|  ¡dS)z‹Call the ``start_feature`` callback on the builder object, visit all the statements in this feature, and then call ``end_feature``.r†z,variation block used undefined conditionset N)r¥rsrgr?Zconditionsets_rr¦rrwr§Zfeature_variations_r¨rŽr©)rtrvrªr«r¬r§rJrJrMrw,s"       zVariationBlock.buildrxcCsb|d|j ¡}||jd7}|jr.|d7}|d7}|tj||d7}||d|j ¡7}|S)Nz variation %s rŒz useExtension z{ )rzz} %s; )rgr­r?r¤rrh)rtrzržrJrJrMrhHszVariationBlock.asFea)FN)rx)r|r}r~rrurwrhrJrJrJrMr>!s r>)XZfontTools.feaLib.errorrZfontTools.feaLib.locationrZfontTools.misc.encodingToolsrZfontTools.misc.textToolsrrÚ collectionsrrðr£Ú__all__rQrÝrqrhÚobjectrrAr&r r„r r r rrrr rrrrFrrrrrrrrrr r#r(r+r,r-r.r/r)r0r1r2r3r4r5r6r7r8r;r<r?r=r>rErGrHrr9r'rDr@rr!rr:r*rIrCr$r%rBrr"r>rJrJrJrMÚsˆ      >  -'%%::$$')8=S(.(n  1 ,(