
    McgY!                    P   d dl mZmZmZmZm	Z
mZ d dlmZ d dlmZmZ d dlmZmZmZmZmZ d dlmZ d dlmZ ddlmZmZmZm Z m!Z! dd	l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z-m.Z/m0Z0 d d
l1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7 d dl8Z8d dl9Z9d dl:m;Z; d dl<Z< e<jz                  e>      Z?d Z@d ZA G d deB      ZC G d deC      ZD G d deD      ZE G d deD      ZF G d deF      ZG G d deF      ZH G d deH      ZI G d d eEeH      ZJ G d! d"eF      ZK G d# d$eF      ZL G d% d&eF      ZM G d' d(eF      ZN G d) d*eF      ZO G d+ d,eF      ZP G d- d.ePeN      ZQ G d/ d0ePeL      ZR G d1 d2ePeH      ZS G d3 d4eD      ZT G d5 d6eD      ZU G d7 d8eU      ZV G d9 d:eL      ZW G d; d<eL      ZX G d= d>eD      ZY G d? d@eY      ZZ G dA dBeY      Z[ G dC dDe[      Z\ G dE dFe[      Z] G dG dHe]      Z^ G dI dJe^      Z_ G dK dLeD      Z` G dM dNeD      Za G dO dPeC      Zb G dQ dReb      Zc G dS dTeb      Zd G dU dVed      Ze G dW dXed      Zf G dY dZeb      Zg G d[ d\ed      Zh G d] d^eeeh      Zi G d_ d`ed      Zj G da dbeF      Zk G dc ddek      Zl G de dfeC      Zm G dg dheC      Zn G di djeC      Zo G dk dleC      Zp G dm dneC      Zq G do dpeC      Zr G dq dreC      Zs G ds dteC      Zt G du dveC      Zu G dw dx      Zv G dy dzeC      Zw G d{ d|eL      Zx G d} d~eN      Zy G d dey      Z, G d dey      Z.i deMdeKdeGdeNdeLdeOdeHdeadeId eJdLe`d4eTd6eUd8eVd:eWd@eZdDe\i dFe]dHe^dJe_debdeddeedefddeldresdtetdveud|exde,de.d<eXd e5ewev      d e5ewe$      eqerecececeod d d d d d dZzy)    )fixedToFloatfloatToFixedfloatToFixedToStrstrToFixedToFloatensureVersionIsLongversionToFixed)TupleVariation)nearestMultipleShortestReprotRound)	bytesjointobytestostrpadsafeEval)LazyList)getSearchRange   )CountReferenceFormatSwitchingBaseTableOTTableReaderOTTableWriterValueRecordFactory)lookupTypesVarCompositeGlyphAATStateTableAATState	AATActionContextualMorphActionLigatureMorphActionInsertionMorphActionMorxSubtable
ExtendModeCompositeModeNO_VARIATION_INDEX)zip_longest
accumulate)partial)SimpleNamespaceN)Optionalc                 "    t        | t              S N)
isinstancetuple)ts    ^/var/www/html/bid-api/venv/lib/python3.12/site-packages/fontTools/ttLib/tables/otConverters.py<lambda>r0   -   s    Jq%(    c           	         g }i }| D ]  \  }}}}}|}	|j                  d      r|dk(  sJ t        }
n|j                  d      s|dv rt        t        t
        d|   }
na|dk(  rt        }
nU|dk(  rt        }
nI|dk(  rt        }
n=|d	k(  rt        }
n1|d
v rt        }
n&|t        vrd|vr	|}	t        }
nt        ||t              }
 |
||||      }|j                  r|j                  }n'|dv r|j                  |      }n|j                  |	      }|j                  s||_        |dv rY|d   |_        |j                   j#                         D ]2  }|j#                         D ]  }t%        ||||      ||j&                  <    4 |d	k(  rN|d   |_        |d	   |_        |j(                  j#                         D ]  }t%        ||||      ||j&                  <    |j-                  |       ||vsJ |       |||<    ||fS )zGiven a table spec from otData.py, build a converter object for each
    field of the table. This is called for each table in otData.py, and
    the results are assigned to the corresponding class in otTables.py.ValueFormatuint16Count)StructLength	MorphType)uint8r4   uint32SubTableExtSubTable	SubStructFeatureParams)CIDGlyphMappingGlyphCIDMapping(description)	MortChainMortSubtable	MorxChain)r:   r;   r<   r   featureParamTypes)
startswithr3   endswithComputedUInt8ComputedUShortComputedULongr:   r;   r<   r=   StructWithLengthconverterMappingStructeval
tableClassgetr   valuesTable__name__rF   defaultFeatureParamsappend)	tableSpectableNamespace
convertersconvertersByNametpnamerepeatauxdescr	tableNameconverterClassconvrP   r.   clss                  r/   buildConvertersrd   0   s%    J(1$D&#u	??=)>!>(N]]7#t/L'L&(' 	N
 Z%N]"(N[ &N_$*N;;-N))cm	!'!%b.:J!KdFCUC??J=='++B/J'++I6J(DO;;-m<D%%,,.88:C5:4c5R$S\\2 & / ?"%34G%HD"(6(GD%--44616tVS#1N . 7$++1T1+!%m )2n '''r1   c                       e Zd ZdZddddZd Zd Zd Zd	 Zdd
Z	d Z
d Z ej                  d      Zdee   fdZy)BaseConverterz\Base class for converter objects. Apart from the constructor, this
    is an abstract class.N rA   c                6   || _         || _        || _        | j                  r(| j                  st        | j                  dd      | _        || _        |j                  d      xs |dv | _        |j                  d      xs |dk(  | _        |dv | _        || _	        y )Nz<string>rO   r5   )DesignAxisRecordSizeValueRecordSize
LookupTyper7   )
ClassCountClass2Count
FeatureTagSettingsCountVarRegionCountMappingCountRegionAxisCountDesignAxisCountri   AxisValueCountrj   	AxisCountBaseGlyphRecordCountLayerRecordCountAxisIndicesList)
r\   r]   r^   compilerP   rH   isCountisLookupTypeisPropagatedrB   selfr\   r]   r^   rP   rB   s         r/   __init__zBaseConverter.__init__t   s    	88DKKtxxV<DH$}}W- 
 :
 2
 !MM,7N4;;N  %
 
" 'r1   c                 `   	
 j                   xr |dkD  }|r j                        

t        u rd}|s6g }t        |      D ]$  }|j	                   j                  |             & |S 
 fd} |       	t        	fdt        |      D              }j                  |
z         |S )z(Read an array of values from the reader.   Fc                  V    j                         j                  fd} | S )Nc                 X    j                  | z  z          j                  i       S r+   )seekread)ifontposreader_copy
recordSizer~   s    r/   	read_itemzABaseConverter.readArray.<locals>.get_read_item.<locals>.read_item   s-    $$S1z>%9:99[$;;r1   copyr   )r   r   r   r   readerr   r~   s    @@r/   get_read_itemz.BaseConverter.readArray.<locals>.get_read_item   s)    $kkmjj< < ! r1   c              3   "   K   | ]  }  y wr+    ).0r   r   s     r/   	<genexpr>z*BaseConverter.readArray.<locals>.<genexpr>   s     9LqLs   )lazygetRecordSizeNotImplementedrangerV   r   r   advance)r~   r   r   	tableDictcountr   lr   r   r   r   s   ```      @@r/   	readArrayzBaseConverter.readArray   s    yy&UQY++F3J^+A5\64;< "H! &I9E%L99ANN5:-.Hr1   c                 >    t        | d      r| j                  S t        S )N
staticSize)hasattrr   r   r~   r   s     r/   r   zBaseConverter.getRecordSize   s    4&??"r1   c                     t        |       )zRead a value from the reader.NotImplementedErrorr~   r   r   r   s       r/   r   zBaseConverter.read       !$''r1   c                     	 t        |      D ]  \  }}| j                  |||||        y # t        $ r}|j                  fz   |_         d }~ww xY wr+   )	enumeratewrite	Exceptionargs)r~   writerr   r   rR   r   valuees           r/   
writeArrayzBaseConverter.writeArray   sR    	%f-5

64E1= . 	VVqd]AF	s   (+ 	AA

Ac                     t        |       )zWrite a value to the writer.r   r~   r   r   r   r   repeatIndexs         r/   r   zBaseConverter.write   r   r1   c                     t        |       )zRead a value from XML.r   r~   attrscontentr   s       r/   xmlReadzBaseConverter.xmlRead   r   r1   c                     t        |       )zWrite a value to XML.r   r~   	xmlWriterr   r   r\   r   s         r/   xmlWritezBaseConverter.xmlWrite   r   r1   zVarIndexBase\s*\+\s*(\d+)returnc                     | j                   j                  | j                        }|syt        |j	                  d            S )zJIf description has `VarIndexBase + {offset}`, return the offset else None.Nr   )varIndexBasePlusOffsetREsearchrB   intgroup)r~   ms     r/   getVarIndexOffsetzBaseConverter.getVarIndexOffset   s6    ))001A1AB1771:r1   r+   )rT   
__module____qualname____doc__r   r   r   r   r   r   r   r   rery   r   r)   r   r   r   r1   r/   rf   rf   p   sZ    '" '><
((((  *rzz*FG8C= r1   rf   c                   8    e Zd Zed        Zed        Zd Zd Zy)SimpleValuec                     | S r+   r   r   s    r/   toStringzSimpleValue.toString       r1   c                     | S r+   r   r   s    r/   
fromStringzSimpleValue.fromString   r   r1   c                 r    |j                  ||d| j                  |      fgz          |j                          y Nr   )	simpletagr   newliner   s         r/   r   zSimpleValue.xmlWrite   s4    D%GT]]55I+J*K"KLr1   c                 *    | j                  |d         S r   )r   r   s       r/   r   zSimpleValue.xmlRead   s    uW~..r1   N)rT   r   r   staticmethodr   r   r   r   r   r1   r/   r   r      s2       /r1   r   c                       e Zd ZdZd Zd Zy)OptionalValueNc                     || j                   k7  r"|j                  d| j                  |      f       |j                  ||       |j	                          y r   )DEFAULTrV   r   r   r   r   s         r/   r   zOptionalValue.xmlWrite   sD    DLL LL'4==#789D%(r1   c                 J    d|v r| j                  |d         S | j                  S r   )r   r   r   s       r/   r   zOptionalValue.xmlRead   s'    e??5>22||r1   )rT   r   r   r   r   r   r   r1   r/   r   r      s    Gr1   r   c                       e Zd Zed        Zy)IntValuec                     t        | d      S Nr   )r   r   s    r/   r   zIntValue.fromString   s    5!}r1   NrT   r   r   r   r   r   r1   r/   r   r      s     r1   r   c                   *    e Zd ZdZd Zd ZddZd Zy)Long   c                 "    |j                         S r+   readLongr   s       r/   r   z	Long.read        r1   c                 $    |j                  |      S r+   )readLongArrayr~   r   r   r   r   s        r/   r   zLong.readArray      ##E**r1   Nc                 &    |j                  |       y r+   )	writeLongr   s         r/   r   z
Long.write      r1   c                 &    |j                  |       y r+   )writeLongArrayr~   r   r   r   rR   s        r/   r   zLong.writeArray
      f%r1   r+   rT   r   r   r   r   r   r   r   r   r1   r/   r   r          J!+ &r1   r   c                   *    e Zd ZdZd Zd ZddZd Zy)ULongr   c                 "    |j                         S r+   	readULongr   s       r/   r   z
ULong.read      !!r1   c                 $    |j                  |      S r+   )readULongArrayr   s        r/   r   zULong.readArray      $$U++r1   Nc                 &    |j                  |       y r+   
writeULongr   s         r/   r   zULong.write      % r1   c                 &    |j                  |       y r+   )writeULongArrayr   s        r/   r   zULong.writeArray      v&r1   r+   r   r   r1   r/   r   r         J",!'r1   r   c                       e Zd Zed        Zy)Flags32c                     d| z  S )Nz0x%08Xr   r   s    r/   r   zFlags32.toString      %r1   N)rT   r   r   r   r   r   r1   r/   r  r    s       r1   r  c                       e Zd ZeZy)VarIndexN)rT   r   r   r$   r   r   r1   r/   r	  r	  $  s     Gr1   r	  c                   *    e Zd ZdZd Zd ZddZd Zy)Short   c                 "    |j                         S r+   )	readShortr   s       r/   r   z
Short.read+  r   r1   c                 $    |j                  |      S r+   )readShortArrayr   s        r/   r   zShort.readArray.  r   r1   Nc                 &    |j                  |       y r+   )
writeShortr   s         r/   r   zShort.write1  r   r1   c                 &    |j                  |       y r+   )writeShortArrayr   s        r/   r   zShort.writeArray4  r  r1   r+   r   r   r1   r/   r  r  (  r  r1   r  c                   *    e Zd ZdZd Zd ZddZd Zy)UShortr  c                 "    |j                         S r+   
readUShortr   s       r/   r   zUShort.read;        ""r1   c                 $    |j                  |      S r+   )readUShortArrayr   s        r/   r   zUShort.readArray>  s    %%e,,r1   Nc                 &    |j                  |       y r+   writeUShortr   s         r/   r   zUShort.writeA      5!r1   c                 &    |j                  |       y r+   )writeUShortArrayr   s        r/   r   zUShort.writeArrayD  s    'r1   r+   r   r   r1   r/   r  r  8  s    J#-"(r1   r  c                   *    e Zd ZdZd Zd ZddZd Zy)Int8r   c                 "    |j                         S r+   )readInt8r   s       r/   r   z	Int8.readK  r   r1   c                 $    |j                  |      S r+   )readInt8Arrayr   s        r/   r   zInt8.readArrayN  r   r1   Nc                 &    |j                  |       y r+   )	writeInt8r   s         r/   r   z
Int8.writeQ  r   r1   c                 &    |j                  |       y r+   )writeInt8Arrayr   s        r/   r   zInt8.writeArrayT  r   r1   r+   r   r   r1   r/   r$  r$  H  r   r1   r$  c                   *    e Zd ZdZd Zd ZddZd Zy)UInt8r   c                 "    |j                         S r+   )	readUInt8r   s       r/   r   z
UInt8.read[  r   r1   c                 $    |j                  |      S r+   )readUInt8Arrayr   s        r/   r   zUInt8.readArray^  r   r1   Nc                 &    |j                  |       y r+   )
writeUInt8r   s         r/   r   zUInt8.writea  r   r1   c                 &    |j                  |       y r+   )writeUInt8Arrayr   s        r/   r   zUInt8.writeArrayd  r  r1   r+   r   r   r1   r/   r.  r.  X  r  r1   r.  c                       e Zd ZdZd ZddZy)UInt24   c                 "    |j                         S r+   
readUInt24r   s       r/   r   zUInt24.readk  r  r1   Nc                 &    |j                  |       y r+   writeUInt24r   s         r/   r   zUInt24.writen  r   r1   r+   rT   r   r   r   r   r   r   r1   r/   r8  r8  h  s    J#"r1   r8  c                       e Zd Zd Zy)ComputedIntc                 V    |'|j                  |d|       |j                          y y )N=)commentr   r   s         r/   r   zComputedInt.xmlWrites  s,    u56 r1   NrT   r   r   r   r   r1   r/   rB  rB  r  s     r1   rB  c                       e Zd Zy)rI   NrT   r   r   r   r1   r/   rI   rI   y      r1   rI   c                       e Zd Zy)rJ   NrH  r   r1   r/   rJ   rJ   }  rI  r1   rJ   c                       e Zd Zy)rK   NrH  r   r1   r/   rK   rK     rI  r1   rK   c                       e Zd ZdZd ZddZy)Tagr   c                 "    |j                         S r+   )readTagr   s       r/   r   zTag.read  s    ~~r1   Nc                 &    |j                  |       y r+   )writeTagr   s         r/   r   z	Tag.write  s    r1   r+   r@  r   r1   r/   rM  rM    s    J r1   rM  c                   .    e Zd ZdZdZd Zd Zd ZddZy)	GlyphIDr  Hc                 n    |j                  |j                  | j                  | j                  |            S r+   )getGlyphNameManyr   typecoder   r   s        r/   r   zGlyphID.readArray  s/    $$T]]DOOUC
 	
r1   c                 l    |j                  |j                  | j                  | j                              S r+   )getGlyphName	readValuerW  r   r   s       r/   r   zGlyphID.read  s(      !1!1$--!QRRr1   c                 Z    |j                  | j                  |j                  |             y r+   )r   rW  getGlyphIDManyr   s        r/   r   zGlyphID.writeArray  s!    $--)<)<V)DEr1   Nc                 Z    |j                  | j                  |j                  |             y r+   )
writeValuerW  
getGlyphIDr   s         r/   r   zGlyphID.write  s    $--)?@r1   r+   )	rT   r   r   r   rW  r   r   r   r   r   r1   r/   rS  rS    s#    JH

SFAr1   rS  c                       e Zd ZdZdZy)	GlyphID32r   LN)rT   r   r   r   rW  r   r1   r/   ra  ra    s    JHr1   ra  c                       e Zd Zd Zy)NameIDc                 @   |j                  ||d|fgz          |rt|rr|j                  d      }|r_|j                  |      }|j                  d       |r|j	                  |       n)|j	                  d       t
        j                  d|z         |j                          y )Nr   r\     zmissing from name tablez"name id %d missing from name table)r   rQ   getDebugNamer   rE  logwarningr   )r~   r   r   r   r\   r   	nameTables          r/   r   zNameID.xmlWrite  s    D%GU+;*<"<=E(I --e4%%%d+%%&?@KK Du LMr1   NrF  r   r1   r/   rd  rd    s    r1   rd  c                       e Zd Zd Zy)	STATFlagsc                    |j                  ||d|fgz          g }|dz  r|j                  d       |dz  r|j                  d       |r1|j                  d       |j                  dj	                  |             |j                          y )Nr   r   OlderSiblingFontAttributer  ElidableAxisValueNamerf   )r   rV   r   rE  joinr   r~   r   r   r   r\   r   flagss          r/   r   zSTATFlags.xmlWrite  s}    D%GU+;*<"<=4<LL454<LL01OOD!chhuo.r1   NrF  r   r1   r/   rl  rl    s    
r1   rl  c                       e Zd Zed        Zy)
FloatValuec                     t        |       S r+   )floatr   s    r/   r   zFloatValue.fromString      U|r1   Nr   r   r1   r/   ru  ru    s     r1   ru  c                       e Zd ZdZd ZddZy)
DeciPointsr  c                 (    |j                         dz  S N
   r  r   s       r/   r   zDeciPoints.read  s      "R''r1   Nc                 >    |j                  t        |dz               y r|  )r  roundr   s         r/   r   zDeciPoints.write  s    5,-r1   r+   r@  r   r1   r/   rz  rz    s    J(.r1   rz  c                   j    e Zd ZeZeZeZeZd ZddZ	e
d        Ze
d        Ze
d        Ze
d        Zy)	BaseFixedValuec                 V    | j                   t        || j                                     S r+   )fromIntgetattrreaderMethodr   s       r/   r   zBaseFixedValue.read  s$    ||>GFD,=,=>@AAr1   Nc                 Z     t        || j                        | j                  |             y r+   )r  writerMethodtoIntr   s         r/   r   zBaseFixedValue.write  s"    *))*4::e+<=r1   c                 .    t        || j                        S r+   )fi2flprecisionBitsrc   r   s     r/   r  zBaseFixedValue.fromInt      UC--..r1   c                 .    t        || j                        S r+   )fl2fir  r  s     r/   r  zBaseFixedValue.toInt  r  r1   c                 .    t        || j                        S r+   )str2flr  r  s     r/   r   zBaseFixedValue.fromString      eS..//r1   c                 .    t        || j                        S r+   )fl2strr  r  s     r/   r   zBaseFixedValue.toString  r  r1   r+   )rT   r   r   r   r   r  r  r  r   r   classmethodr  r  r   r   r   r1   r/   r  r    sq    J"M!L!LB> / / / / 0 0 0 0r1   r  c                       e Zd ZdZdZdZdZy)Fixedr      r   r   NrT   r   r   r   r  r  r  r   r1   r/   r  r    s    JMLLr1   r  c                       e Zd ZdZdZdZdZy)F2Dot14r     r  r  Nr  r   r1   r/   r  r    s    JMLLr1   r  c                   d     e Zd ZdZdZe fd       Ze fd       Zed        Zed        Z	 xZ
S )Angleg        g     ?c                 B    t         |   |      | j                  z   dz  S N   )superr  biasrc   r   	__class__s     r/   r  zAngle.fromInt  s     &1S88r1   c                 B    t         |   |dz  | j                  z
        S r  )r  r  r  r  s     r/   r  zAngle.toInt
  s    w}eckSXX566r1   c                 ^    t        t        |      | j                  z        | j                  z  S r+   )r   rw  factorr  s     r/   r   zAngle.fromString  s%     uU|cjj01CJJ>>r1   c                 .    t        || j                        S r+   )r
   r  r  s     r/   r   zAngle.toString  s    *5#**==r1   )rT   r   r   r  r  r  r  r  r   r   __classcell__r  s   @r/   r  r     s]     D"F9 9 7 7 ? ? > >r1   r  c                       e Zd ZdZy)BiasedAngleg      ?N)rT   r   r   r  r   r1   r/   r  r    s	     Dr1   r  c                   N    e Zd ZdZd ZddZed        Zed        Zed        Z	y)	Versionr   c                 &    |j                         }|S r+   r   )r~   r   r   r   r   s        r/   r   zVersion.read!  s    !r1   Nc                 <    t        |      }|j                  |       y r+   )fi2ver   r   s         r/   r   zVersion.write%  s    er1   c                     t        |       S r+   )ve2fir   s    r/   r   zVersion.fromString)  rx  r1   c                     d| z  S )N0x%08xr   r   s    r/   r   zVersion.toString-  r  r1   c                     t        | d      S )Nr  )r  )vs    r/   	fromFloatzVersion.fromFloat1  s    Q|r1   r+   )
rT   r   r   r   r   r   r   r   r   r  r   r1   r/   r  r    sM    J         r1   r  c                   "    e Zd ZdZdZd ZddZy)Char64zAn ASCII string with up to 64 characters.

    Unused character positions are filled with 0x00 bytes.
    Used in Apple AAT fonts in the `gcid` table.
    @   c                     |j                  | j                        }|j                  d      }|dk\  r|d | }t        |dd      }|t        |dd      k7  rt        j                  d|z         |S )N    r   asciireplaceencodingerrorsignorez%replaced non-ASCII characters in "%s")readDatar   findr   rh  ri  )r~   r   r   r   datazeroPosss          r/   r   zChar64.read?  sj    t/))E"a<>D$;dWX>>KK?!CDr1   Nc                 J   t        |dd      }|t        |dd      k7  rt        j                  d|z         t        |      | j                  kD  r$t        j                  d|| j                  fz         |d| j                  z  z   d | j                   }|j                  |       y )Nr  r  r  r  z&replacing non-ASCII characters in "%s"z$truncating overlong "%s" to %d bytesr  )r   rh  ri  lenr   	writeData)r~   r   r   r   r   r   r  s          r/   r   zChar64.writeI  s    uwyA7578DDKK@5HIt9t&KK6%9QQ ut..0A$//Br1   r+   )rT   r   r   r   r   r   r   r   r1   r/   r  r  6  s     J	r1   r  c                   2    e Zd Zd Zd ZddZd Zd Zd Zy)	rN   c                 T    | j                   xr | j                   j                  |      S r+   )rP   r   r   s     r/   r   zStruct.getRecordSizeV  s     H4??#@#@#HHr1   c                 J    | j                         }|j                  ||       |S r+   )rP   	decompile)r~   r   r   r   tables        r/   r   zStruct.readY  s!    !%r1   Nc                 (    |j                  ||       y r+   )ry   r   s         r/   r   zStruct.write^  s    fd#r1   c                     |*|r'|j                  ||dgz          |j                          y y |j                  ||||       y )N)emptyr   )r\   )r   r   toXMLr   s         r/   r   zStruct.xmlWritea  sF    = ##D%<.*@A!!#KK	4TK:r1   c                 *   d|v rt        |d         ry | j                         }|j                  d      }|t        |      |_        t        |d       }|rd}|j                         D ]  }|j                  sd}t        |d      si |_        |j                  }	|j                  |	vsJ |j                  |	f       t        ||j                  d        t        |j                  |j                        |	|j                  <    |D ]-  }
t        |
t              r|
\  }}}|j                  ||||       ./ |j!                  t#        |dd              |rBr@|j                         D ]-  }|j                  s|j                  }	|	|j                  = |	r,|`/ |S )Nr  FormatpostReadFT_propagator)
propagator)r   rP   rQ   r   r  r   getConvertersr|   r  r\   setattrr   __dict__r,   r-   fromXMLpopulateDefaultsr  )r~   r   r   r   r  r  
noPostReadcleanPropagationrb   r  elementr\   s               r/   r   zStruct.xmlReadn  s   ew 8!8$v;EL 
33
$++-$$'+$"47+-(!%!1!1J99J6OJ8OO6E499d3,:5>>499,UJtyy) . G'5)'.$eWdE7D9  	'$t*LM!//1D((%)%5%5
&tyy1) $ 0 2 r1   c                 2    dt        | j                        z   S )Nz
Struct of )reprrP   )r~   s    r/   __repr__zStruct.__repr__  s    d4??333r1   r+   )	rT   r   r   r   r   r   r   r   r  r   r1   r/   rN   rN   U  s"    I
$;(T4r1   rN   c                       e Zd Zd ZddZy)rL   c                     |j                   }| j                         }|j                  ||       |j                  ||j                  z          |S r+   )r   rP   r  r   r6   )r~   r   r   r   r   r  s         r/   r   zStructWithLength.read  sA    jj!%C%,,,-r1   Nc                 $   t        |j                               D ]  \  }}|j                  dk(  s n t        |j                        z   }t        |t              r|dz  }ddddj                     }	|j                         }
|	|_	        |j                  ||       |j                         |
z
  }|j                         }|j                  ||||       |j                  |   dd |j                   k(  sJ |j                         |j                  |<   y )Nr6   r      i     >[= )r   r  r      ޭ)r   r  r\   r  itemsr,   r   r   getDataLengthr6   ry   getSubWriterr   
getAllData)r~   r   r   r   r   r   	convIndexrb   lengthIndexdeadbeefbeforelengthlengthWriters                r/   r   zStructWithLength.write  s    ()<)<)>?OItyyN*  @ &,,')3e561K:6tG%%'%fd#%%'&0**,

<y&9||K(,?@Q$//,RRRR$0$;$;$=[!r1   r+   rT   r   r   r   r   r   r1   r/   rL   rL     s    >r1   rL   c                   *    e Zd ZdZd Zd Zd ZddZy)rS   r  c                 "    |j                         S r+   r  r   s     r/   
readOffsetzTable.readOffset  r  r1   c                 &    |j                  d       y r   r  r~   r   s     r/   writeNullOffsetzTable.writeNullOffset      1r1   c                     | j                  |      }|dk(  ry | j                         }|j                  |      }|j                  r||_        ||_        |S |j                  ||       |S r   )r  rP   getSubReaderr   r   r   r  )r~   r   r   r   offsetr  s         r/   r   z
Table.read  sg    (Q;!$$V,99!ELEJ  OOFD)r1   Nc                     || j                  |       y |j                         }| j                  |_        |||_        |j	                  || j
                         |j                  ||       y )N
offsetSize)r  r  r\   r   writeSubTabler   ry   )r~   r   r   r   r   r   	subWriters          r/   r   zTable.write  sa    =  (++-I!YYIN&(3	%  t GMM)T*r1   r+   )rT   r   r   r   r  r  r   r   r   r1   r/   rS   rS     s    J#	+r1   rS   c                       e Zd ZdZd Zd Zy)LTabler   c                 "    |j                         S r+   r   r   s     r/   r  zLTable.readOffset  r   r1   c                 &    |j                  d       y r   r   r  s     r/   r  zLTable.writeNullOffset  s    !r1   NrT   r   r   r   r  r  r   r1   r/   r  r    s    J"r1   r  c                       e Zd ZdZd Zd Zy)Table24r9  c                 "    |j                         S r+   r;  r   s     r/   r  zTable24.readOffset  r  r1   c                 &    |j                  d       y r   r>  r  s     r/   r  zTable24.writeNullOffset  r  r1   Nr
  r   r1   r/   r  r    s    J#r1   r  c                   $     e Zd Zd Z fdZ xZS )r<   c                     | j                   |   |   }| j                  | j                  | j                  | j                  |      S r+   r   r  r\   r]   r^   r~   	tableType
lookupTyperP   s       r/   getConverterzSubStruct.getConverter  8    %%i0<
~~diidhh
KKr1   c                 4    t         t        |   |||d |       y r+   )r  r<   r   r~   r   r   r   r\   r   r  s         r/   r   zSubStruct.xmlWrite  s    i'	4eLr1   rT   r   r   r  r   r  r  s   @r/   r<   r<     s    LM Mr1   r<   c                   $     e Zd Zd Z fdZ xZS )r:   c                     | j                   |   |   }| j                  | j                  | j                  | j                  |      S r+   r  r  s       r/   r  zSubTable.getConverter  r  r1   c                 4    t         t        |   |||d |       y r+   )r  r:   r   r  s         r/   r   zSubTable.xmlWrite  s    h&y$tUKr1   r  r  s   @r/   r:   r:     s    LL Lr1   r:   c                       e Zd ZddZy)r;   Nc                 F    d|_         t        j                  | |||||       y )NT)	ExtensionrS   r   r   s         r/   r   zExtSubTable.write  s     D&$	5+Fr1   r+   )rT   r   r   r   r   r1   r/   r;   r;     s    Gr1   r;   c                       e Zd Zd Zy)r=   c                     | j                   j                  || j                        }| j                  | j                  | j
                  | j                  |      S r+   )rF   rQ   rU   r  r\   r]   r^   )r~   
featureTagrP   s      r/   r  zFeatureParams.getConverter
  sA    ++//
D<U<UV
~~diidhh
KKr1   N)rT   r   r   r  r   r1   r/   r=   r=   	  s    Lr1   r=   c                   ,    e Zd ZdZddddZd ZddZy)	r3   r  Nrg   rA   c                r    t         j                  | |||||       d|d   dk(  r
dz   | _        y dz   | _        y )NrA   r3   21)rf   r   whichr}   s         r/   r   zValueFormat.__init__  sC    $Z[ 	 	
 #T"X_cF
#F
r1   c                 V    |j                         }t        |      || j                  <   |S r+   )r  r   r(  r~   r   r   r   formats        r/   r   zValueFormat.read  s(    ""$/7tzzr1   c                 V    |j                  |       t        |      || j                  <   y r+   )r  r   r(  )r~   r   r   r   r+  r   s         r/   r   zValueFormat.write  s#    6"/7tzzr1   r+   )rT   r   r   r   r   r   r   r   r1   r/   r3   r3     s    JG" G
8r1   r3   c                   ,    e Zd Zd Zd ZddZd Zd Zy)ValueRecordc                 8    dt        || j                           z  S Nr  )r  r(  r   s     r/   r   zValueRecord.getRecordSize#  s    3vdjj)***r1   c                 @    || j                      j                  ||      S r+   )r(  readValueRecordr   s       r/   r   zValueRecord.read&  s    djj!11&$??r1   Nc                 D    || j                      j                  |||       y r+   )r(  writeValueRecordr   s         r/   r   zValueRecord.write)  s    tzz++FD%@r1   c                 F    |y |j                  ||| j                  |       y r+   )r  r\   r   s         r/   r   zValueRecord.xmlWrite,  s     =KK	4E:r1   c                 H    ddl m}  |       }|j                  d |||       |S )Nr   )r.  )otBaser.  r  )r~   r   r   r   r.  r   s         r/   r   zValueRecord.xmlRead2  s#    'dE7D1r1   r+   )rT   r   r   r   r   r   r   r   r   r1   r/   r.  r.  "  s    +@A;r1   r.  c                       e Zd ZdZdddZd ZddZed        Zd	 Z	d
 Z
d Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zd Zy)	AATLookupr}  rg   rA   c                    t         j                  | |||||       t        | j                  t              r| j                  dd d       | _        y t        dd d | j                        | _        y )NrA   Value)r\   r]   r^   )r\   r]   r^   rP   )rf   r   
issubclassrP   r   	converterrS   r}   s         r/   r   zAATLookup.__init__=  sa    $Z[ 	 	
 doo{3!__'$D_QDN"TtDNr1   c                    |j                         }|dk(  r| j                  ||      S |dk(  r| j                  ||      S |dk(  r| j                  ||      S |dk(  r| j	                  ||      S |dk(  r| j                  ||      S J d|z         )Nr   r  r      r   zunsupported lookup format: %d)r  readFormat0readFormat2readFormat4readFormat6readFormat8r*  s        r/   r   zAATLookup.readH  s    ""$Q;##FD11q[##FD11q[##FD11q[##FD11q[##FD11B9FBB5r1   Nc                    t        t        |j                         D cg c]  \  }}|j                  |      |f c}}            }t        t        t	        d | j                  |||      | j                  |||      | j                  |||      | j                  |||      g                  }	|	d   \  }
}}|j                         } |        |j                         |z
  }||
k(  sJ d||
|fz         y c c}}w )Nr   z;AATLookup format %d claimed to write %d bytes, but wrote %d)
listsortedr  r_  filterbuildFormat0buildFormat2buildFormat6buildFormat8r  )r~   r   r   r   r   r   glyphvalrR   formatsdataSizelookupFormatwriteMethodr   
actualSizes                  r/   r   zAATLookup.writeW  s   EKKMRMjeST__U+S1MRS
 ))&$?))&$?))&$?))&$?	

 /6aj+,""$))+c1
("	
HL
 
	
"/ Ss   C3c                     | j                  |       | j                  |       t        ||      \  }}}| j                  |       | j                  |       | j                  |       y )N)nitemSize)r  r   )r   numUnitsunitSizesearchRangeentrySelector
rangeShifts         r/   writeBinSearchHeaderzAATLookup.writeBinSearchHeaderw  s`    8$8$1?2
.]J 	;'=):&r1   c                      t        j                               }t              |k7  ry  j                  j                  }d||z  z   d fdfS )Nr  r   c                  *    j                         S r+   )writeFormat0r   r~   rR   r   s   r/   r0   z(AATLookup.buildFormat0.<locals>.<lambda>      D%%fdF;r1   )r  getGlyphOrderr=  r   )r~   r   r   rR   	numGlyphs	valueSizes   ````  r/   rI  zAATLookup.buildFormat0  sQ    **,-	v;)#NN--		I%%;
 	
r1   c                 z    |j                  d       |D ]%  \  }}| j                  j                  ||d |d        ' y )Nr   r   r   r   )r  r=  r   )r~   r   r   rR   glyphID_r   s         r/   r_  zAATLookup.writeFormat0  s@    1%OHeNN  Et !   &r1   c                 F    |d   \  }}|}g |dd  D ]/  \  }}||dz   k7  s||k7  rj                  |||f       |x}}|}.|}1 j                  |||f        j                  j                  }	t              dz   |	dz   }}
d j                  z   |
|z  z   d fdfS )Nr   r   r   r  c                  *    j                         S r+   )writeFormat2)r   segmentsr~   r   s   r/   r0   z(AATLookup.buildFormat2.<locals>.<lambda>  s    D%%fdH=r1   )rV   r=  r   r  BIN_SEARCH_HEADER_SIZE)r~   r   r   rR   segStartsegValuesegEndglyphIDcurValuerd  rW  rX  rk  s   ```         @r/   rJ  zAATLookup.buildFormat2  s    #AY(!'GX&1*$H(<68 <=$++6#  ", 	6845NN--	 ]Q.	A(+++h.AA=
 	
r1   c                    |j                  d       | j                  j                  }t        |      |dz   }}| j	                  |||       |D ]H  \  }}}	|j                  |       |j                  |       | j                  j                  ||d |	d        J |j                  d       |j                  d       |j                  d|z         y )Nr  r   rf    r  r  r=  r   r  r\  r   r  )
r~   r   r   rk  rd  rW  rX  
firstGlyph	lastGlyphr   s
             r/   rj  zAATLookup.writeFormat2  s    1NN--	 ]IM(!!&(H=,4(J	5y)z*NN  Et !  -5 	6"6"9,-r1   c                       j                   j                  }t              |dz   }}d j                  z   |dz   |z  z   d fdfS )Nr  r   r?  c                  *    j                         S r+   )writeFormat6r`  s   r/   r0   z(AATLookup.buildFormat6.<locals>.<lambda>  ra  r1   )r=  r   r  rl  )r~   r   r   rR   rd  rW  rX  s   ````   r/   rK  zAATLookup.buildFormat6  sO    NN--	 [)a-(+++x!|x.GG;
 	
r1   c                 X   |j                  d       | j                  j                  }t        |      |dz   }}| j	                  |||       |D ]6  \  }}|j                  |       | j                  j                  ||d |d        8 |j                  d       |j                  d|z         y )Nr?  r  rf  rs  r  rt  )	r~   r   r   rR   rd  rW  rX  rp  r   s	            r/   ry  zAATLookup.writeFormat6  s    1NN--	 [)a-(!!&(H=$NGUw'NN  Et !  %
 	6"9,-r1   c                      d   d   d   d   }}t              ||z
  dz   k7  ry  j                  j                  }dt              |z  z   d fdfS )Nr   r%  r   r?  r   c                  *    j                         S r+   )writeFormat8r`  s   r/   r0   z(AATLookup.buildFormat8.<locals>.<lambda>  ra  r1   )r  r=  r   )r~   r   r   rR   
minGlyphID
maxGlyphIDrd  s   ````   r/   rL  zAATLookup.buildFormat8  se    !'1vbz!}J
v;*z1A55NN--	Fi'';
 	
r1   c                     |d   d   }|j                  d       |j                  |       |j                  t        |             |D ]%  \  }}| j                  j                  ||d |d        ' y )Nr   r   rf  )r  r  r=  r   )r~   r   r   rR   firstGlyphID_r   s          r/   r}  zAATLookup.writeFormat8  sm    ay|1<(3v;'HAuNN  Et !  r1   c                     t        |j                               }| j                  j                  ||d |      }t	        |      D ci c]  \  }}|j                  |      | c}}S c c}}w Nr   r   )r  rb  r=  r   r   rY  )r~   r   r   rc  r  kr   s          r/   r@  zAATLookup.readFormat0  sb    **,-	~~''I'V<EdOLO5!!!$e+OLLLs   A'c                    i }|j                   dz
  }|j                         |j                         }}|d| j                  j                  z   k\  sJ |       t	        |      D ]  }|j                  |||z  z   dz          |j                         }|j                         }	| j                  j                  ||d       }
|dk7  sat	        |	|dz         D ]  }|
||j                  |      <     |S )Nr  r      r   rs  r   r   r  r=  r   r   r   r   rY  )r~   r   r   mappingr   rX  rW  r   lastfirstr   r  s               r/   rA  zAATLookup.readFormat2  s    jj1n#..0&2C2C2E(1t~~8888B(B8xAKKa(l*R/0$$&D%%'ENN'''EEv~udQh/A49GD--a01 0 ! r1   c                 $   i }|j                   dz
  }|j                         }|dk\  sJ |       t        |j                               D ]  }|j                  |||z  z   dz          |j                         }|j                         }|j                         }	|dk7  sS|j	                  d      }
|
j                  ||	z          | j
                  j                  |
|d ||z
  dz         }t        |      D ]  \  }}|||j                  ||z         <     |S )Nr  r?  r  rs  r   r   r  )	r   r  r   r   r  r=  r   r   rY  )r~   r   r   r  r   rX  r   r  r  r   
dataReaderr  r  r  s                 r/   rB  zAATLookup.readFormat4  s   jj1n$$&1}&h&}v((*+AKKa(l*R/0$$&D%%'E&&(Fv~#003
f-~~//D5L1<L 0  &dODAq<=GD--eai89 , , r1   c                    i }|j                   dz
  }|j                         }|d| j                  j                  z   k\  sJ |       t	        |j                               D ]d  }|j                  |||z  z   dz          |j                         }| j                  j                  ||d       }|dk7  sQ|||j                  |      <   f |S )Nr  r  r  rs  r  )	r~   r   r   r  r   rX  r   rp  r   s	            r/   rC  zAATLookup.readFormat6
  s    jj1n$$&1t~~8888B(B8v((*+AKKa(l*R/0'')GNN'''EE& 6;))'23 , r1   c                     |j                         }|j                         }| j                  j                  ||d |      }t        |      D ci c]  \  }}|j	                  ||z         | c}}S c c}}w r  )r  r=  r   r   rY  )r~   r   r   r  r   r  r  r   s           r/   rD  zAATLookup.readFormat8  sp    !!#!!#~~''E'RFOPToVo
E!!%!),e3oVVVs   A1c                     i }|D ]B  }t        |t              s|\  }}}|dk(  s | j                  j                  |||      ||d   <   D |S )NLookuprM  )r,   r-   r=  r   )	r~   r   r   r   r   r  r\   a
eltContents	            r/   r   zAATLookup.xmlRead  sW    G'5)&-#a8#(,(>(>q*d(SE!G*%	 
 r1   c           	         |j                  ||       |j                          t        |j                               D ](  \  }}| j                  j                  |||dd|fg       * |j                  |       |j                          y )Nr  rM  )r   r\   r   )begintagr   rG  r  r=  r   endtag)r~   r   r   r   r\   r   rM  s          r/   r   zAATLookup.xmlWrite&  s}    4'"5;;=1LE5NN##4u8WeDTCU $  2 	r1   r+   )rT   r   r   rl  r   r   r   r   r\  rI  r_  rJ  rj  rK  ry  rL  r}  r@  rA  rB  rC  rD  r   r   r   r1   r/   r9  r9  :  s}    EG 	C
@ ' '	

(.
.	
M
(Wr1   r9  c                   &    e Zd Zd ZddZd Zd Zy)AATLookupWithDataOffsetc                 \   |j                         }|j                         }|j                  |      }t        dd d t              }|j	                  |||      }i }	|j                         D ]@  \  }
}|j                  ||z         }| j                         }|j                  ||       ||	|
<   B |	S NDataOffsets)r   r  r9  r  r   r  rP   r  )r~   r   r   r   lookupOffset
dataOffsetlookupReaderlookupoffsetsresultrM  r   r  items                 r/   r   zAATLookupWithDataOffset.read9  s    '')%%'
**<8=$f=++lD)<$]]_ME6,,Vj-@AJ??$DNN:t, F5M	 -
 r1   Nc                 8   i i d}}}g }	t        ||j                        D ]s  }
t               }||
   j                  ||       |j	                         }|j                  |d       }|d k(  r&|}|t        |      z   }|||<   |	j                  |       |||
<   u |j                         }t        dd d t              }|j                  ||||d        |j                         }|j                  |d       |j                  |d       |	D ]  }|j                  |        y )Nr   )keyr  r   r  )rG  r_  r   ry   r  rQ   r  rV   r  r9  r  r   r  r  )r~   r   r   r   r   r   offsetByGlyphoffsetByDatadataLencompiledDatarM  r  r  r   lookupWriterr  
dataWriterds                     r/   r   zAATLookupWithDataOffset.writeG  s"    022qW|Et7E%I%L  D1'')D!%%dD1F~ !CI-%+T"##D)#)M%  8 **,=$f=\4M4H((*
\a8ZA6A  # r1   c                 X    t        dd d | j                        }|j                  |||      S r  )r9  rP   r   )r~   r   r   r   r  s        r/   r   zAATLookupWithDataOffset.xmlReadj  s)    =$dooF~~eWd33r1   c                 ^    t        dd d | j                        }|j                  |||||       y r  )r9  rP   r   )r~   r   r   r   r\   r   r  s          r/   r   z AATLookupWithDataOffset.xmlWriten  s*    =$dooF	4e<r1   r+   rT   r   r   r   r   r   r   r   r1   r/   r  r  8  s    !$F4=r1   r  c                       e Zd ZdddddZej	                         D  ci c]  \  }}||
 c}}} Zdddd	Zd
 Zd Zd Z	d Z
ddZyc c}}} w )MorxSubtableConverterLayoutOrderReversedLayoutOrderLogicalOrderReversedLogicalOrder))FF)TFFT)TTNrg   rA   c                :    t         j                  | |||||       y NrA   )rf   r   r}   s         r/   r   zMorxSubtableConverter.__init__~  s"    $Z[ 	 	
r1   c                 R    |dz  dk7  rd|_         y |dz  dk7  rd|_         y d|_         y )N    r   Any   Vertical
Horizontal)TextDirection)r~   rs  subtables      r/   "_setTextDirectionFromCoverageFlagsz8MorxSubtableConverter._setTextDirectionFromCoverageFlags  s2    DLQ%*H"dlq %/H"%1H"r1   c                    |j                   }t               }|j                         |_        |j	                         }|dz  dk7  |dz  dk7  f}| j
                  |   |_        | j                  ||       |j                         |_	        |xj                  |dz  dz  z  c_	        |j	                         |_
        |j                         |_        t        d   j                  |j                        }|J d|j                  z         |j                   |z
  }	|j                  |j                   |j                   |j                  z   |	z
   }
t        |
      |j                  |	z
  k(  sJ t!        |
|j"                        } |       |_        |j$                  j'                  ||       |j)                  ||j                  z          |S )Nr  r   r     morxz!unsupported 'morx' lookup type %s)r  tableTag)r   r!   r   r6   r0  _PROCESSING_ORDERSProcessingOrderr  r  Reservedr7   SubFeatureFlagsr   rQ   r  r  r   r  r<   r  r   )r~   r   r   r   r   r   rs  orderKeyrP   headerLengthr  	subReaders               r/   r   zMorxSubtableConverter.read  s   jjN))+  "T\a'%$,1)<= 33H=//q9&&(
	

us{r))
&&(",,. (,,Q[[9
K=KK5 zzC'{{6::

Q^^(Cl(RS4yANN\9999!tfooF	 l	i.C!..()r1   c                    |j                  ||       |j                          |j                  d|j                  z         |j                          |j	                  d|j
                         |j                          |j	                  d|j                         |j                          |j                  dk7  r0|j	                  dd|j                  z         |j                          |j                  d|j                  z         |j                          |j	                  d	d
|j                  z         |j                          |j                  j                  ||       |j                  |       |j                          y )NzStructLength=%dr  r   r  r   r  z0x%04xzMorphType=%dr  r  )r  r   rE  r6   r   r  r  r  r7   r  r<   r  r  r   s         r/   r   zMorxSubtableConverter.xmlWrite  s?   4'+e.@.@@AO53F3FG-U5J5JK>>Q
(U^^2KL.5??:;-X@U@U5UVi.r1   c                    t               }d}d|_        t        t        |      D ]  \  }}}|dk(  rEt	        |d         }|dz  dk7  |dz  dk7  f}	| j
                  |	   |_        | j                  ||       R|dk(  r7|d   |_        |j                  | j                  v rzJ d|j                  z         |dk(  r-|d   |_	        |j                  d	v rJ d
|j                  z         |dk(  rt	        |d         |_        |dk(  rt	        |d         |_
        |j                  d      r|j                  ||||       J |        |dz  dz  |j                  z  |_        |S )Nr   CoverageFlagsr   r  r  r  zunknown ProcessingOrder: %sr  >   r  r  r  zunknown TextDirection %sr  r  Morphr  )r!   r  rH  istupler   r  r  r  _PROCESSING_ORDERS_REVERSEDr  r  rH   r  )
r~   r   r   r   r   covFlagseltNameeltAttrsr  r  s
             r/   r   zMorxSubtableConverter.xmlRead  s   N
-3GW-E)GXz/)#HW$56%_2X_4JK$($;$;H$E!77!D--$,W$5!((D,L,LL 1A4E4EEL O+"*7"3*KK .@K J&%hw&78
--$,Xg->$?!!!'*		'8Z>%g%u1 .F2 n+ajj8
r1   c                 H   |j                   dz  dz	  }| j                  |j                     \  }}||j                  dk(  rdndz  }||rdndz  }||j                  dk(  rdndz  }||rdndz  }||_        t        |j                        }	|j                         }
d	|_        |j                   }|j                   d
z  |_         |j                  ||       ||_         |j                  |	   dk(  sJ |j                         |
z
  }t        j                  d|      |j                  |	<   y )Ni   r  r  r  r   r  r  r  r  rs  r  z>L)r  r  r  r  r  r  r  r  r6   ry   structpack)r~   r   r   r   r   r   r  reverseOrderlogicalOrderr  r  origReservedr  s                r/   r   zMorxSubtableConverter.write  s#   NNZ/B6%)%E%E!!&
"l 	E//:=D1DLDa/E//58Da?LDa/&&,,'%%'' ~~&0fd#%||K(,????%%'&0$*KKf$=[!r1   r+   )rT   r   r   r  r  r  r   r  r   r   r   r   )r   r  rN  s   000r/   r  r  s  sp     &,%, =O<T<T<V"W<VS38<V"W
" 

26(@>} #Xs   A
r  c                   z    e Zd ZdddZd Zd Zd Zd Zd Zdd
Z	d Z
d Zd Zd Zd Zd Zd Zd Zd Zd Zy	)	STXHeaderrg   rA   c                   t         j                  | |||||       t        | j                  t              sJ t        dd d t              | _        t        | j                  t              rt        dd d t              | _
        y d | _
        y )NrA   GlyphClassesPerGlyphLookup)rf   r   r<  rP   r   r9  r  classLookupr   rS  perGlyphLookupr}   s         r/   r   zSTXHeader.__init__  sv    $Z[ 	 	
 $//9555$^T4Hdoo'<="+,<dD'"RD"&Dr1   c                    t               }|j                  }|j                  d      }|j                  d      }|j                  d      }d }	d }
|j                         |_        |j                  ||j                         z          |j                  ||j                         z          |j                  ||j                         z          | j                  3|j                  d      }|j                  ||j                         z          t        | j                  t              r|j                  d      }	|	j                  ||j                         z          |j                  d      }|j                  ||j                         z          |j                  d      }
|
j                  ||j                         z          |
j                  |j                  z
  dz  }|dk\  sJ |j                  |      |_        | j                  |
|      |_        nMt        | j                  t              r3|j                  d      }	|	j                  ||j                         z          | j                  j!                  |||      |_        t%        |j                  |j                  z
  |j                  dz  z        }t'        |      D ]r  }t)               }|j*                  j-                  |       t'        |j                        D ]3  }|j/                         }| j1                  ||||	      |j2                  |<   5 t | j                  | j5                  ||      |_        |S )Nr   r  )r   r   r  r   GlyphClassCountr   r  r<  rP   r   r  LigComponents_readLigatures	Ligaturesr    r  r   r  r   r   r   StatesrV   r  _readTransitionTransitions_readPerGlyphLookupsPerGlyphLookups)r~   r   r   r   r  r   classTableReaderstateArrayReaderentryTableReaderactionReaderligaturesReaderperGlyphTableReaderligComponentReadernumLigComponents	numStates
stateIndexstate
glyphClass
entryIndexs                      r/   r   zSTXHeader.read   s   jj!..q1!..q1!..q1 & 0 0 2cF$4$4$667cF$4$4$667cF$4$4$667*"("5"5a"8$$S6+;+;+=%=>doo':;!..q1LcF$4$4$667!'!4!4Q!7##C&*:*:*<$<=$11!4O  v'7'7'9!9: / 3 36H6L6L LQRR#q((("4"D"DEU"VE"11/4HEO)=>!..q1LcF$4$4$667!--223CT9U!!$4$8$88U=R=RUV=VW
	  	*JJELL&#E$9$9:
-88:
040D0D$j$1!!*- ; + *$($=$=*D%E! r1   c                     | j                         }|j                  |j                  ||j                  z  z         }|j	                  |||       |S r+   )rP   r  r   r   r  )r~   r   r  r   r  
transitionentryReaders          r/   r  zSTXHeader._readTransition/  sO    __&
))JJj&;&;;;
 	[$=r1   c                     t        |j                        }||j                  z
  dz  }|j                  |j	                  |            S r0  )r  r  r   rV  r  )r~   r   r   limitnumLigatureGlyphss        r/   r  zSTXHeader._readLigatures7  sA    FKK "VZZ/A5$$V%;%;<M%NOOr1   c                 .   d}|j                   D ]  }|j                  j                         D ]d  }t        |t              s|j
                  dk7  rt        ||j
                  dz         }|j                  dk7  sLt        ||j                  dz         }f  |S )Nr   rs  r   )r  r  rR   r,   r   	MarkIndexmaxCurrentIndex)r~   r  
numLookupsr  r.   s        r/   _countPerGlyphLookupszSTXHeader._countPerGlyphLookups<  s    
 
\\E&&--/a!67{{f,%(Q[[1_%E
~~/%(Q^^a5G%H
 0 " r1   c                    |j                   }g }t        | j                  |            D ]a  }|j                  d      }|j	                  ||j                         z          |j                  | j                  j                  ||i              c |S r   )	r   r   r  r  r   r   rV   r  r   )r~   r  r   r   r   lookupsr  r  s           r/   r  zSTXHeader._readPerGlyphLookupsK  s~    jjt11%89A!..q1LcF$4$4$667NN4..33L$KL : r1   Nc                 d   t               }| j                  j                  ||||j                  d        t	        |j                         d      }t        |j                  j                               dz   }d}	| j                  |	dz  }	|	| j                  j                  z  }	| j                  j                  ||j                        \  }
}| j                  ||j                  ||      \  }}|	t        |      z   }|t        |      z   }|t        |      z   }t	        | j                  ||      d      }|
|t        |      z   }nd }d\  }}| j!                  ||      }| j#                  ||      }|,t        |      dk(  sJ |t        |
      z   }|t        |      z   }|j%                  |       |j%                  |	       |j%                  |       |j%                  |       | j                  |j%                  |       ||j%                  |       |"|j%                  |       |j%                  |       |j'                  |       |j'                  |       |j'                  |       |j'                  |       |
|j'                  |
       ||j'                  |       ||j'                  |       y y )N)r   r  r   r  r   )NNr   )r   r  r   r  r   r  r  rR   r  rP   actionHeaderSizecompileActionsr  _compileStatesr  _compilePerGlyphLookups_compileLigComponents_compileLigaturesr   r  )r~   r   r   r   r   r   glyphClassWriterglyphClassDataglyphClassCountglyphClassTableOffset
actionDataactionIndexstateArrayDataentryTableDatastateArrayOffsetentryTableOffsetperGlyphOffsetperGlyphDataactionOffsetligaturesOffsetligComponentsOffsetligComponentsDataligaturesDatas                          r/   r   zSTXHeader.writeT  s   (?dIu/A/At 	 	
 -88:A>e00779:Q> "*!Q&!!A!AA"&//"@"@u||"T
K)-)<)<%,,*
& 13~3FF+c..AA)C,??477tDaH!+c..AALL/9,, 66udC..ud;(|$)))".Z"@1C8I4JJO/*/0*+*+*n-#l+*12o.(((&!Z((./$]+ %r1   c           	      6   t               }g i }}|D ]  }t        |      D ]  }	|j                  |	   }
t               }|
j                  |||       |j	                         }t        |      |
j                  k(  s)J dt        |
      |
j                  t        |      fz         |j                  |      }|!t        |      }|||<   |j                  |       |j                  |         t        |j	                         d      }t        t        |      d      }||fS )Nz1%s has staticSize %d, but actually wrote %d bytesr   )r   r   r  ry   r  r  r   r  rQ   rV   r  r   r   )r~   r   statesr  r  stateArrayWriterentriesentryIDsr  r  r  entryWriter	entryDatar  r  r  s                   r/   r  zSTXHeader._compileStates  s   (?E#O4
"..z:
+o"";kB'224		Nj&;&;;I$))	NM ; &\\)4
%!$WJ*4HY'NN9- ,,Z8# 5 & -88:A>Yw/3~--r1   c                    | j                   y| j                  |      }t        |j                        |k(  sJ dt        |j                        |fz         t	               }|j                  D ]D  }|j                         }| j                   j                  ||i |d        |j                  |d       F |j                         S )Nr1   zVlen(AATStateTable.PerGlyphLookups) is %d, but the actions inside the table refer to %dr   r  )	r  r  r  r  r   r  r   r  r  )r~   r  r   r  r   r  r  s          r/   r  z!STXHeader._compilePerGlyphLookups  s    &//6
5(()Z7 	
;5(():67	
7
 ++F!..0L%%lD"fdK  ! < ,   ""r1   c                     t        |d      sy t               }|j                  D ]  }|j                  |        |j	                         S )Nr  )r   r   r  r  r  )r~   r  r   r   	components        r/   r  zSTXHeader._compileLigComponents  sC    uo.,,Iy) -  ""r1   c                     t        |d      sy t               }|j                  D ]"  }|j                  |j	                  |             $ |j                         S )Nr  )r   r   r  r  r_  r  )r~   r  r   r   	glyphNames        r/   r  zSTXHeader._compileLigatures  sJ    uk*Ity9: )  ""r1   c                 ^   |j                  ||       |j                          |j                  d|j                  z         |j                          t	        |j
                  j                               D ])  \  }}|j                  d||       |j                          + t        |j                        D ]  \  }}	|j                  d|       |j                          t	        |	j                  j                               D ]  \  }
}|j                  ||d|
id        |j                  d       |j                           t        |j                        D ]  \  }}|j                  d	|       |j                          t	        |j                               D ])  \  }}|j                  d
||       |j                          + |j                  d	       |j                           t        |d      r|j                  d       |j                          t        t        |d            D ])  \  }}|j                  d||       |j                          + |j                  d       |j                          | j!                  |||||       |j                  |       |j                          y )NzGlyphClassCount=%s
GlyphClassrM  r   State)indexonGlyphClass
Transition)r   r   r\   r  r  r  LigComponent)r1  r   )r  r   rE  r  rG  r  r  r   r   r  r  r  r  r  r   r  _xmlWriteLigatures)r~   r   r   r   r\   r   gklassr  r  r  transr   r  rM  rN  s                   r/   r   zSTXHeader.xmlWrite  sb   4'.1F1FFGu11779:HAuAUC ; "+5<<!8Jwj9%+E,=,=,C,C,E%F!
E):6%	   &G W% "9 #5#8#89IAv/q9$V\\^4
s##HE#E!!# 5 -. : 5/*/#GE?$CD3##N!3#G!!# E _-	4eDr1   c                 $   t        |d      sy |j                  d       |j                          t        t	        |d            D ])  \  }}|j                  d||       |j                          + |j                  d       |j                          y )Nr  Ligature)r1  rM  )r   r  r   r   r  r   r  )r~   r   r   r   r\   r   r   r6  s           r/   r5  zSTXHeader._xmlWriteLigatures  s    uk*;'ge[9:DAq
!1= ; 	%r1   c                 N   t               }t        t        |      D ]  \  }}}|dk(  r#|d   }|d   }	t        |	      |j                  |<   /|dk(  r/| j                  |||      }
|j                  j                  |
       c|dk(  r9| j                  j                  |||      }|j                  j                  |       |dk(  r| j                  |||      |_        |dk(  s| j                  |||      |_         t        |j                  j!                               dz   |_        |S )	Nr.  rM  r   r0  r  r  r  r   )r   rH  r  r   r  _xmlReadStater  rV   r  r   r  _xmlReadLigComponentsr  _xmlReadLigaturesr  r  rR   r  )r~   r   r   r   r  r  r  r  rM  r   r  r  s               r/   r   zSTXHeader.xmlRead  s!   -3GW-E)GXz,& ) ),4UO""5)G#**8ZF##E*,,,,44Xz4P%%,,V4O+&*&@&@j$'# K'"&"8"8:t"T! .F" !$E$6$6$=$=$? @1 Dr1   c                     t               }t        t        |      D ]M  \  }}}|dk(  st        |d         }| j	                         }	|	j                  ||||       |	|j                  |<   O |S )Nr3  r2  )r   rH  r  r   rP   r  r  )
r~   r   r   r   r  r  r  r  r  r  s
             r/   r<  zSTXHeader._xmlReadState  sp    
-3GW-E)GXz,&%h~&>?
!__.
""7Hj$G0:!!*- .F r1   c                     g }t        t        |      D ])  \  }}}|dk(  s|j                  t        |d                + |S )Nr4  r   )rH  r  rV   r   )r~   r   r   r   ligComponentsr  r  _eltContents           r/   r=  zSTXHeader._xmlReadLigComponents  sH    .4Wg.F*GX{.($$Xhw.?%@A /G r1   c                 p    g }t        t        |      D ]   \  }}}|dk(  s|j                  |d          " |S )Nr:  rM  )rH  r  rV   )r~   r   r   r   ligsr  r  rB  s           r/   r>  zSTXHeader._xmlReadLigatures  s@    .4Wg.F*GX{*$HW-. /G r1   r+   )rT   r   r   r   r   r  r  r  r  r   r  r  r  r  r   r5  r   r<  r=  r>  r   r1   r/   r  r    s^    EG 	'-^P
5,n.4# ##&P	,r1   r  c                   &    e Zd Zd ZddZd Zd Zy)CIDGlyphMapc                     |j                         }i }t        |j                  |            D ]  \  }}|dk7  s|j                  |      ||<   ! |S )Nrs  )r  r   r  rY  )r~   r   r   r   numCIDsr  cidrp  s           r/   r   zCIDGlyphMap.read(  sW    ##%%f&<&<W&EFLC& "//8s G r1   Nc                    |j                         D ci c]  \  }}||j                  |       }}}|rt        |      dz   nd}	|j                  |	       t	        |	      D ]#  }|j                  |j                  |d             % y c c}}w )Nr   r   rs  r  r_  r  r  r   rQ   )
r~   r   r   r   r   r   rI  rM  r  r   s
             r/   r   zCIDGlyphMap.write0  sz    ?D{{}M}edooe,,}M"'E
QQ5!<Cuyyf56   Ns   Bc                     i }t        t        |      D ].  \  }}}|dk(  s|d   j                         |t        |d         <   0 |S )NCIDrM  rI  )rH  r  stripr   r~   r   r   r   r  eNameeAttrs	_eContents           r/   r   zCIDGlyphMap.xmlRead7  sN    (.w(@$E69~28/2G2G2Ixu./ )A r1   c                 &   |j                  ||       |j                          t        |j                               D ]2  \  }}|	|dk7  s|j	                  d||       |j                          4 |j                  |       |j                          y )Nrs  rM  )rI  rM  r  r   rG  r  r   r  )r~   r   r   r   r\   r   rI  rM  s           r/   r   zCIDGlyphMap.xmlWrite>  s    4' /JC Uf_##Es%#@!!# 0 	r1   r+   r  r   r1   r/   rF  rF  '  s    7r1   rF  c                   &    e Zd Zd ZddZd Zd Zy)GlyphCIDMapc                 L   |j                         }|j                         }|j                  |      }|t        |      kD  r#t        j                  d|t        |      fz         i }t        t        t        |      t        |                  D ]  }||   }	|	dk7  s|	|||   <    |S )NzOGlyphCIDMap has %d elements, but the font has only %d glyphs; ignoring the restrs  )rb  r  r  r  rh  ri  r   min)
r~   r   r   r   
glyphOrderr   cidsr  rp  rI  s
             r/   r   zGlyphCIDMap.readJ  s    '')
!!#%%e,3z?"KK$',c*o&>?
 STC
O<=Gw-Cf}.1z'*+ > r1   Nc                 *   |j                         D ci c]  \  }}||dk7  r|j                  |      |  }}}|rt        |      dz   nd}	|j                  |	       t	        |	      D ]#  }
|j                  |j                  |
d             % y c c}}w )Nrs  r   r   rK  )r~   r   r   r   r   r   r6  rI  r  r   rp  s              r/   r   zGlyphCIDMap.write[  s      ++-
'33&= OOA#' 	 

 #(E
QQ5!U|Guyy&9: $
s   #Bc                 p    i }t        t        |      D ]   \  }}}|dk(  st        |d         ||d   <   " |S )NrM  r   rM  )rH  r  r   rO  s           r/   r   zGlyphCIDMap.xmlReadf  sE    (.w(@$E69~*26'?*Cvg' )A r1   c                 &   |j                  ||       |j                          t        |j                               D ]2  \  }}|	|dk7  s|j	                  d||       |j                          4 |j                  |       |j                          y )Nrs  rM  r/  rT  )r~   r   r   r   r\   r   rM  rI  s           r/   r   zGlyphCIDMap.xmlWritem  s    4' /JE33&=##Ec#B!!# 0 	r1   r+   r  r   r1   r/   rV  rV  I  s    "	;r1   rV  c                   &    e Zd Zd ZddZd Zd Zy)
DeltaValuec                 *   |d   }|d   }|d   }|dv sJ d       ||z
  dz   }d|z  }d|z  }	d|z  dz
  }
d|dz
  z  }g }d\  }}t        |      D ]A  }|dk(  r|j                         d	}}||z
  }||z	  |
z  }||z  r||	z
  }|j                  |       C |S )
N	StartSizeEndSizeDeltaFormatr   r  r9  illegal DeltaFormatr   )r   r   r   r  )r   r  rV   )r~   r   r   r   ra  rb  rc  nItemsnBitsminusOffsetmasksignMaskr_  tmpshiftr   r   s                    r/   r   zDeltaValue.ready  s    k*	I&.i'>)>>'9$q([ 5jU
a#

UvAz#..0"UEMEE\T)Ex+e$  r1   Nc                 $   |d   }|d   }|d   }|}	|dv sJ d       ||z
  dz   }
d|z  }t        |	      |
k(  sJ d|z  dz
  }d\  }}|	D ].  }||z
  }|||z  |z  z  }|dk(  s|j                  |       d\  }}0 |d	k7  r|j                  |       y y )
Nra  rb  rc  rd  re  r   )r   r  r   r  )r  r  )r~   r   r   r   r   r   ra  rb  rc  r_  rf  rg  ri  rk  rl  s                  r/   r   zDeltaValue.write  s    k*	I&.
i'>)>>'9$q([ :&(((U
a
UEEME%$,501Cz""3'"
U   B;s# r1   c                 T    |j                  ||d|fgz          |j                          y r   r   r   r   s         r/   r   zDeltaValue.xmlWrite  +    D%GU+;*<"<=r1   c                     t        |d         S r   r   r   s       r/   r   zDeltaValue.xmlRead      g''r1   r+   rT   r   r   r   r   r   r   r   r1   r/   r_  r_  x  s    .$*(r1   r_  c                       e Zd Zd ZddZy)VarIdxMapValuec                    |d   }|d   }d|dz  z   }d|z  dz
  }d|z
  }d|z
  }	d|dz  dz	  z   }
|j                   |j                  |j                  |j                  d	|
   } ||      D cg c]  }||z  |	z  ||z  z   c}S c c}w )
NEntryFormatrq   r   r  l    r  0   r   r   r  r9  r   r2  r  readUInt24Arrayr   )r~   r   r   r   fmtrf  	innerBits	innerMask	outerMask
outerShift	entrySizer   raws                r/   r   zVarIdxMapValue.read  s    &>*v&	)^q(	*	)^
#,1,-	$$%%%%$$	

 	 !(
( Y:-#	/B(
 	
 
s   ,BNc                 >   |d   }|}|d   j                  t        |             d|dz  z   }d|z  dz
  }	d|z
  }
d|dz  dz	  z   }|j                  |j                  |j                  |j
                  d|   } ||D cg c]  }|d	z  |
z	  ||	z  z   c}       y c c}w )
Nrx  rq   r   r  r  ry  r   rz  l      )setValuer  r6  r"  writeUInt24Arrayr  )r~   r   r   r   r   r   r}  r  r~  r  r  r  r   idxs                 r/   r   zVarIdxMapValue.write  s    &~''G5v&	)^q(	)^
#,1,-	%%&&&&%%	

 
 	 #"C #
2sYG"	
s   =Br+   r  r   r1   r/   rv  rv    s    
,
r1   rv  c                   &    e Zd Zd ZddZd Zd Zy)VarDataValuec                 P   g }|d   }|d   }t        |dz        }|dz  }|r|j                  |j                  }	}n|j                  |j                  }	}t	        ||      t        ||      }}
|j                   ||
             |j                   |	||
z
               ||kD  r||d = |S )Nrp   	NumShorts     )boolr   r  r(  rX  r  extend)r~   r   r   r   rR   regionCount	wordCount	longWordsreadBigArrayreadSmallArrayn1n2s               r/   r   zVarDataValue.read  s     01k*	 V+,	&	+1+?+?AVAV.L+1+@+@&BVBV.L[),c+y.IBl2&'nR"W-.{|$r1   Nc                 D   |d   }|d   }t        |dz        }|dz  }|j                  |j                  f|j                  |j                  fd|   \  }	}
t	        ||      t        ||      }} |	|d |         |
|||        ||kD  r|j                  dg||z
  z         y y )Nrp   r  r  r  r  r   )r  r  r,  r   rX  r  writeSmallArray)r~   r   r   r   rR   r   r  r  r  writeBigArrayr  r  r  s                r/   r   zVarDataValue.write  s     01k*	 V+,	&	 **F,A,AB((&*@*@A,
 ,(
 [),c+y.IBfSbk"r+./""A3"{*:#;< r1   c                 T    |j                  ||d|fgz          |j                          y r   ro  r   s         r/   r   zVarDataValue.xmlWrite  rp  r1   c                     t        |d         S r   rr  r   s       r/   r   zVarDataValue.xmlRead  rs  r1   r+   rt  r   r1   r/   r  r    s    .=&(r1   r  c                   &    e Zd Zd ZddZd Zd Zy)TupleValuesc                 4    t        j                  d |      d   S r   )r	   decompileDeltas_)r~   r  r   s      r/   r   zTupleValues.read  s    ..tT:1==r1   Nc                 >    t        t        j                  |            S r+   )bytesr	   compileDeltaValues_)r~   r   r   r   rR   r   s         r/   r   zTupleValues.write  s    ^77?@@r1   c                     t        |d         S r   rr  r   s       r/   r   zTupleValues.xmlRead  rs  r1   c                 T    |j                  ||d|fgz          |j                          y r   ro  r   s         r/   r   zTupleValues.xmlWrite  rp  r1   r+   r  r   r1   r/   r  r    s    >A(r1   r  c                   :    e Zd Z	 d	dddddZd Zd	dZd Zd Zy)
	CFF2IndexNrg   )	itemClassitemConverterClassrB   c                t    t         j                  | |||||       || _        | |       | _        y d | _        y r  )rf   r   
_itemClass
_converter)r~   r\   r]   r^   rP   r  r  rB   s           r/   r   zCFF2Index.__init__   sJ     	$Z[ 	 	
 $$6$B  	HL 	r1   c                     j                         dk(  rg S j                         d        }j                  duxr dkD  }|s |dz         }g }|j                  d      }j	                  |dz
         |D ]  }	||	k  sJ j	                  |	|z
        }
 j
                  0 j                         }|j                  |
j                         |}
n( j                   j                  j                  |
      }
|j                  |
       |	} |S  fd} |       }t        |gz        }|S )Nr   c                 f    | j                   | j                  | j                  | j                  d|   S )Nrz  r{  )r   offSizes     r/   getReadArrayz$CFF2Index.read.<locals>.getReadArray9  s:    (())))((	
  r1   Fr   r   c                      	j                         	j                  dz   z  z   dz
         
fd} | S )Nr   c                 r   	j                  | z  z           d      }	j                  |d   z          	j                  |d   |d   z
        }
j                  1
j                         }|j                  |	j                         |}|S 
j
                  
j
                  j                  |      }|S )Nr  r   r   )r   r  r  r  
localStater  r   )r   r  r  objdata_posr   r  
offset_posr   r   r~   s       r/   r   z8CFF2Index.read.<locals>.get_read_item.<locals>.read_item`  s    $$Z!g+%=>'lG$$X
%:;&//
WQZ0GHD2"oo/dD+2H2HI"  K 4#33D$?Kr1   r   )r   r  r  r   r   r   r   r  r  r   r~   s    @@@@r/   r   z%CFF2Index.read.<locals>.get_read_itemZ  sM    $kkm#ZZ
%g(==A(g>	    ! r1   )r   r0  r   popr  r  r  r  r  r   rV   r   )r~   r   r   r   r   r   r  r  
lastOffsetr   r  r  r   r   r   r   r  r  s   ```            @@@r/   r   zCFF2Index.read3  sG     "A:I""$	 !1	yy%3%!)	*GE QJOOJN+!!V+++v
':;??.//+CMM$f.?.?@D__0??//d;DT"#
 " L! !, &I)u,-A Hr1   c                    |}|j                  t        |             t        |      sy | j                  |D cg c]  }|j                  |       }}nF| j                  :t        |      D cg c]$  \  }}| j                  j                  |||||      & }}}|D cg c]  }t        |       }	}t        t        |	d            }	|	d   }
|
dk  rdn|
dk  rdn|
dk  rdnd	}|j                  |       |j                  |j                  |j                  |j                  d
|   } ||	       |D ]  }|j                  |        y c c}w c c}}w c c}w )Nr   )initialr%     i   r  i   r9  r   rz  )r   r  r  ry   r  r   r   rF  r&   r4  r6  r"  r  r  r  )r~   r   r   r   rR   r   r  r  r   r  r  r  r   s                r/   r   zCFF2Index.writew  sl   #e*%5z??&49:EDT\\$'EE:__(  )//GAt %%fdItQG/  
 *//3t9/z'156R[
 E!  7*Z)5KQR 	
 	'" %%&&&&%%	

 
 	7DT" 5 ;
 0s   E.)EEc                     | j                   &| j                         }|j                  d |||       |S | j                  | j                  j                  |||      S t	               r+   )r  r  r  r   r   )r~   r   r   r   r  s        r/   r   zCFF2Index.xmlRead  s[    ??&//#CKKeWd3J__(??**5'4@@%''r1   c           
         | j                   +t        |      D ]  \  }}|j                  ||d|fg|        y | j                  9t        |      D ]*  \  }}| j                  j	                  |||||d|fgz          , y t               )Nr1  )r  r   r  r  r   r   )r~   r   r   r   r\   r   r   r  s           r/   r   zCFF2Index.xmlWrite  s    ??&$U+4

9dgq\NDA ,__($U+4((tT47A,1G ,
 &''r1   r+   )rT   r   r   r   r   r   r   r   r   r1   r/   r  r    s3     
 
&BH##J(
(r1   r  c                       e Zd Zd Zy)
LookupFlagc                    |j                  ||d|fgz          g }|dz  r|j                  d       |dz  r|j                  d       |dz  r|j                  d       |dz  r|j                  d	       |d
z  r|j                  d       |dz  r|j                  d|dz	  z         |r |j                  dj                  |             |j	                          y )Nr   r   rightToLeftr  ignoreBaseGlyphsr   ignoreLigaturesr   ignoreMarksr  useMarkFilteringSeti   zmarkAttachmentType[%i]rp  )r   rV   rE  rq  r   rr  s          r/   r   zLookupFlag.xmlWrite  s    D%GU+;*<"<=4<LL'4<LL+,4<LL*+4<LL'4<LL./6>LL1UaZ@Achhuo.r1   NrF  r   r1   r/   r  r    s    r1   r  c                   B     e Zd ZeZ fdZed        Zed        Z xZ	S )
_UInt8Enumc                 D    | j                  t        | 	  |||            S r+   )	enumClassr  r   )r~   r   r   r   r  s       r/   r   z_UInt8Enum.read  s    ~~egl64CDDr1   c                 J    t        | j                  |j                               S r+   )r  r  upperr  s     r/   r   z_UInt8Enum.fromString  s    s}}ekkm44r1   c                 T    | j                  |      j                  j                         S r+   )r  r\   lowerr  s     r/   r   z_UInt8Enum.toString  s     }}U#((..00r1   )
rT   r   r   r   r  r   r  r   r   r  r  s   @r/   r  r    s6    IE 5 5 1 1r1   r  c                       e Zd ZeZy)r"   N)rT   r   r   _ExtendModer  r   r1   r/   r"   r"     s    Ir1   r"   c                       e Zd ZeZy)r#   N)rT   r   r   _CompositeModer  r   r1   r/   r#   r#     s    Ir1   r#   int8int16int32r8   r4   uint24r9   char64r  OffsetLOffsetOffset24	TupleList)r  VarCompositeGlyphList)r  c                 $    t        t        |       S N)rP   )r'   r9  Cs    r/   r0   r0         79;r1   c                 $    t        t        |       S r  )r'   r  r  s    r/   r0   r0     s    1HUV)Wr1   c                 $    t        t        |       S r  )r'   r  r  s    r/   r0   r0     r  r1   c                 $    t        t        |       S r  )r'   rS   r  s    r/   r0   r0     s    '%A6r1   c                 $    t        t        |       S r  )r'   r  r  s    r/   r0   r0     s    76a8r1   c                 $    t        t        |       S r  )r'   r  r  s    r/   r0   r0     s    WW;r1   )rF  rV  rC   rD   rE   r!   r9  r  r  OffsetTo	LOffsetToLOffset24To){fontTools.misc.fixedToolsr   r  r   r  r   r  r   r  r   r  r   r  %fontTools.ttLib.tables.TupleVariationr	   fontTools.misc.roundToolsr
   r   fontTools.misc.textToolsr   r   r   r   r   fontTools.misc.lazyToolsr   fontTools.ttLibr   r7  r   r   r   r   r   otTablesr   r   r   r   r   r   r   r    r!   r"   r  r#   r  r$   	itertoolsr%   r&   	functoolsr'   typesr(   r   r  typingr)   logging	getLoggerrT   rh  r  rd   objectrf   r   r   r   r   r   r  r	  r  r  r$  r.  r8  rB  rI   rJ   rK   rM  rS  ra  rd  rl  ru  rz  r  r  r  r  r  r  r  rN   rL   rS   r  r  r<   r:   r;   r=   r3   r.  r9  r  r  r  rF  rV  r_  rv  r  r  r  r  r  rM   r   r1   r/   <module>r     s1    A J M M - *     .  ! 	    g!
(=(@eF eP/- /"K { &8 & 'H '  e  !}e !'H ' (X ( &8 & 'H ' "X " (  	K 		[& 		K 	+ Ak A& 
V    . .0Z 0:N  n  >G >0% k 0[ >D4] D4N>v >6+F +DU e M MLu LG&( GLE L8( 8&+ 0t t|8=m 8=v|>M |>Bp pf	- D,- ,^2( 2(j-
] -
`0(= 0(f Q( Q(h *1 1 J 2
D2 U2 T	2
 U2 f2 f2 e2 f2 w2 2 w2 
32 w2 2  f!2" *#2$ U%2& w'2( U)2* ;+2, f-2. e/20 v122 324 ;526 *728 n92: L;2< *=2> *?2@ ]A2B C2D {CE2F WY:KLG2J !$!);W;68;c2 r1   