Add files using upload-large-folder tool

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/B_A_S_E_.py

@@ -0,0 +1,5 @@
+from .otBase import BaseTTXConverter
+
+
+class table_B_A_S_E_(BaseTTXConverter):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/C_F_F__2.py

@@ -0,0 +1,13 @@
+from io import BytesIO
+from fontTools.ttLib.tables.C_F_F_ import table_C_F_F_
+
+
+class table_C_F_F__2(table_C_F_F_):
+    def decompile(self, data, otFont):
+        self.cff.decompile(BytesIO(data), otFont, isCFF2=True)
+        assert len(self.cff) == 1, "can't deal with multi-font CFF tables."
+
+    def compile(self, otFont):
+        f = BytesIO()
+        self.cff.compile(f, otFont, isCFF2=True)
+        return f.getvalue()

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/C_O_L_R_.py

@@ -0,0 +1,157 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod
+
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+
+
+class table_C_O_L_R_(DefaultTable.DefaultTable):
+    """This table is structured so that you can treat it like a dictionary keyed by glyph name.
+
+    ``ttFont['COLR'][<glyphName>]`` will return the color layers for any glyph.
+
+    ``ttFont['COLR'][<glyphName>] = <value>`` will set the color layers for any glyph.
+    """
+
+    @staticmethod
+    def _decompileColorLayersV0(table):
+        if not table.LayerRecordArray:
+            return {}
+        colorLayerLists = {}
+        layerRecords = table.LayerRecordArray.LayerRecord
+        numLayerRecords = len(layerRecords)
+        for baseRec in table.BaseGlyphRecordArray.BaseGlyphRecord:
+            baseGlyph = baseRec.BaseGlyph
+            firstLayerIndex = baseRec.FirstLayerIndex
+            numLayers = baseRec.NumLayers
+            assert firstLayerIndex + numLayers <= numLayerRecords
+            layers = []
+            for i in range(firstLayerIndex, firstLayerIndex + numLayers):
+                layerRec = layerRecords[i]
+                layers.append(LayerRecord(layerRec.LayerGlyph, layerRec.PaletteIndex))
+            colorLayerLists[baseGlyph] = layers
+        return colorLayerLists
+
+    def _toOTTable(self, ttFont):
+        from . import otTables
+        from fontTools.colorLib.builder import populateCOLRv0
+
+        tableClass = getattr(otTables, self.tableTag)
+        table = tableClass()
+        table.Version = self.version
+
+        populateCOLRv0(
+            table,
+            {
+                baseGlyph: [(layer.name, layer.colorID) for layer in layers]
+                for baseGlyph, layers in self.ColorLayers.items()
+            },
+            glyphMap=ttFont.getReverseGlyphMap(rebuild=True),
+        )
+        return table
+
+    def decompile(self, data, ttFont):
+        from .otBase import OTTableReader
+        from . import otTables
+
+        # We use otData to decompile, but we adapt the decompiled otTables to the
+        # existing COLR v0 API for backward compatibility.
+        reader = OTTableReader(data, tableTag=self.tableTag)
+        tableClass = getattr(otTables, self.tableTag)
+        table = tableClass()
+        table.decompile(reader, ttFont)
+
+        self.version = table.Version
+        if self.version == 0:
+            self.ColorLayers = self._decompileColorLayersV0(table)
+        else:
+            # for new versions, keep the raw otTables around
+            self.table = table
+
+    def compile(self, ttFont):
+        from .otBase import OTTableWriter
+
+        if hasattr(self, "table"):
+            table = self.table
+        else:
+            table = self._toOTTable(ttFont)
+
+        writer = OTTableWriter(tableTag=self.tableTag)
+        table.compile(writer, ttFont)
+        return writer.getAllData()
+
+    def toXML(self, writer, ttFont):
+        if hasattr(self, "table"):
+            self.table.toXML2(writer, ttFont)
+        else:
+            writer.simpletag("version", value=self.version)
+            writer.newline()
+            for baseGlyph in sorted(self.ColorLayers.keys(), key=ttFont.getGlyphID):
+                writer.begintag("ColorGlyph", name=baseGlyph)
+                writer.newline()
+                for layer in self.ColorLayers[baseGlyph]:
+                    layer.toXML(writer, ttFont)
+                writer.endtag("ColorGlyph")
+                writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":  # old COLR v0 API
+            setattr(self, name, safeEval(attrs["value"]))
+        elif name == "ColorGlyph":
+            if not hasattr(self, "ColorLayers"):
+                self.ColorLayers = {}
+            glyphName = attrs["name"]
+            for element in content:
+                if isinstance(element, str):
+                    continue
+            layers = []
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                layer = LayerRecord()
+                layer.fromXML(element[0], element[1], element[2], ttFont)
+                layers.append(layer)
+            self.ColorLayers[glyphName] = layers
+        else:  # new COLR v1 API
+            from . import otTables
+
+            if not hasattr(self, "table"):
+                tableClass = getattr(otTables, self.tableTag)
+                self.table = tableClass()
+            self.table.fromXML(name, attrs, content, ttFont)
+            self.table.populateDefaults()
+            self.version = self.table.Version
+
+    def __getitem__(self, glyphName):
+        if not isinstance(glyphName, str):
+            raise TypeError(f"expected str, found {type(glyphName).__name__}")
+        return self.ColorLayers[glyphName]
+
+    def __setitem__(self, glyphName, value):
+        if not isinstance(glyphName, str):
+            raise TypeError(f"expected str, found {type(glyphName).__name__}")
+        if value is not None:
+            self.ColorLayers[glyphName] = value
+        elif glyphName in self.ColorLayers:
+            del self.ColorLayers[glyphName]
+
+    def __delitem__(self, glyphName):
+        del self.ColorLayers[glyphName]
+
+
+class LayerRecord(object):
+    def __init__(self, name=None, colorID=None):
+        self.name = name
+        self.colorID = colorID
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("layer", name=self.name, colorID=self.colorID)
+        writer.newline()
+
+    def fromXML(self, eltname, attrs, content, ttFont):
+        for name, value in attrs.items():
+            if name == "name":
+                setattr(self, name, value)
+            else:
+                setattr(self, name, safeEval(value))

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/C_P_A_L_.py

@@ -0,0 +1,296 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod
+
+from fontTools.misc.textTools import bytesjoin, safeEval
+from . import DefaultTable
+import array
+from collections import namedtuple
+import struct
+import sys
+
+
+class table_C_P_A_L_(DefaultTable.DefaultTable):
+    NO_NAME_ID = 0xFFFF
+    DEFAULT_PALETTE_TYPE = 0
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.palettes = []
+        self.paletteTypes = []
+        self.paletteLabels = []
+        self.paletteEntryLabels = []
+
+    def decompile(self, data, ttFont):
+        (
+            self.version,
+            self.numPaletteEntries,
+            numPalettes,
+            numColorRecords,
+            goffsetFirstColorRecord,
+        ) = struct.unpack(">HHHHL", data[:12])
+        assert (
+            self.version <= 1
+        ), "Version of CPAL table is higher than I know how to handle"
+        self.palettes = []
+        pos = 12
+        for i in range(numPalettes):
+            startIndex = struct.unpack(">H", data[pos : pos + 2])[0]
+            assert startIndex + self.numPaletteEntries <= numColorRecords
+            pos += 2
+            palette = []
+            ppos = goffsetFirstColorRecord + startIndex * 4
+            for j in range(self.numPaletteEntries):
+                palette.append(Color(*struct.unpack(">BBBB", data[ppos : ppos + 4])))
+                ppos += 4
+            self.palettes.append(palette)
+        if self.version == 0:
+            offsetToPaletteTypeArray = 0
+            offsetToPaletteLabelArray = 0
+            offsetToPaletteEntryLabelArray = 0
+        else:
+            pos = 12 + numPalettes * 2
+            (
+                offsetToPaletteTypeArray,
+                offsetToPaletteLabelArray,
+                offsetToPaletteEntryLabelArray,
+            ) = struct.unpack(">LLL", data[pos : pos + 12])
+        self.paletteTypes = self._decompileUInt32Array(
+            data,
+            offsetToPaletteTypeArray,
+            numPalettes,
+            default=self.DEFAULT_PALETTE_TYPE,
+        )
+        self.paletteLabels = self._decompileUInt16Array(
+            data, offsetToPaletteLabelArray, numPalettes, default=self.NO_NAME_ID
+        )
+        self.paletteEntryLabels = self._decompileUInt16Array(
+            data,
+            offsetToPaletteEntryLabelArray,
+            self.numPaletteEntries,
+            default=self.NO_NAME_ID,
+        )
+
+    def _decompileUInt16Array(self, data, offset, numElements, default=0):
+        if offset == 0:
+            return [default] * numElements
+        result = array.array("H", data[offset : offset + 2 * numElements])
+        if sys.byteorder != "big":
+            result.byteswap()
+        assert len(result) == numElements, result
+        return result.tolist()
+
+    def _decompileUInt32Array(self, data, offset, numElements, default=0):
+        if offset == 0:
+            return [default] * numElements
+        result = array.array("I", data[offset : offset + 4 * numElements])
+        if sys.byteorder != "big":
+            result.byteswap()
+        assert len(result) == numElements, result
+        return result.tolist()
+
+    def compile(self, ttFont):
+        colorRecordIndices, colorRecords = self._compileColorRecords()
+        paletteTypes = self._compilePaletteTypes()
+        paletteLabels = self._compilePaletteLabels()
+        paletteEntryLabels = self._compilePaletteEntryLabels()
+        numColorRecords = len(colorRecords) // 4
+        offsetToFirstColorRecord = 12 + len(colorRecordIndices)
+        if self.version >= 1:
+            offsetToFirstColorRecord += 12
+        header = struct.pack(
+            ">HHHHL",
+            self.version,
+            self.numPaletteEntries,
+            len(self.palettes),
+            numColorRecords,
+            offsetToFirstColorRecord,
+        )
+        if self.version == 0:
+            dataList = [header, colorRecordIndices, colorRecords]
+        else:
+            pos = offsetToFirstColorRecord + len(colorRecords)
+            if len(paletteTypes) == 0:
+                offsetToPaletteTypeArray = 0
+            else:
+                offsetToPaletteTypeArray = pos
+                pos += len(paletteTypes)
+            if len(paletteLabels) == 0:
+                offsetToPaletteLabelArray = 0
+            else:
+                offsetToPaletteLabelArray = pos
+                pos += len(paletteLabels)
+            if len(paletteEntryLabels) == 0:
+                offsetToPaletteEntryLabelArray = 0
+            else:
+                offsetToPaletteEntryLabelArray = pos
+                pos += len(paletteLabels)
+            header1 = struct.pack(
+                ">LLL",
+                offsetToPaletteTypeArray,
+                offsetToPaletteLabelArray,
+                offsetToPaletteEntryLabelArray,
+            )
+            dataList = [
+                header,
+                colorRecordIndices,
+                header1,
+                colorRecords,
+                paletteTypes,
+                paletteLabels,
+                paletteEntryLabels,
+            ]
+        return bytesjoin(dataList)
+
+    def _compilePalette(self, palette):
+        assert len(palette) == self.numPaletteEntries
+        pack = lambda c: struct.pack(">BBBB", c.blue, c.green, c.red, c.alpha)
+        return bytesjoin([pack(color) for color in palette])
+
+    def _compileColorRecords(self):
+        colorRecords, colorRecordIndices, pool = [], [], {}
+        for palette in self.palettes:
+            packedPalette = self._compilePalette(palette)
+            if packedPalette in pool:
+                index = pool[packedPalette]
+            else:
+                index = len(colorRecords)
+                colorRecords.append(packedPalette)
+                pool[packedPalette] = index
+            colorRecordIndices.append(struct.pack(">H", index * self.numPaletteEntries))
+        return bytesjoin(colorRecordIndices), bytesjoin(colorRecords)
+
+    def _compilePaletteTypes(self):
+        if self.version == 0 or not any(self.paletteTypes):
+            return b""
+        assert len(self.paletteTypes) == len(self.palettes)
+        result = bytesjoin([struct.pack(">I", ptype) for ptype in self.paletteTypes])
+        assert len(result) == 4 * len(self.palettes)
+        return result
+
+    def _compilePaletteLabels(self):
+        if self.version == 0 or all(l == self.NO_NAME_ID for l in self.paletteLabels):
+            return b""
+        assert len(self.paletteLabels) == len(self.palettes)
+        result = bytesjoin([struct.pack(">H", label) for label in self.paletteLabels])
+        assert len(result) == 2 * len(self.palettes)
+        return result
+
+    def _compilePaletteEntryLabels(self):
+        if self.version == 0 or all(
+            l == self.NO_NAME_ID for l in self.paletteEntryLabels
+        ):
+            return b""
+        assert len(self.paletteEntryLabels) == self.numPaletteEntries
+        result = bytesjoin(
+            [struct.pack(">H", label) for label in self.paletteEntryLabels]
+        )
+        assert len(result) == 2 * self.numPaletteEntries
+        return result
+
+    def toXML(self, writer, ttFont):
+        numPalettes = len(self.palettes)
+        paletteLabels = {i: nameID for (i, nameID) in enumerate(self.paletteLabels)}
+        paletteTypes = {i: typ for (i, typ) in enumerate(self.paletteTypes)}
+        writer.simpletag("version", value=self.version)
+        writer.newline()
+        writer.simpletag("numPaletteEntries", value=self.numPaletteEntries)
+        writer.newline()
+        for index, palette in enumerate(self.palettes):
+            attrs = {"index": index}
+            paletteType = paletteTypes.get(index, self.DEFAULT_PALETTE_TYPE)
+            paletteLabel = paletteLabels.get(index, self.NO_NAME_ID)
+            if self.version > 0 and paletteLabel != self.NO_NAME_ID:
+                attrs["label"] = paletteLabel
+            if self.version > 0 and paletteType != self.DEFAULT_PALETTE_TYPE:
+                attrs["type"] = paletteType
+            writer.begintag("palette", **attrs)
+            writer.newline()
+            if (
+                self.version > 0
+                and paletteLabel != self.NO_NAME_ID
+                and ttFont
+                and "name" in ttFont
+            ):
+                name = ttFont["name"].getDebugName(paletteLabel)
+                if name is not None:
+                    writer.comment(name)
+                    writer.newline()
+            assert len(palette) == self.numPaletteEntries
+            for cindex, color in enumerate(palette):
+                color.toXML(writer, ttFont, cindex)
+            writer.endtag("palette")
+            writer.newline()
+        if self.version > 0 and not all(
+            l == self.NO_NAME_ID for l in self.paletteEntryLabels
+        ):
+            writer.begintag("paletteEntryLabels")
+            writer.newline()
+            for index, label in enumerate(self.paletteEntryLabels):
+                if label != self.NO_NAME_ID:
+                    writer.simpletag("label", index=index, value=label)
+                    if self.version > 0 and label and ttFont and "name" in ttFont:
+                        name = ttFont["name"].getDebugName(label)
+                        if name is not None:
+                            writer.comment(name)
+                    writer.newline()
+            writer.endtag("paletteEntryLabels")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "palette":
+            self.paletteLabels.append(int(attrs.get("label", self.NO_NAME_ID)))
+            self.paletteTypes.append(int(attrs.get("type", self.DEFAULT_PALETTE_TYPE)))
+            palette = []
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                attrs = element[1]
+                color = Color.fromHex(attrs["value"])
+                palette.append(color)
+            self.palettes.append(palette)
+        elif name == "paletteEntryLabels":
+            colorLabels = {}
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                elementName, elementAttr, _ = element
+                if elementName == "label":
+                    labelIndex = safeEval(elementAttr["index"])
+                    nameID = safeEval(elementAttr["value"])
+                    colorLabels[labelIndex] = nameID
+            self.paletteEntryLabels = [
+                colorLabels.get(i, self.NO_NAME_ID)
+                for i in range(self.numPaletteEntries)
+            ]
+        elif "value" in attrs:
+            value = safeEval(attrs["value"])
+            setattr(self, name, value)
+            if name == "numPaletteEntries":
+                self.paletteEntryLabels = [self.NO_NAME_ID] * self.numPaletteEntries
+
+
+class Color(namedtuple("Color", "blue green red alpha")):
+    def hex(self):
+        return "#%02X%02X%02X%02X" % (self.red, self.green, self.blue, self.alpha)
+
+    def __repr__(self):
+        return self.hex()
+
+    def toXML(self, writer, ttFont, index=None):
+        writer.simpletag("color", value=self.hex(), index=index)
+        writer.newline()
+
+    @classmethod
+    def fromHex(cls, value):
+        if value[0] == "#":
+            value = value[1:]
+        red = int(value[0:2], 16)
+        green = int(value[2:4], 16)
+        blue = int(value[4:6], 16)
+        alpha = int(value[6:8], 16) if len(value) >= 8 else 0xFF
+        return cls(red=red, green=green, blue=blue, alpha=alpha)
+
+    @classmethod
+    def fromRGBA(cls, red, green, blue, alpha):
+        return cls(red=red, green=green, blue=blue, alpha=alpha)

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/D__e_b_g.py

@@ -0,0 +1,17 @@
+import json
+
+from . import DefaultTable
+
+
+class table_D__e_b_g(DefaultTable.DefaultTable):
+    def decompile(self, data, ttFont):
+        self.data = json.loads(data)
+
+    def compile(self, ttFont):
+        return json.dumps(self.data).encode("utf-8")
+
+    def toXML(self, writer, ttFont):
+        writer.writecdata(json.dumps(self.data, indent=2))
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.data = json.loads(content)

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/E_B_D_T_.py

@@ -0,0 +1,827 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import (
+    bytechr,
+    byteord,
+    bytesjoin,
+    strjoin,
+    safeEval,
+    readHex,
+    hexStr,
+    deHexStr,
+)
+from .BitmapGlyphMetrics import (
+    BigGlyphMetrics,
+    bigGlyphMetricsFormat,
+    SmallGlyphMetrics,
+    smallGlyphMetricsFormat,
+)
+from . import DefaultTable
+import itertools
+import os
+import struct
+import logging
+
+
+log = logging.getLogger(__name__)
+
+ebdtTableVersionFormat = """
+	> # big endian
+	version: 16.16F
+"""
+
+ebdtComponentFormat = """
+	> # big endian
+	glyphCode: H
+	xOffset:   b
+	yOffset:   b
+"""
+
+
+class table_E_B_D_T_(DefaultTable.DefaultTable):
+    # Keep a reference to the name of the data locator table.
+    locatorName = "EBLC"
+
+    # This method can be overridden in subclasses to support new formats
+    # without changing the other implementation. Also can be used as a
+    # convenience method for coverting a font file to an alternative format.
+    def getImageFormatClass(self, imageFormat):
+        return ebdt_bitmap_classes[imageFormat]
+
+    def decompile(self, data, ttFont):
+        # Get the version but don't advance the slice.
+        # Most of the lookup for this table is done relative
+        # to the begining so slice by the offsets provided
+        # in the EBLC table.
+        sstruct.unpack2(ebdtTableVersionFormat, data, self)
+
+        # Keep a dict of glyphs that have been seen so they aren't remade.
+        # This dict maps intervals of data to the BitmapGlyph.
+        glyphDict = {}
+
+        # Pull out the EBLC table and loop through glyphs.
+        # A strike is a concept that spans both tables.
+        # The actual bitmap data is stored in the EBDT.
+        locator = ttFont[self.__class__.locatorName]
+        self.strikeData = []
+        for curStrike in locator.strikes:
+            bitmapGlyphDict = {}
+            self.strikeData.append(bitmapGlyphDict)
+            for indexSubTable in curStrike.indexSubTables:
+                dataIter = zip(indexSubTable.names, indexSubTable.locations)
+                for curName, curLoc in dataIter:
+                    # Don't create duplicate data entries for the same glyphs.
+                    # Instead just use the structures that already exist if they exist.
+                    if curLoc in glyphDict:
+                        curGlyph = glyphDict[curLoc]
+                    else:
+                        curGlyphData = data[slice(*curLoc)]
+                        imageFormatClass = self.getImageFormatClass(
+                            indexSubTable.imageFormat
+                        )
+                        curGlyph = imageFormatClass(curGlyphData, ttFont)
+                        glyphDict[curLoc] = curGlyph
+                    bitmapGlyphDict[curName] = curGlyph
+
+    def compile(self, ttFont):
+        dataList = []
+        dataList.append(sstruct.pack(ebdtTableVersionFormat, self))
+        dataSize = len(dataList[0])
+
+        # Keep a dict of glyphs that have been seen so they aren't remade.
+        # This dict maps the id of the BitmapGlyph to the interval
+        # in the data.
+        glyphDict = {}
+
+        # Go through the bitmap glyph data. Just in case the data for a glyph
+        # changed the size metrics should be recalculated. There are a variety
+        # of formats and they get stored in the EBLC table. That is why
+        # recalculation is defered to the EblcIndexSubTable class and just
+        # pass what is known about bitmap glyphs from this particular table.
+        locator = ttFont[self.__class__.locatorName]
+        for curStrike, curGlyphDict in zip(locator.strikes, self.strikeData):
+            for curIndexSubTable in curStrike.indexSubTables:
+                dataLocations = []
+                for curName in curIndexSubTable.names:
+                    # Handle the data placement based on seeing the glyph or not.
+                    # Just save a reference to the location if the glyph has already
+                    # been saved in compile. This code assumes that glyphs will only
+                    # be referenced multiple times from indexFormat5. By luck the
+                    # code may still work when referencing poorly ordered fonts with
+                    # duplicate references. If there is a font that is unlucky the
+                    # respective compile methods for the indexSubTables will fail
+                    # their assertions. All fonts seem to follow this assumption.
+                    # More complicated packing may be needed if a counter-font exists.
+                    glyph = curGlyphDict[curName]
+                    objectId = id(glyph)
+                    if objectId not in glyphDict:
+                        data = glyph.compile(ttFont)
+                        data = curIndexSubTable.padBitmapData(data)
+                        startByte = dataSize
+                        dataSize += len(data)
+                        endByte = dataSize
+                        dataList.append(data)
+                        dataLoc = (startByte, endByte)
+                        glyphDict[objectId] = dataLoc
+                    else:
+                        dataLoc = glyphDict[objectId]
+                    dataLocations.append(dataLoc)
+                # Just use the new data locations in the indexSubTable.
+                # The respective compile implementations will take care
+                # of any of the problems in the convertion that may arise.
+                curIndexSubTable.locations = dataLocations
+
+        return bytesjoin(dataList)
+
+    def toXML(self, writer, ttFont):
+        # When exporting to XML if one of the data export formats
+        # requires metrics then those metrics may be in the locator.
+        # In this case populate the bitmaps with "export metrics".
+        if ttFont.bitmapGlyphDataFormat in ("row", "bitwise"):
+            locator = ttFont[self.__class__.locatorName]
+            for curStrike, curGlyphDict in zip(locator.strikes, self.strikeData):
+                for curIndexSubTable in curStrike.indexSubTables:
+                    for curName in curIndexSubTable.names:
+                        glyph = curGlyphDict[curName]
+                        # I'm not sure which metrics have priority here.
+                        # For now if both metrics exist go with glyph metrics.
+                        if hasattr(glyph, "metrics"):
+                            glyph.exportMetrics = glyph.metrics
+                        else:
+                            glyph.exportMetrics = curIndexSubTable.metrics
+                        glyph.exportBitDepth = curStrike.bitmapSizeTable.bitDepth
+
+        writer.simpletag("header", [("version", self.version)])
+        writer.newline()
+        locator = ttFont[self.__class__.locatorName]
+        for strikeIndex, bitmapGlyphDict in enumerate(self.strikeData):
+            writer.begintag("strikedata", [("index", strikeIndex)])
+            writer.newline()
+            for curName, curBitmap in bitmapGlyphDict.items():
+                curBitmap.toXML(strikeIndex, curName, writer, ttFont)
+            writer.endtag("strikedata")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "header":
+            self.version = safeEval(attrs["version"])
+        elif name == "strikedata":
+            if not hasattr(self, "strikeData"):
+                self.strikeData = []
+            strikeIndex = safeEval(attrs["index"])
+
+            bitmapGlyphDict = {}
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content = element
+                if name[4:].startswith(_bitmapGlyphSubclassPrefix[4:]):
+                    imageFormat = safeEval(name[len(_bitmapGlyphSubclassPrefix) :])
+                    glyphName = attrs["name"]
+                    imageFormatClass = self.getImageFormatClass(imageFormat)
+                    curGlyph = imageFormatClass(None, None)
+                    curGlyph.fromXML(name, attrs, content, ttFont)
+                    assert glyphName not in bitmapGlyphDict, (
+                        "Duplicate glyphs with the same name '%s' in the same strike."
+                        % glyphName
+                    )
+                    bitmapGlyphDict[glyphName] = curGlyph
+                else:
+                    log.warning("%s being ignored by %s", name, self.__class__.__name__)
+
+            # Grow the strike data array to the appropriate size. The XML
+            # format allows the strike index value to be out of order.
+            if strikeIndex >= len(self.strikeData):
+                self.strikeData += [None] * (strikeIndex + 1 - len(self.strikeData))
+            assert (
+                self.strikeData[strikeIndex] is None
+            ), "Duplicate strike EBDT indices."
+            self.strikeData[strikeIndex] = bitmapGlyphDict
+
+
+class EbdtComponent(object):
+    def toXML(self, writer, ttFont):
+        writer.begintag("ebdtComponent", [("name", self.name)])
+        writer.newline()
+        for componentName in sstruct.getformat(ebdtComponentFormat)[1][1:]:
+            writer.simpletag(componentName, value=getattr(self, componentName))
+            writer.newline()
+        writer.endtag("ebdtComponent")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.name = attrs["name"]
+        componentNames = set(sstruct.getformat(ebdtComponentFormat)[1][1:])
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            if name in componentNames:
+                vars(self)[name] = safeEval(attrs["value"])
+            else:
+                log.warning("unknown name '%s' being ignored by EbdtComponent.", name)
+
+
+# Helper functions for dealing with binary.
+
+
+def _data2binary(data, numBits):
+    binaryList = []
+    for curByte in data:
+        value = byteord(curByte)
+        numBitsCut = min(8, numBits)
+        for i in range(numBitsCut):
+            if value & 0x1:
+                binaryList.append("1")
+            else:
+                binaryList.append("0")
+            value = value >> 1
+        numBits -= numBitsCut
+    return strjoin(binaryList)
+
+
+def _binary2data(binary):
+    byteList = []
+    for bitLoc in range(0, len(binary), 8):
+        byteString = binary[bitLoc : bitLoc + 8]
+        curByte = 0
+        for curBit in reversed(byteString):
+            curByte = curByte << 1
+            if curBit == "1":
+                curByte |= 1
+        byteList.append(bytechr(curByte))
+    return bytesjoin(byteList)
+
+
+def _memoize(f):
+    class memodict(dict):
+        def __missing__(self, key):
+            ret = f(key)
+            if isinstance(key, int) or len(key) == 1:
+                self[key] = ret
+            return ret
+
+    return memodict().__getitem__
+
+
+# 00100111 -> 11100100 per byte, not to be confused with little/big endian.
+# Bitmap data per byte is in the order that binary is written on the page
+# with the least significant bit as far right as possible. This is the
+# opposite of what makes sense algorithmically and hence this function.
+@_memoize
+def _reverseBytes(data):
+    r"""
+    >>> bin(ord(_reverseBytes(0b00100111)))
+    '0b11100100'
+    >>> _reverseBytes(b'\x00\xf0')
+    b'\x00\x0f'
+    """
+    if isinstance(data, bytes) and len(data) != 1:
+        return bytesjoin(map(_reverseBytes, data))
+    byte = byteord(data)
+    result = 0
+    for i in range(8):
+        result = result << 1
+        result |= byte & 1
+        byte = byte >> 1
+    return bytechr(result)
+
+
+# This section of code is for reading and writing image data to/from XML.
+
+
+def _writeRawImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
+    writer.begintag("rawimagedata")
+    writer.newline()
+    writer.dumphex(bitmapObject.imageData)
+    writer.endtag("rawimagedata")
+    writer.newline()
+
+
+def _readRawImageData(bitmapObject, name, attrs, content, ttFont):
+    bitmapObject.imageData = readHex(content)
+
+
+def _writeRowImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
+    metrics = bitmapObject.exportMetrics
+    del bitmapObject.exportMetrics
+    bitDepth = bitmapObject.exportBitDepth
+    del bitmapObject.exportBitDepth
+
+    writer.begintag(
+        "rowimagedata", bitDepth=bitDepth, width=metrics.width, height=metrics.height
+    )
+    writer.newline()
+    for curRow in range(metrics.height):
+        rowData = bitmapObject.getRow(curRow, bitDepth=bitDepth, metrics=metrics)
+        writer.simpletag("row", value=hexStr(rowData))
+        writer.newline()
+    writer.endtag("rowimagedata")
+    writer.newline()
+
+
+def _readRowImageData(bitmapObject, name, attrs, content, ttFont):
+    bitDepth = safeEval(attrs["bitDepth"])
+    metrics = SmallGlyphMetrics()
+    metrics.width = safeEval(attrs["width"])
+    metrics.height = safeEval(attrs["height"])
+
+    dataRows = []
+    for element in content:
+        if not isinstance(element, tuple):
+            continue
+        name, attr, content = element
+        # Chop off 'imagedata' from the tag to get just the option.
+        if name == "row":
+            dataRows.append(deHexStr(attr["value"]))
+    bitmapObject.setRows(dataRows, bitDepth=bitDepth, metrics=metrics)
+
+
+def _writeBitwiseImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
+    metrics = bitmapObject.exportMetrics
+    del bitmapObject.exportMetrics
+    bitDepth = bitmapObject.exportBitDepth
+    del bitmapObject.exportBitDepth
+
+    # A dict for mapping binary to more readable/artistic ASCII characters.
+    binaryConv = {"0": ".", "1": "@"}
+
+    writer.begintag(
+        "bitwiseimagedata",
+        bitDepth=bitDepth,
+        width=metrics.width,
+        height=metrics.height,
+    )
+    writer.newline()
+    for curRow in range(metrics.height):
+        rowData = bitmapObject.getRow(
+            curRow, bitDepth=1, metrics=metrics, reverseBytes=True
+        )
+        rowData = _data2binary(rowData, metrics.width)
+        # Make the output a readable ASCII art form.
+        rowData = strjoin(map(binaryConv.get, rowData))
+        writer.simpletag("row", value=rowData)
+        writer.newline()
+    writer.endtag("bitwiseimagedata")
+    writer.newline()
+
+
+def _readBitwiseImageData(bitmapObject, name, attrs, content, ttFont):
+    bitDepth = safeEval(attrs["bitDepth"])
+    metrics = SmallGlyphMetrics()
+    metrics.width = safeEval(attrs["width"])
+    metrics.height = safeEval(attrs["height"])
+
+    # A dict for mapping from ASCII to binary. All characters are considered
+    # a '1' except space, period and '0' which maps to '0'.
+    binaryConv = {" ": "0", ".": "0", "0": "0"}
+
+    dataRows = []
+    for element in content:
+        if not isinstance(element, tuple):
+            continue
+        name, attr, content = element
+        if name == "row":
+            mapParams = zip(attr["value"], itertools.repeat("1"))
+            rowData = strjoin(itertools.starmap(binaryConv.get, mapParams))
+            dataRows.append(_binary2data(rowData))
+
+    bitmapObject.setRows(
+        dataRows, bitDepth=bitDepth, metrics=metrics, reverseBytes=True
+    )
+
+
+def _writeExtFileImageData(strikeIndex, glyphName, bitmapObject, writer, ttFont):
+    try:
+        folder = os.path.dirname(writer.file.name)
+    except AttributeError:
+        # fall back to current directory if output file's directory isn't found
+        folder = "."
+    folder = os.path.join(folder, "bitmaps")
+    filename = glyphName + bitmapObject.fileExtension
+    if not os.path.isdir(folder):
+        os.makedirs(folder)
+    folder = os.path.join(folder, "strike%d" % strikeIndex)
+    if not os.path.isdir(folder):
+        os.makedirs(folder)
+
+    fullPath = os.path.join(folder, filename)
+    writer.simpletag("extfileimagedata", value=fullPath)
+    writer.newline()
+
+    with open(fullPath, "wb") as file:
+        file.write(bitmapObject.imageData)
+
+
+def _readExtFileImageData(bitmapObject, name, attrs, content, ttFont):
+    fullPath = attrs["value"]
+    with open(fullPath, "rb") as file:
+        bitmapObject.imageData = file.read()
+
+
+# End of XML writing code.
+
+# Important information about the naming scheme. Used for identifying formats
+# in XML.
+_bitmapGlyphSubclassPrefix = "ebdt_bitmap_format_"
+
+
+class BitmapGlyph(object):
+    # For the external file format. This can be changed in subclasses. This way
+    # when the extfile option is turned on files have the form: glyphName.ext
+    # The default is just a flat binary file with no meaning.
+    fileExtension = ".bin"
+
+    # Keep track of reading and writing of various forms.
+    xmlDataFunctions = {
+        "raw": (_writeRawImageData, _readRawImageData),
+        "row": (_writeRowImageData, _readRowImageData),
+        "bitwise": (_writeBitwiseImageData, _readBitwiseImageData),
+        "extfile": (_writeExtFileImageData, _readExtFileImageData),
+    }
+
+    def __init__(self, data, ttFont):
+        self.data = data
+        self.ttFont = ttFont
+        # TODO Currently non-lazy decompilation is untested here...
+        # if not ttFont.lazy:
+        # 	self.decompile()
+        # 	del self.data
+
+    def __getattr__(self, attr):
+        # Allow lazy decompile.
+        if attr[:2] == "__":
+            raise AttributeError(attr)
+        if attr == "data":
+            raise AttributeError(attr)
+        self.decompile()
+        del self.data
+        return getattr(self, attr)
+
+    def ensureDecompiled(self, recurse=False):
+        if hasattr(self, "data"):
+            self.decompile()
+            del self.data
+
+    # Not a fan of this but it is needed for safer safety checking.
+    def getFormat(self):
+        return safeEval(self.__class__.__name__[len(_bitmapGlyphSubclassPrefix) :])
+
+    def toXML(self, strikeIndex, glyphName, writer, ttFont):
+        writer.begintag(self.__class__.__name__, [("name", glyphName)])
+        writer.newline()
+
+        self.writeMetrics(writer, ttFont)
+        # Use the internal write method to write using the correct output format.
+        self.writeData(strikeIndex, glyphName, writer, ttFont)
+
+        writer.endtag(self.__class__.__name__)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.readMetrics(name, attrs, content, ttFont)
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attr, content = element
+            if not name.endswith("imagedata"):
+                continue
+            # Chop off 'imagedata' from the tag to get just the option.
+            option = name[: -len("imagedata")]
+            assert option in self.__class__.xmlDataFunctions
+            self.readData(name, attr, content, ttFont)
+
+    # Some of the glyphs have the metrics. This allows for metrics to be
+    # added if the glyph format has them. Default behavior is to do nothing.
+    def writeMetrics(self, writer, ttFont):
+        pass
+
+    # The opposite of write metrics.
+    def readMetrics(self, name, attrs, content, ttFont):
+        pass
+
+    def writeData(self, strikeIndex, glyphName, writer, ttFont):
+        try:
+            writeFunc, readFunc = self.__class__.xmlDataFunctions[
+                ttFont.bitmapGlyphDataFormat
+            ]
+        except KeyError:
+            writeFunc = _writeRawImageData
+        writeFunc(strikeIndex, glyphName, self, writer, ttFont)
+
+    def readData(self, name, attrs, content, ttFont):
+        # Chop off 'imagedata' from the tag to get just the option.
+        option = name[: -len("imagedata")]
+        writeFunc, readFunc = self.__class__.xmlDataFunctions[option]
+        readFunc(self, name, attrs, content, ttFont)
+
+
+# A closure for creating a mixin for the two types of metrics handling.
+# Most of the code is very similar so its easier to deal with here.
+# Everything works just by passing the class that the mixin is for.
+def _createBitmapPlusMetricsMixin(metricsClass):
+    # Both metrics names are listed here to make meaningful error messages.
+    metricStrings = [BigGlyphMetrics.__name__, SmallGlyphMetrics.__name__]
+    curMetricsName = metricsClass.__name__
+    # Find which metrics this is for and determine the opposite name.
+    metricsId = metricStrings.index(curMetricsName)
+    oppositeMetricsName = metricStrings[1 - metricsId]
+
+    class BitmapPlusMetricsMixin(object):
+        def writeMetrics(self, writer, ttFont):
+            self.metrics.toXML(writer, ttFont)
+
+        def readMetrics(self, name, attrs, content, ttFont):
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                name, attrs, content = element
+                if name == curMetricsName:
+                    self.metrics = metricsClass()
+                    self.metrics.fromXML(name, attrs, content, ttFont)
+                elif name == oppositeMetricsName:
+                    log.warning(
+                        "Warning: %s being ignored in format %d.",
+                        oppositeMetricsName,
+                        self.getFormat(),
+                    )
+
+    return BitmapPlusMetricsMixin
+
+
+# Since there are only two types of mixin's just create them here.
+BitmapPlusBigMetricsMixin = _createBitmapPlusMetricsMixin(BigGlyphMetrics)
+BitmapPlusSmallMetricsMixin = _createBitmapPlusMetricsMixin(SmallGlyphMetrics)
+
+
+# Data that is bit aligned can be tricky to deal with. These classes implement
+# helper functionality for dealing with the data and getting a particular row
+# of bitwise data. Also helps implement fancy data export/import in XML.
+class BitAlignedBitmapMixin(object):
+    def _getBitRange(self, row, bitDepth, metrics):
+        rowBits = bitDepth * metrics.width
+        bitOffset = row * rowBits
+        return (bitOffset, bitOffset + rowBits)
+
+    def getRow(self, row, bitDepth=1, metrics=None, reverseBytes=False):
+        if metrics is None:
+            metrics = self.metrics
+        assert 0 <= row and row < metrics.height, "Illegal row access in bitmap"
+
+        # Loop through each byte. This can cover two bytes in the original data or
+        # a single byte if things happen to be aligned. The very last entry might
+        # not be aligned so take care to trim the binary data to size and pad with
+        # zeros in the row data. Bit aligned data is somewhat tricky.
+        #
+        # Example of data cut. Data cut represented in x's.
+        # '|' represents byte boundary.
+        # data = ...0XX|XXXXXX00|000... => XXXXXXXX
+        # 		or
+        # data = ...0XX|XXXX0000|000... => XXXXXX00
+        #   or
+        # data = ...000|XXXXXXXX|000... => XXXXXXXX
+        #   or
+        # data = ...000|00XXXX00|000... => XXXX0000
+        #
+        dataList = []
+        bitRange = self._getBitRange(row, bitDepth, metrics)
+        stepRange = bitRange + (8,)
+        for curBit in range(*stepRange):
+            endBit = min(curBit + 8, bitRange[1])
+            numBits = endBit - curBit
+            cutPoint = curBit % 8
+            firstByteLoc = curBit // 8
+            secondByteLoc = endBit // 8
+            if firstByteLoc < secondByteLoc:
+                numBitsCut = 8 - cutPoint
+            else:
+                numBitsCut = endBit - curBit
+            curByte = _reverseBytes(self.imageData[firstByteLoc])
+            firstHalf = byteord(curByte) >> cutPoint
+            firstHalf = ((1 << numBitsCut) - 1) & firstHalf
+            newByte = firstHalf
+            if firstByteLoc < secondByteLoc and secondByteLoc < len(self.imageData):
+                curByte = _reverseBytes(self.imageData[secondByteLoc])
+                secondHalf = byteord(curByte) << numBitsCut
+                newByte = (firstHalf | secondHalf) & ((1 << numBits) - 1)
+            dataList.append(bytechr(newByte))
+
+        # The way the data is kept is opposite the algorithm used.
+        data = bytesjoin(dataList)
+        if not reverseBytes:
+            data = _reverseBytes(data)
+        return data
+
+    def setRows(self, dataRows, bitDepth=1, metrics=None, reverseBytes=False):
+        if metrics is None:
+            metrics = self.metrics
+        if not reverseBytes:
+            dataRows = list(map(_reverseBytes, dataRows))
+
+        # Keep track of a list of ordinal values as they are easier to modify
+        # than a list of strings. Map to actual strings later.
+        numBytes = (self._getBitRange(len(dataRows), bitDepth, metrics)[0] + 7) // 8
+        ordDataList = [0] * numBytes
+        for row, data in enumerate(dataRows):
+            bitRange = self._getBitRange(row, bitDepth, metrics)
+            stepRange = bitRange + (8,)
+            for curBit, curByte in zip(range(*stepRange), data):
+                endBit = min(curBit + 8, bitRange[1])
+                cutPoint = curBit % 8
+                firstByteLoc = curBit // 8
+                secondByteLoc = endBit // 8
+                if firstByteLoc < secondByteLoc:
+                    numBitsCut = 8 - cutPoint
+                else:
+                    numBitsCut = endBit - curBit
+                curByte = byteord(curByte)
+                firstByte = curByte & ((1 << numBitsCut) - 1)
+                ordDataList[firstByteLoc] |= firstByte << cutPoint
+                if firstByteLoc < secondByteLoc and secondByteLoc < numBytes:
+                    secondByte = (curByte >> numBitsCut) & ((1 << 8 - numBitsCut) - 1)
+                    ordDataList[secondByteLoc] |= secondByte
+
+        # Save the image data with the bits going the correct way.
+        self.imageData = _reverseBytes(bytesjoin(map(bytechr, ordDataList)))
+
+
+class ByteAlignedBitmapMixin(object):
+    def _getByteRange(self, row, bitDepth, metrics):
+        rowBytes = (bitDepth * metrics.width + 7) // 8
+        byteOffset = row * rowBytes
+        return (byteOffset, byteOffset + rowBytes)
+
+    def getRow(self, row, bitDepth=1, metrics=None, reverseBytes=False):
+        if metrics is None:
+            metrics = self.metrics
+        assert 0 <= row and row < metrics.height, "Illegal row access in bitmap"
+        byteRange = self._getByteRange(row, bitDepth, metrics)
+        data = self.imageData[slice(*byteRange)]
+        if reverseBytes:
+            data = _reverseBytes(data)
+        return data
+
+    def setRows(self, dataRows, bitDepth=1, metrics=None, reverseBytes=False):
+        if metrics is None:
+            metrics = self.metrics
+        if reverseBytes:
+            dataRows = map(_reverseBytes, dataRows)
+        self.imageData = bytesjoin(dataRows)
+
+
+class ebdt_bitmap_format_1(
+    ByteAlignedBitmapMixin, BitmapPlusSmallMetricsMixin, BitmapGlyph
+):
+    def decompile(self):
+        self.metrics = SmallGlyphMetrics()
+        dummy, data = sstruct.unpack2(smallGlyphMetricsFormat, self.data, self.metrics)
+        self.imageData = data
+
+    def compile(self, ttFont):
+        data = sstruct.pack(smallGlyphMetricsFormat, self.metrics)
+        return data + self.imageData
+
+
+class ebdt_bitmap_format_2(
+    BitAlignedBitmapMixin, BitmapPlusSmallMetricsMixin, BitmapGlyph
+):
+    def decompile(self):
+        self.metrics = SmallGlyphMetrics()
+        dummy, data = sstruct.unpack2(smallGlyphMetricsFormat, self.data, self.metrics)
+        self.imageData = data
+
+    def compile(self, ttFont):
+        data = sstruct.pack(smallGlyphMetricsFormat, self.metrics)
+        return data + self.imageData
+
+
+class ebdt_bitmap_format_5(BitAlignedBitmapMixin, BitmapGlyph):
+    def decompile(self):
+        self.imageData = self.data
+
+    def compile(self, ttFont):
+        return self.imageData
+
+
+class ebdt_bitmap_format_6(
+    ByteAlignedBitmapMixin, BitmapPlusBigMetricsMixin, BitmapGlyph
+):
+    def decompile(self):
+        self.metrics = BigGlyphMetrics()
+        dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data, self.metrics)
+        self.imageData = data
+
+    def compile(self, ttFont):
+        data = sstruct.pack(bigGlyphMetricsFormat, self.metrics)
+        return data + self.imageData
+
+
+class ebdt_bitmap_format_7(
+    BitAlignedBitmapMixin, BitmapPlusBigMetricsMixin, BitmapGlyph
+):
+    def decompile(self):
+        self.metrics = BigGlyphMetrics()
+        dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data, self.metrics)
+        self.imageData = data
+
+    def compile(self, ttFont):
+        data = sstruct.pack(bigGlyphMetricsFormat, self.metrics)
+        return data + self.imageData
+
+
+class ComponentBitmapGlyph(BitmapGlyph):
+    def toXML(self, strikeIndex, glyphName, writer, ttFont):
+        writer.begintag(self.__class__.__name__, [("name", glyphName)])
+        writer.newline()
+
+        self.writeMetrics(writer, ttFont)
+
+        writer.begintag("components")
+        writer.newline()
+        for curComponent in self.componentArray:
+            curComponent.toXML(writer, ttFont)
+        writer.endtag("components")
+        writer.newline()
+
+        writer.endtag(self.__class__.__name__)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        self.readMetrics(name, attrs, content, ttFont)
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attr, content = element
+            if name == "components":
+                self.componentArray = []
+                for compElement in content:
+                    if not isinstance(compElement, tuple):
+                        continue
+                    name, attrs, content = compElement
+                    if name == "ebdtComponent":
+                        curComponent = EbdtComponent()
+                        curComponent.fromXML(name, attrs, content, ttFont)
+                        self.componentArray.append(curComponent)
+                    else:
+                        log.warning("'%s' being ignored in component array.", name)
+
+
+class ebdt_bitmap_format_8(BitmapPlusSmallMetricsMixin, ComponentBitmapGlyph):
+    def decompile(self):
+        self.metrics = SmallGlyphMetrics()
+        dummy, data = sstruct.unpack2(smallGlyphMetricsFormat, self.data, self.metrics)
+        data = data[1:]
+
+        (numComponents,) = struct.unpack(">H", data[:2])
+        data = data[2:]
+        self.componentArray = []
+        for i in range(numComponents):
+            curComponent = EbdtComponent()
+            dummy, data = sstruct.unpack2(ebdtComponentFormat, data, curComponent)
+            curComponent.name = self.ttFont.getGlyphName(curComponent.glyphCode)
+            self.componentArray.append(curComponent)
+
+    def compile(self, ttFont):
+        dataList = []
+        dataList.append(sstruct.pack(smallGlyphMetricsFormat, self.metrics))
+        dataList.append(b"\0")
+        dataList.append(struct.pack(">H", len(self.componentArray)))
+        for curComponent in self.componentArray:
+            curComponent.glyphCode = ttFont.getGlyphID(curComponent.name)
+            dataList.append(sstruct.pack(ebdtComponentFormat, curComponent))
+        return bytesjoin(dataList)
+
+
+class ebdt_bitmap_format_9(BitmapPlusBigMetricsMixin, ComponentBitmapGlyph):
+    def decompile(self):
+        self.metrics = BigGlyphMetrics()
+        dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data, self.metrics)
+        (numComponents,) = struct.unpack(">H", data[:2])
+        data = data[2:]
+        self.componentArray = []
+        for i in range(numComponents):
+            curComponent = EbdtComponent()
+            dummy, data = sstruct.unpack2(ebdtComponentFormat, data, curComponent)
+            curComponent.name = self.ttFont.getGlyphName(curComponent.glyphCode)
+            self.componentArray.append(curComponent)
+
+    def compile(self, ttFont):
+        dataList = []
+        dataList.append(sstruct.pack(bigGlyphMetricsFormat, self.metrics))
+        dataList.append(struct.pack(">H", len(self.componentArray)))
+        for curComponent in self.componentArray:
+            curComponent.glyphCode = ttFont.getGlyphID(curComponent.name)
+            dataList.append(sstruct.pack(ebdtComponentFormat, curComponent))
+        return bytesjoin(dataList)
+
+
+# Dictionary of bitmap formats to the class representing that format
+# currently only the ones listed in this map are the ones supported.
+ebdt_bitmap_classes = {
+    1: ebdt_bitmap_format_1,
+    2: ebdt_bitmap_format_2,
+    5: ebdt_bitmap_format_5,
+    6: ebdt_bitmap_format_6,
+    7: ebdt_bitmap_format_7,
+    8: ebdt_bitmap_format_8,
+    9: ebdt_bitmap_format_9,
+}

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/E_B_L_C_.py

@@ -0,0 +1,710 @@
+from fontTools.misc import sstruct
+from . import DefaultTable
+from fontTools.misc.textTools import bytesjoin, safeEval
+from .BitmapGlyphMetrics import (
+    BigGlyphMetrics,
+    bigGlyphMetricsFormat,
+    SmallGlyphMetrics,
+    smallGlyphMetricsFormat,
+)
+import struct
+import itertools
+from collections import deque
+import logging
+
+
+log = logging.getLogger(__name__)
+
+eblcHeaderFormat = """
+	> # big endian
+	version:  16.16F
+	numSizes: I
+"""
+# The table format string is split to handle sbitLineMetrics simply.
+bitmapSizeTableFormatPart1 = """
+	> # big endian
+	indexSubTableArrayOffset: I
+	indexTablesSize:          I
+	numberOfIndexSubTables:   I
+	colorRef:                 I
+"""
+# The compound type for hori and vert.
+sbitLineMetricsFormat = """
+	> # big endian
+	ascender:              b
+	descender:             b
+	widthMax:              B
+	caretSlopeNumerator:   b
+	caretSlopeDenominator: b
+	caretOffset:           b
+	minOriginSB:           b
+	minAdvanceSB:          b
+	maxBeforeBL:           b
+	minAfterBL:            b
+	pad1:                  b
+	pad2:                  b
+"""
+# hori and vert go between the two parts.
+bitmapSizeTableFormatPart2 = """
+	> # big endian
+	startGlyphIndex: H
+	endGlyphIndex:   H
+	ppemX:           B
+	ppemY:           B
+	bitDepth:        B
+	flags:           b
+"""
+
+indexSubTableArrayFormat = ">HHL"
+indexSubTableArraySize = struct.calcsize(indexSubTableArrayFormat)
+
+indexSubHeaderFormat = ">HHL"
+indexSubHeaderSize = struct.calcsize(indexSubHeaderFormat)
+
+codeOffsetPairFormat = ">HH"
+codeOffsetPairSize = struct.calcsize(codeOffsetPairFormat)
+
+
+class table_E_B_L_C_(DefaultTable.DefaultTable):
+    dependencies = ["EBDT"]
+
+    # This method can be overridden in subclasses to support new formats
+    # without changing the other implementation. Also can be used as a
+    # convenience method for coverting a font file to an alternative format.
+    def getIndexFormatClass(self, indexFormat):
+        return eblc_sub_table_classes[indexFormat]
+
+    def decompile(self, data, ttFont):
+        # Save the original data because offsets are from the start of the table.
+        origData = data
+        i = 0
+
+        dummy = sstruct.unpack(eblcHeaderFormat, data[:8], self)
+        i += 8
+
+        self.strikes = []
+        for curStrikeIndex in range(self.numSizes):
+            curStrike = Strike()
+            self.strikes.append(curStrike)
+            curTable = curStrike.bitmapSizeTable
+            dummy = sstruct.unpack2(
+                bitmapSizeTableFormatPart1, data[i : i + 16], curTable
+            )
+            i += 16
+            for metric in ("hori", "vert"):
+                metricObj = SbitLineMetrics()
+                vars(curTable)[metric] = metricObj
+                dummy = sstruct.unpack2(
+                    sbitLineMetricsFormat, data[i : i + 12], metricObj
+                )
+                i += 12
+            dummy = sstruct.unpack(
+                bitmapSizeTableFormatPart2, data[i : i + 8], curTable
+            )
+            i += 8
+
+        for curStrike in self.strikes:
+            curTable = curStrike.bitmapSizeTable
+            for subtableIndex in range(curTable.numberOfIndexSubTables):
+                i = (
+                    curTable.indexSubTableArrayOffset
+                    + subtableIndex * indexSubTableArraySize
+                )
+
+                tup = struct.unpack(
+                    indexSubTableArrayFormat, data[i : i + indexSubTableArraySize]
+                )
+                (firstGlyphIndex, lastGlyphIndex, additionalOffsetToIndexSubtable) = tup
+                i = curTable.indexSubTableArrayOffset + additionalOffsetToIndexSubtable
+
+                tup = struct.unpack(
+                    indexSubHeaderFormat, data[i : i + indexSubHeaderSize]
+                )
+                (indexFormat, imageFormat, imageDataOffset) = tup
+
+                indexFormatClass = self.getIndexFormatClass(indexFormat)
+                indexSubTable = indexFormatClass(data[i + indexSubHeaderSize :], ttFont)
+                indexSubTable.firstGlyphIndex = firstGlyphIndex
+                indexSubTable.lastGlyphIndex = lastGlyphIndex
+                indexSubTable.additionalOffsetToIndexSubtable = (
+                    additionalOffsetToIndexSubtable
+                )
+                indexSubTable.indexFormat = indexFormat
+                indexSubTable.imageFormat = imageFormat
+                indexSubTable.imageDataOffset = imageDataOffset
+                indexSubTable.decompile()  # https://github.com/fonttools/fonttools/issues/317
+                curStrike.indexSubTables.append(indexSubTable)
+
+    def compile(self, ttFont):
+        dataList = []
+        self.numSizes = len(self.strikes)
+        dataList.append(sstruct.pack(eblcHeaderFormat, self))
+
+        # Data size of the header + bitmapSizeTable needs to be calculated
+        # in order to form offsets. This value will hold the size of the data
+        # in dataList after all the data is consolidated in dataList.
+        dataSize = len(dataList[0])
+
+        # The table will be structured in the following order:
+        # (0) header
+        # (1) Each bitmapSizeTable [1 ... self.numSizes]
+        # (2) Alternate between indexSubTableArray and indexSubTable
+        #     for each bitmapSizeTable present.
+        #
+        # The issue is maintaining the proper offsets when table information
+        # gets moved around. All offsets and size information must be recalculated
+        # when building the table to allow editing within ttLib and also allow easy
+        # import/export to and from XML. All of this offset information is lost
+        # when exporting to XML so everything must be calculated fresh so importing
+        # from XML will work cleanly. Only byte offset and size information is
+        # calculated fresh. Count information like numberOfIndexSubTables is
+        # checked through assertions. If the information in this table was not
+        # touched or was changed properly then these types of values should match.
+        #
+        # The table will be rebuilt the following way:
+        # (0) Precompute the size of all the bitmapSizeTables. This is needed to
+        #     compute the offsets properly.
+        # (1) For each bitmapSizeTable compute the indexSubTable and
+        #    	indexSubTableArray pair. The indexSubTable must be computed first
+        #     so that the offset information in indexSubTableArray can be
+        #     calculated. Update the data size after each pairing.
+        # (2) Build each bitmapSizeTable.
+        # (3) Consolidate all the data into the main dataList in the correct order.
+
+        for _ in self.strikes:
+            dataSize += sstruct.calcsize(bitmapSizeTableFormatPart1)
+            dataSize += len(("hori", "vert")) * sstruct.calcsize(sbitLineMetricsFormat)
+            dataSize += sstruct.calcsize(bitmapSizeTableFormatPart2)
+
+        indexSubTablePairDataList = []
+        for curStrike in self.strikes:
+            curTable = curStrike.bitmapSizeTable
+            curTable.numberOfIndexSubTables = len(curStrike.indexSubTables)
+            curTable.indexSubTableArrayOffset = dataSize
+
+            # Precompute the size of the indexSubTableArray. This information
+            # is important for correctly calculating the new value for
+            # additionalOffsetToIndexSubtable.
+            sizeOfSubTableArray = (
+                curTable.numberOfIndexSubTables * indexSubTableArraySize
+            )
+            lowerBound = dataSize
+            dataSize += sizeOfSubTableArray
+            upperBound = dataSize
+
+            indexSubTableDataList = []
+            for indexSubTable in curStrike.indexSubTables:
+                indexSubTable.additionalOffsetToIndexSubtable = (
+                    dataSize - curTable.indexSubTableArrayOffset
+                )
+                glyphIds = list(map(ttFont.getGlyphID, indexSubTable.names))
+                indexSubTable.firstGlyphIndex = min(glyphIds)
+                indexSubTable.lastGlyphIndex = max(glyphIds)
+                data = indexSubTable.compile(ttFont)
+                indexSubTableDataList.append(data)
+                dataSize += len(data)
+            curTable.startGlyphIndex = min(
+                ist.firstGlyphIndex for ist in curStrike.indexSubTables
+            )
+            curTable.endGlyphIndex = max(
+                ist.lastGlyphIndex for ist in curStrike.indexSubTables
+            )
+
+            for i in curStrike.indexSubTables:
+                data = struct.pack(
+                    indexSubHeaderFormat,
+                    i.firstGlyphIndex,
+                    i.lastGlyphIndex,
+                    i.additionalOffsetToIndexSubtable,
+                )
+                indexSubTablePairDataList.append(data)
+            indexSubTablePairDataList.extend(indexSubTableDataList)
+            curTable.indexTablesSize = dataSize - curTable.indexSubTableArrayOffset
+
+        for curStrike in self.strikes:
+            curTable = curStrike.bitmapSizeTable
+            data = sstruct.pack(bitmapSizeTableFormatPart1, curTable)
+            dataList.append(data)
+            for metric in ("hori", "vert"):
+                metricObj = vars(curTable)[metric]
+                data = sstruct.pack(sbitLineMetricsFormat, metricObj)
+                dataList.append(data)
+            data = sstruct.pack(bitmapSizeTableFormatPart2, curTable)
+            dataList.append(data)
+        dataList.extend(indexSubTablePairDataList)
+
+        return bytesjoin(dataList)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("header", [("version", self.version)])
+        writer.newline()
+        for curIndex, curStrike in enumerate(self.strikes):
+            curStrike.toXML(curIndex, writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "header":
+            self.version = safeEval(attrs["version"])
+        elif name == "strike":
+            if not hasattr(self, "strikes"):
+                self.strikes = []
+            strikeIndex = safeEval(attrs["index"])
+            curStrike = Strike()
+            curStrike.fromXML(name, attrs, content, ttFont, self)
+
+            # Grow the strike array to the appropriate size. The XML format
+            # allows for the strike index value to be out of order.
+            if strikeIndex >= len(self.strikes):
+                self.strikes += [None] * (strikeIndex + 1 - len(self.strikes))
+            assert self.strikes[strikeIndex] is None, "Duplicate strike EBLC indices."
+            self.strikes[strikeIndex] = curStrike
+
+
+class Strike(object):
+    def __init__(self):
+        self.bitmapSizeTable = BitmapSizeTable()
+        self.indexSubTables = []
+
+    def toXML(self, strikeIndex, writer, ttFont):
+        writer.begintag("strike", [("index", strikeIndex)])
+        writer.newline()
+        self.bitmapSizeTable.toXML(writer, ttFont)
+        writer.comment(
+            "GlyphIds are written but not read. The firstGlyphIndex and\nlastGlyphIndex values will be recalculated by the compiler."
+        )
+        writer.newline()
+        for indexSubTable in self.indexSubTables:
+            indexSubTable.toXML(writer, ttFont)
+        writer.endtag("strike")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont, locator):
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            if name == "bitmapSizeTable":
+                self.bitmapSizeTable.fromXML(name, attrs, content, ttFont)
+            elif name.startswith(_indexSubTableSubclassPrefix):
+                indexFormat = safeEval(name[len(_indexSubTableSubclassPrefix) :])
+                indexFormatClass = locator.getIndexFormatClass(indexFormat)
+                indexSubTable = indexFormatClass(None, None)
+                indexSubTable.indexFormat = indexFormat
+                indexSubTable.fromXML(name, attrs, content, ttFont)
+                self.indexSubTables.append(indexSubTable)
+
+
+class BitmapSizeTable(object):
+    # Returns all the simple metric names that bitmap size table
+    # cares about in terms of XML creation.
+    def _getXMLMetricNames(self):
+        dataNames = sstruct.getformat(bitmapSizeTableFormatPart1)[1]
+        dataNames = {**dataNames, **sstruct.getformat(bitmapSizeTableFormatPart2)[1]}
+        # Skip the first 3 data names because they are byte offsets and counts.
+        return list(dataNames.keys())[3:]
+
+    def toXML(self, writer, ttFont):
+        writer.begintag("bitmapSizeTable")
+        writer.newline()
+        for metric in ("hori", "vert"):
+            getattr(self, metric).toXML(metric, writer, ttFont)
+        for metricName in self._getXMLMetricNames():
+            writer.simpletag(metricName, value=getattr(self, metricName))
+            writer.newline()
+        writer.endtag("bitmapSizeTable")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        # Create a lookup for all the simple names that make sense to
+        # bitmap size table. Only read the information from these names.
+        dataNames = set(self._getXMLMetricNames())
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            if name == "sbitLineMetrics":
+                direction = attrs["direction"]
+                assert direction in (
+                    "hori",
+                    "vert",
+                ), "SbitLineMetrics direction specified invalid."
+                metricObj = SbitLineMetrics()
+                metricObj.fromXML(name, attrs, content, ttFont)
+                vars(self)[direction] = metricObj
+            elif name in dataNames:
+                vars(self)[name] = safeEval(attrs["value"])
+            else:
+                log.warning("unknown name '%s' being ignored in BitmapSizeTable.", name)
+
+
+class SbitLineMetrics(object):
+    def toXML(self, name, writer, ttFont):
+        writer.begintag("sbitLineMetrics", [("direction", name)])
+        writer.newline()
+        for metricName in sstruct.getformat(sbitLineMetricsFormat)[1]:
+            writer.simpletag(metricName, value=getattr(self, metricName))
+            writer.newline()
+        writer.endtag("sbitLineMetrics")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        metricNames = set(sstruct.getformat(sbitLineMetricsFormat)[1])
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            if name in metricNames:
+                vars(self)[name] = safeEval(attrs["value"])
+
+
+# Important information about the naming scheme. Used for identifying subtables.
+_indexSubTableSubclassPrefix = "eblc_index_sub_table_"
+
+
+class EblcIndexSubTable(object):
+    def __init__(self, data, ttFont):
+        self.data = data
+        self.ttFont = ttFont
+        # TODO Currently non-lazy decompiling doesn't work for this class...
+        # if not ttFont.lazy:
+        # 	self.decompile()
+        # 	del self.data, self.ttFont
+
+    def __getattr__(self, attr):
+        # Allow lazy decompile.
+        if attr[:2] == "__":
+            raise AttributeError(attr)
+        if attr == "data":
+            raise AttributeError(attr)
+        self.decompile()
+        return getattr(self, attr)
+
+    def ensureDecompiled(self, recurse=False):
+        if hasattr(self, "data"):
+            self.decompile()
+
+    # This method just takes care of the indexSubHeader. Implementing subclasses
+    # should call it to compile the indexSubHeader and then continue compiling
+    # the remainder of their unique format.
+    def compile(self, ttFont):
+        return struct.pack(
+            indexSubHeaderFormat,
+            self.indexFormat,
+            self.imageFormat,
+            self.imageDataOffset,
+        )
+
+    # Creates the XML for bitmap glyphs. Each index sub table basically makes
+    # the same XML except for specific metric information that is written
+    # out via a method call that a subclass implements optionally.
+    def toXML(self, writer, ttFont):
+        writer.begintag(
+            self.__class__.__name__,
+            [
+                ("imageFormat", self.imageFormat),
+                ("firstGlyphIndex", self.firstGlyphIndex),
+                ("lastGlyphIndex", self.lastGlyphIndex),
+            ],
+        )
+        writer.newline()
+        self.writeMetrics(writer, ttFont)
+        # Write out the names as thats all thats needed to rebuild etc.
+        # For font debugging of consecutive formats the ids are also written.
+        # The ids are not read when moving from the XML format.
+        glyphIds = map(ttFont.getGlyphID, self.names)
+        for glyphName, glyphId in zip(self.names, glyphIds):
+            writer.simpletag("glyphLoc", name=glyphName, id=glyphId)
+            writer.newline()
+        writer.endtag(self.__class__.__name__)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        # Read all the attributes. Even though the glyph indices are
+        # recalculated, they are still read in case there needs to
+        # be an immediate export of the data.
+        self.imageFormat = safeEval(attrs["imageFormat"])
+        self.firstGlyphIndex = safeEval(attrs["firstGlyphIndex"])
+        self.lastGlyphIndex = safeEval(attrs["lastGlyphIndex"])
+
+        self.readMetrics(name, attrs, content, ttFont)
+
+        self.names = []
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            if name == "glyphLoc":
+                self.names.append(attrs["name"])
+
+    # A helper method that writes the metrics for the index sub table. It also
+    # is responsible for writing the image size for fixed size data since fixed
+    # size is not recalculated on compile. Default behavior is to do nothing.
+    def writeMetrics(self, writer, ttFont):
+        pass
+
+    # A helper method that is the inverse of writeMetrics.
+    def readMetrics(self, name, attrs, content, ttFont):
+        pass
+
+    # This method is for fixed glyph data sizes. There are formats where
+    # the glyph data is fixed but are actually composite glyphs. To handle
+    # this the font spec in indexSubTable makes the data the size of the
+    # fixed size by padding the component arrays. This function abstracts
+    # out this padding process. Input is data unpadded. Output is data
+    # padded only in fixed formats. Default behavior is to return the data.
+    def padBitmapData(self, data):
+        return data
+
+    # Remove any of the glyph locations and names that are flagged as skipped.
+    # This only occurs in formats {1,3}.
+    def removeSkipGlyphs(self):
+        # Determines if a name, location pair is a valid data location.
+        # Skip glyphs are marked when the size is equal to zero.
+        def isValidLocation(args):
+            (name, (startByte, endByte)) = args
+            return startByte < endByte
+
+        # Remove all skip glyphs.
+        dataPairs = list(filter(isValidLocation, zip(self.names, self.locations)))
+        self.names, self.locations = list(map(list, zip(*dataPairs)))
+
+
+# A closure for creating a custom mixin. This is done because formats 1 and 3
+# are very similar. The only difference between them is the size per offset
+# value. Code put in here should handle both cases generally.
+def _createOffsetArrayIndexSubTableMixin(formatStringForDataType):
+    # Prep the data size for the offset array data format.
+    dataFormat = ">" + formatStringForDataType
+    offsetDataSize = struct.calcsize(dataFormat)
+
+    class OffsetArrayIndexSubTableMixin(object):
+        def decompile(self):
+            numGlyphs = self.lastGlyphIndex - self.firstGlyphIndex + 1
+            indexingOffsets = [
+                glyphIndex * offsetDataSize for glyphIndex in range(numGlyphs + 2)
+            ]
+            indexingLocations = zip(indexingOffsets, indexingOffsets[1:])
+            offsetArray = [
+                struct.unpack(dataFormat, self.data[slice(*loc)])[0]
+                for loc in indexingLocations
+            ]
+
+            glyphIds = list(range(self.firstGlyphIndex, self.lastGlyphIndex + 1))
+            modifiedOffsets = [offset + self.imageDataOffset for offset in offsetArray]
+            self.locations = list(zip(modifiedOffsets, modifiedOffsets[1:]))
+
+            self.names = list(map(self.ttFont.getGlyphName, glyphIds))
+            self.removeSkipGlyphs()
+            del self.data, self.ttFont
+
+        def compile(self, ttFont):
+            # First make sure that all the data lines up properly. Formats 1 and 3
+            # must have all its data lined up consecutively. If not this will fail.
+            for curLoc, nxtLoc in zip(self.locations, self.locations[1:]):
+                assert (
+                    curLoc[1] == nxtLoc[0]
+                ), "Data must be consecutive in indexSubTable offset formats"
+
+            glyphIds = list(map(ttFont.getGlyphID, self.names))
+            # Make sure that all ids are sorted strictly increasing.
+            assert all(glyphIds[i] < glyphIds[i + 1] for i in range(len(glyphIds) - 1))
+
+            # Run a simple algorithm to add skip glyphs to the data locations at
+            # the places where an id is not present.
+            idQueue = deque(glyphIds)
+            locQueue = deque(self.locations)
+            allGlyphIds = list(range(self.firstGlyphIndex, self.lastGlyphIndex + 1))
+            allLocations = []
+            for curId in allGlyphIds:
+                if curId != idQueue[0]:
+                    allLocations.append((locQueue[0][0], locQueue[0][0]))
+                else:
+                    idQueue.popleft()
+                    allLocations.append(locQueue.popleft())
+
+            # Now that all the locations are collected, pack them appropriately into
+            # offsets. This is the form where offset[i] is the location and
+            # offset[i+1]-offset[i] is the size of the data location.
+            offsets = list(allLocations[0]) + [loc[1] for loc in allLocations[1:]]
+            # Image data offset must be less than or equal to the minimum of locations.
+            # This offset may change the value for round tripping but is safer and
+            # allows imageDataOffset to not be required to be in the XML version.
+            self.imageDataOffset = min(offsets)
+            offsetArray = [offset - self.imageDataOffset for offset in offsets]
+
+            dataList = [EblcIndexSubTable.compile(self, ttFont)]
+            dataList += [
+                struct.pack(dataFormat, offsetValue) for offsetValue in offsetArray
+            ]
+            # Take care of any padding issues. Only occurs in format 3.
+            if offsetDataSize * len(offsetArray) % 4 != 0:
+                dataList.append(struct.pack(dataFormat, 0))
+            return bytesjoin(dataList)
+
+    return OffsetArrayIndexSubTableMixin
+
+
+# A Mixin for functionality shared between the different kinds
+# of fixed sized data handling. Both kinds have big metrics so
+# that kind of special processing is also handled in this mixin.
+class FixedSizeIndexSubTableMixin(object):
+    def writeMetrics(self, writer, ttFont):
+        writer.simpletag("imageSize", value=self.imageSize)
+        writer.newline()
+        self.metrics.toXML(writer, ttFont)
+
+    def readMetrics(self, name, attrs, content, ttFont):
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            if name == "imageSize":
+                self.imageSize = safeEval(attrs["value"])
+            elif name == BigGlyphMetrics.__name__:
+                self.metrics = BigGlyphMetrics()
+                self.metrics.fromXML(name, attrs, content, ttFont)
+            elif name == SmallGlyphMetrics.__name__:
+                log.warning(
+                    "SmallGlyphMetrics being ignored in format %d.", self.indexFormat
+                )
+
+    def padBitmapData(self, data):
+        # Make sure that the data isn't bigger than the fixed size.
+        assert len(data) <= self.imageSize, (
+            "Data in indexSubTable format %d must be less than the fixed size."
+            % self.indexFormat
+        )
+        # Pad the data so that it matches the fixed size.
+        pad = (self.imageSize - len(data)) * b"\0"
+        return data + pad
+
+
+class eblc_index_sub_table_1(
+    _createOffsetArrayIndexSubTableMixin("L"), EblcIndexSubTable
+):
+    pass
+
+
+class eblc_index_sub_table_2(FixedSizeIndexSubTableMixin, EblcIndexSubTable):
+    def decompile(self):
+        (self.imageSize,) = struct.unpack(">L", self.data[:4])
+        self.metrics = BigGlyphMetrics()
+        sstruct.unpack2(bigGlyphMetricsFormat, self.data[4:], self.metrics)
+        glyphIds = list(range(self.firstGlyphIndex, self.lastGlyphIndex + 1))
+        offsets = [
+            self.imageSize * i + self.imageDataOffset for i in range(len(glyphIds) + 1)
+        ]
+        self.locations = list(zip(offsets, offsets[1:]))
+        self.names = list(map(self.ttFont.getGlyphName, glyphIds))
+        del self.data, self.ttFont
+
+    def compile(self, ttFont):
+        glyphIds = list(map(ttFont.getGlyphID, self.names))
+        # Make sure all the ids are consecutive. This is required by Format 2.
+        assert glyphIds == list(
+            range(self.firstGlyphIndex, self.lastGlyphIndex + 1)
+        ), "Format 2 ids must be consecutive."
+        self.imageDataOffset = min(next(iter(zip(*self.locations))))
+
+        dataList = [EblcIndexSubTable.compile(self, ttFont)]
+        dataList.append(struct.pack(">L", self.imageSize))
+        dataList.append(sstruct.pack(bigGlyphMetricsFormat, self.metrics))
+        return bytesjoin(dataList)
+
+
+class eblc_index_sub_table_3(
+    _createOffsetArrayIndexSubTableMixin("H"), EblcIndexSubTable
+):
+    pass
+
+
+class eblc_index_sub_table_4(EblcIndexSubTable):
+    def decompile(self):
+        (numGlyphs,) = struct.unpack(">L", self.data[:4])
+        data = self.data[4:]
+        indexingOffsets = [
+            glyphIndex * codeOffsetPairSize for glyphIndex in range(numGlyphs + 2)
+        ]
+        indexingLocations = zip(indexingOffsets, indexingOffsets[1:])
+        glyphArray = [
+            struct.unpack(codeOffsetPairFormat, data[slice(*loc)])
+            for loc in indexingLocations
+        ]
+        glyphIds, offsets = list(map(list, zip(*glyphArray)))
+        # There are one too many glyph ids. Get rid of the last one.
+        glyphIds.pop()
+
+        offsets = [offset + self.imageDataOffset for offset in offsets]
+        self.locations = list(zip(offsets, offsets[1:]))
+        self.names = list(map(self.ttFont.getGlyphName, glyphIds))
+        del self.data, self.ttFont
+
+    def compile(self, ttFont):
+        # First make sure that all the data lines up properly. Format 4
+        # must have all its data lined up consecutively. If not this will fail.
+        for curLoc, nxtLoc in zip(self.locations, self.locations[1:]):
+            assert (
+                curLoc[1] == nxtLoc[0]
+            ), "Data must be consecutive in indexSubTable format 4"
+
+        offsets = list(self.locations[0]) + [loc[1] for loc in self.locations[1:]]
+        # Image data offset must be less than or equal to the minimum of locations.
+        # Resetting this offset may change the value for round tripping but is safer
+        # and allows imageDataOffset to not be required to be in the XML version.
+        self.imageDataOffset = min(offsets)
+        offsets = [offset - self.imageDataOffset for offset in offsets]
+        glyphIds = list(map(ttFont.getGlyphID, self.names))
+        # Create an iterator over the ids plus a padding value.
+        idsPlusPad = list(itertools.chain(glyphIds, [0]))
+
+        dataList = [EblcIndexSubTable.compile(self, ttFont)]
+        dataList.append(struct.pack(">L", len(glyphIds)))
+        tmp = [
+            struct.pack(codeOffsetPairFormat, *cop) for cop in zip(idsPlusPad, offsets)
+        ]
+        dataList += tmp
+        data = bytesjoin(dataList)
+        return data
+
+
+class eblc_index_sub_table_5(FixedSizeIndexSubTableMixin, EblcIndexSubTable):
+    def decompile(self):
+        self.origDataLen = 0
+        (self.imageSize,) = struct.unpack(">L", self.data[:4])
+        data = self.data[4:]
+        self.metrics, data = sstruct.unpack2(
+            bigGlyphMetricsFormat, data, BigGlyphMetrics()
+        )
+        (numGlyphs,) = struct.unpack(">L", data[:4])
+        data = data[4:]
+        glyphIds = [
+            struct.unpack(">H", data[2 * i : 2 * (i + 1)])[0] for i in range(numGlyphs)
+        ]
+
+        offsets = [
+            self.imageSize * i + self.imageDataOffset for i in range(len(glyphIds) + 1)
+        ]
+        self.locations = list(zip(offsets, offsets[1:]))
+        self.names = list(map(self.ttFont.getGlyphName, glyphIds))
+        del self.data, self.ttFont
+
+    def compile(self, ttFont):
+        self.imageDataOffset = min(next(iter(zip(*self.locations))))
+        dataList = [EblcIndexSubTable.compile(self, ttFont)]
+        dataList.append(struct.pack(">L", self.imageSize))
+        dataList.append(sstruct.pack(bigGlyphMetricsFormat, self.metrics))
+        glyphIds = list(map(ttFont.getGlyphID, self.names))
+        dataList.append(struct.pack(">L", len(glyphIds)))
+        dataList += [struct.pack(">H", curId) for curId in glyphIds]
+        if len(glyphIds) % 2 == 1:
+            dataList.append(struct.pack(">H", 0))
+        return bytesjoin(dataList)
+
+
+# Dictionary of indexFormat to the class representing that format.
+eblc_sub_table_classes = {
+    1: eblc_index_sub_table_1,
+    2: eblc_index_sub_table_2,
+    3: eblc_index_sub_table_3,
+    4: eblc_index_sub_table_4,
+    5: eblc_index_sub_table_5,
+}

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/F_F_T_M_.py

@@ -0,0 +1,42 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from fontTools.misc.timeTools import timestampFromString, timestampToString
+from . import DefaultTable
+
+FFTMFormat = """
+		>	# big endian
+		version:        I
+		FFTimeStamp:    Q
+		sourceCreated:  Q
+		sourceModified: Q
+"""
+
+
+class table_F_F_T_M_(DefaultTable.DefaultTable):
+    def decompile(self, data, ttFont):
+        dummy, rest = sstruct.unpack2(FFTMFormat, data, self)
+
+    def compile(self, ttFont):
+        data = sstruct.pack(FFTMFormat, self)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.comment(
+            "FontForge's timestamp, font source creation and modification dates"
+        )
+        writer.newline()
+        formatstring, names, fixes = sstruct.getformat(FFTMFormat)
+        for name in names:
+            value = getattr(self, name)
+            if name in ("FFTimeStamp", "sourceCreated", "sourceModified"):
+                value = timestampToString(value)
+            writer.simpletag(name, value=value)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        value = attrs["value"]
+        if name in ("FFTimeStamp", "sourceCreated", "sourceModified"):
+            value = timestampFromString(value)
+        else:
+            value = safeEval(value)
+        setattr(self, name, value)

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/G_D_E_F_.py

@@ -0,0 +1,5 @@
+from .otBase import BaseTTXConverter
+
+
+class table_G_D_E_F_(BaseTTXConverter):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/G_P_K_G_.py

@@ -0,0 +1,126 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytesjoin, safeEval, readHex
+from . import DefaultTable
+import sys
+import array
+
+GPKGFormat = """
+		>	# big endian
+		version:	H
+		flags:	H
+		numGMAPs:		H
+		numGlyplets:		H
+"""
+# psFontName is a byte string which follows the record above. This is zero padded
+# to the beginning of the records array. The recordsOffsst is 32 bit aligned.
+
+
+class table_G_P_K_G_(DefaultTable.DefaultTable):
+    def decompile(self, data, ttFont):
+        dummy, newData = sstruct.unpack2(GPKGFormat, data, self)
+
+        GMAPoffsets = array.array("I")
+        endPos = (self.numGMAPs + 1) * 4
+        GMAPoffsets.frombytes(newData[:endPos])
+        if sys.byteorder != "big":
+            GMAPoffsets.byteswap()
+        self.GMAPs = []
+        for i in range(self.numGMAPs):
+            start = GMAPoffsets[i]
+            end = GMAPoffsets[i + 1]
+            self.GMAPs.append(data[start:end])
+        pos = endPos
+        endPos = pos + (self.numGlyplets + 1) * 4
+        glyphletOffsets = array.array("I")
+        glyphletOffsets.frombytes(newData[pos:endPos])
+        if sys.byteorder != "big":
+            glyphletOffsets.byteswap()
+        self.glyphlets = []
+        for i in range(self.numGlyplets):
+            start = glyphletOffsets[i]
+            end = glyphletOffsets[i + 1]
+            self.glyphlets.append(data[start:end])
+
+    def compile(self, ttFont):
+        self.numGMAPs = len(self.GMAPs)
+        self.numGlyplets = len(self.glyphlets)
+        GMAPoffsets = [0] * (self.numGMAPs + 1)
+        glyphletOffsets = [0] * (self.numGlyplets + 1)
+
+        dataList = [sstruct.pack(GPKGFormat, self)]
+
+        pos = len(dataList[0]) + (self.numGMAPs + 1) * 4 + (self.numGlyplets + 1) * 4
+        GMAPoffsets[0] = pos
+        for i in range(1, self.numGMAPs + 1):
+            pos += len(self.GMAPs[i - 1])
+            GMAPoffsets[i] = pos
+        gmapArray = array.array("I", GMAPoffsets)
+        if sys.byteorder != "big":
+            gmapArray.byteswap()
+        dataList.append(gmapArray.tobytes())
+
+        glyphletOffsets[0] = pos
+        for i in range(1, self.numGlyplets + 1):
+            pos += len(self.glyphlets[i - 1])
+            glyphletOffsets[i] = pos
+        glyphletArray = array.array("I", glyphletOffsets)
+        if sys.byteorder != "big":
+            glyphletArray.byteswap()
+        dataList.append(glyphletArray.tobytes())
+        dataList += self.GMAPs
+        dataList += self.glyphlets
+        data = bytesjoin(dataList)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.comment("Most of this table will be recalculated by the compiler")
+        writer.newline()
+        formatstring, names, fixes = sstruct.getformat(GPKGFormat)
+        for name in names:
+            value = getattr(self, name)
+            writer.simpletag(name, value=value)
+            writer.newline()
+
+        writer.begintag("GMAPs")
+        writer.newline()
+        for gmapData in self.GMAPs:
+            writer.begintag("hexdata")
+            writer.newline()
+            writer.dumphex(gmapData)
+            writer.endtag("hexdata")
+            writer.newline()
+        writer.endtag("GMAPs")
+        writer.newline()
+
+        writer.begintag("glyphlets")
+        writer.newline()
+        for glyphletData in self.glyphlets:
+            writer.begintag("hexdata")
+            writer.newline()
+            writer.dumphex(glyphletData)
+            writer.endtag("hexdata")
+            writer.newline()
+        writer.endtag("glyphlets")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "GMAPs":
+            if not hasattr(self, "GMAPs"):
+                self.GMAPs = []
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                itemName, itemAttrs, itemContent = element
+                if itemName == "hexdata":
+                    self.GMAPs.append(readHex(itemContent))
+        elif name == "glyphlets":
+            if not hasattr(self, "glyphlets"):
+                self.glyphlets = []
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                itemName, itemAttrs, itemContent = element
+                if itemName == "hexdata":
+                    self.glyphlets.append(readHex(itemContent))
+        else:
+            setattr(self, name, safeEval(attrs["value"]))

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/G_P_O_S_.py

@@ -0,0 +1,5 @@
+from .otBase import BaseTTXConverter
+
+
+class table_G_P_O_S_(BaseTTXConverter):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/G__l_a_t.py

@@ -0,0 +1,234 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import floatToFixedToStr
+from fontTools.misc.textTools import safeEval
+
+# from itertools import *
+from functools import partial
+from . import DefaultTable
+from . import grUtils
+import struct
+
+
+Glat_format_0 = """
+    >        # big endian
+    version: 16.16F
+"""
+
+Glat_format_3 = """
+    >
+    version: 16.16F
+    compression:L    # compression scheme or reserved 
+"""
+
+Glat_format_1_entry = """
+    >
+    attNum:     B    # Attribute number of first attribute
+    num:        B    # Number of attributes in this run
+"""
+Glat_format_23_entry = """
+    >
+    attNum:     H    # Attribute number of first attribute
+    num:        H    # Number of attributes in this run
+"""
+
+Glat_format_3_octabox_metrics = """
+    >
+    subboxBitmap:   H    # Which subboxes exist on 4x4 grid
+    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
+    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
+    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
+    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
+"""
+
+Glat_format_3_subbox_entry = """
+    >
+    left:           B    # xi
+    right:          B    # xa
+    bottom:         B    # yi
+    top:            B    # ya
+    diagNegMin:     B    # Defines minimum negatively-sloped diagonal (si)
+    diagNegMax:     B    # Defines maximum negatively-sloped diagonal (sa)
+    diagPosMin:     B    # Defines minimum positively-sloped diagonal (di)
+    diagPosMax:     B    # Defines maximum positively-sloped diagonal (da)
+"""
+
+
+class _Object:
+    pass
+
+
+class _Dict(dict):
+    pass
+
+
+class table_G__l_a_t(DefaultTable.DefaultTable):
+    """
+    Support Graphite Glat tables
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.scheme = 0
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack2(Glat_format_0, data, self)
+        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
+        if self.version <= 1.9:
+            decoder = partial(self.decompileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version <= 2.9:
+            decoder = partial(self.decompileAttributes12, fmt=Glat_format_23_entry)
+        elif self.version >= 3.0:
+            (data, self.scheme) = grUtils.decompress(data)
+            sstruct.unpack2(Glat_format_3, data, self)
+            self.hasOctaboxes = (self.compression & 1) == 1
+            decoder = self.decompileAttributes3
+
+        gloc = ttFont["Gloc"]
+        self.attributes = {}
+        count = 0
+        for s, e in zip(gloc, gloc[1:]):
+            self.attributes[ttFont.getGlyphName(count)] = decoder(data[s:e])
+            count += 1
+
+    def decompileAttributes12(self, data, fmt):
+        attributes = _Dict()
+        while len(data) > 3:
+            e, data = sstruct.unpack2(fmt, data, _Object())
+            keys = range(e.attNum, e.attNum + e.num)
+            if len(data) >= 2 * e.num:
+                vals = struct.unpack_from((">%dh" % e.num), data)
+                attributes.update(zip(keys, vals))
+                data = data[2 * e.num :]
+        return attributes
+
+    def decompileAttributes3(self, data):
+        if self.hasOctaboxes:
+            o, data = sstruct.unpack2(Glat_format_3_octabox_metrics, data, _Object())
+            numsub = bin(o.subboxBitmap).count("1")
+            o.subboxes = []
+            for b in range(numsub):
+                if len(data) >= 8:
+                    subbox, data = sstruct.unpack2(
+                        Glat_format_3_subbox_entry, data, _Object()
+                    )
+                    o.subboxes.append(subbox)
+        attrs = self.decompileAttributes12(data, Glat_format_23_entry)
+        if self.hasOctaboxes:
+            attrs.octabox = o
+        return attrs
+
+    def compile(self, ttFont):
+        data = sstruct.pack(Glat_format_0, self)
+        if self.version <= 1.9:
+            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version <= 2.9:
+            encoder = partial(self.compileAttributes12, fmt=Glat_format_1_entry)
+        elif self.version >= 3.0:
+            self.compression = (self.scheme << 27) + (1 if self.hasOctaboxes else 0)
+            data = sstruct.pack(Glat_format_3, self)
+            encoder = self.compileAttributes3
+
+        glocs = []
+        for n in range(len(self.attributes)):
+            glocs.append(len(data))
+            data += encoder(self.attributes[ttFont.getGlyphName(n)])
+        glocs.append(len(data))
+        ttFont["Gloc"].set(glocs)
+
+        if self.version >= 3.0:
+            data = grUtils.compress(self.scheme, data)
+        return data
+
+    def compileAttributes12(self, attrs, fmt):
+        data = b""
+        for e in grUtils.entries(attrs):
+            data += sstruct.pack(fmt, {"attNum": e[0], "num": e[1]}) + struct.pack(
+                (">%dh" % len(e[2])), *e[2]
+            )
+        return data
+
+    def compileAttributes3(self, attrs):
+        if self.hasOctaboxes:
+            o = attrs.octabox
+            data = sstruct.pack(Glat_format_3_octabox_metrics, o)
+            numsub = bin(o.subboxBitmap).count("1")
+            for b in range(numsub):
+                data += sstruct.pack(Glat_format_3_subbox_entry, o.subboxes[b])
+        else:
+            data = ""
+        return data + self.compileAttributes12(attrs, Glat_format_23_entry)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", version=self.version, compressionScheme=self.scheme)
+        writer.newline()
+        for n, a in sorted(
+            self.attributes.items(), key=lambda x: ttFont.getGlyphID(x[0])
+        ):
+            writer.begintag("glyph", name=n)
+            writer.newline()
+            if hasattr(a, "octabox"):
+                o = a.octabox
+                formatstring, names, fixes = sstruct.getformat(
+                    Glat_format_3_octabox_metrics
+                )
+                vals = {}
+                for k in names:
+                    if k == "subboxBitmap":
+                        continue
+                    vals[k] = "{:.3f}%".format(getattr(o, k) * 100.0 / 255)
+                vals["bitmap"] = "{:0X}".format(o.subboxBitmap)
+                writer.begintag("octaboxes", **vals)
+                writer.newline()
+                formatstring, names, fixes = sstruct.getformat(
+                    Glat_format_3_subbox_entry
+                )
+                for s in o.subboxes:
+                    vals = {}
+                    for k in names:
+                        vals[k] = "{:.3f}%".format(getattr(s, k) * 100.0 / 255)
+                    writer.simpletag("octabox", **vals)
+                    writer.newline()
+                writer.endtag("octaboxes")
+                writer.newline()
+            for k, v in sorted(a.items()):
+                writer.simpletag("attribute", index=k, value=v)
+                writer.newline()
+            writer.endtag("glyph")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = float(safeEval(attrs["version"]))
+            self.scheme = int(safeEval(attrs["compressionScheme"]))
+        if name != "glyph":
+            return
+        if not hasattr(self, "attributes"):
+            self.attributes = {}
+        gname = attrs["name"]
+        attributes = _Dict()
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            tag, attrs, subcontent = element
+            if tag == "attribute":
+                k = int(safeEval(attrs["index"]))
+                v = int(safeEval(attrs["value"]))
+                attributes[k] = v
+            elif tag == "octaboxes":
+                self.hasOctaboxes = True
+                o = _Object()
+                o.subboxBitmap = int(attrs["bitmap"], 16)
+                o.subboxes = []
+                del attrs["bitmap"]
+                for k, v in attrs.items():
+                    setattr(o, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
+                for element in subcontent:
+                    if not isinstance(element, tuple):
+                        continue
+                    (tag, attrs, subcontent) = element
+                    so = _Object()
+                    for k, v in attrs.items():
+                        setattr(so, k, int(float(v[:-1]) * 255.0 / 100.0 + 0.5))
+                    o.subboxes.append(so)
+                attributes.octabox = o
+        self.attributes[gname] = attributes

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/J_S_T_F_.py

@@ -0,0 +1,5 @@
+from .otBase import BaseTTXConverter
+
+
+class table_J_S_T_F_(BaseTTXConverter):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/S_I_N_G_.py

@@ -0,0 +1,92 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytechr, byteord, tobytes, tostr, safeEval
+from . import DefaultTable
+
+SINGFormat = """
+		>	# big endian
+		tableVersionMajor:	H
+		tableVersionMinor: 	H
+		glyphletVersion:	H
+		permissions:		h
+		mainGID:			H
+		unitsPerEm:			H
+		vertAdvance:		h
+		vertOrigin:			h
+		uniqueName:			28s
+		METAMD5:			16s
+		nameLength:			1s
+"""
+# baseGlyphName is a byte string which follows the record above.
+
+
+class table_S_I_N_G_(DefaultTable.DefaultTable):
+    dependencies = []
+
+    def decompile(self, data, ttFont):
+        dummy, rest = sstruct.unpack2(SINGFormat, data, self)
+        self.uniqueName = self.decompileUniqueName(self.uniqueName)
+        self.nameLength = byteord(self.nameLength)
+        assert len(rest) == self.nameLength
+        self.baseGlyphName = tostr(rest)
+
+        rawMETAMD5 = self.METAMD5
+        self.METAMD5 = "[" + hex(byteord(self.METAMD5[0]))
+        for char in rawMETAMD5[1:]:
+            self.METAMD5 = self.METAMD5 + ", " + hex(byteord(char))
+        self.METAMD5 = self.METAMD5 + "]"
+
+    def decompileUniqueName(self, data):
+        name = ""
+        for char in data:
+            val = byteord(char)
+            if val == 0:
+                break
+            if (val > 31) or (val < 128):
+                name += chr(val)
+            else:
+                octString = oct(val)
+                if len(octString) > 3:
+                    octString = octString[1:]  # chop off that leading zero.
+                elif len(octString) < 3:
+                    octString.zfill(3)
+                name += "\\" + octString
+        return name
+
+    def compile(self, ttFont):
+        d = self.__dict__.copy()
+        d["nameLength"] = bytechr(len(self.baseGlyphName))
+        d["uniqueName"] = self.compilecompileUniqueName(self.uniqueName, 28)
+        METAMD5List = eval(self.METAMD5)
+        d["METAMD5"] = b""
+        for val in METAMD5List:
+            d["METAMD5"] += bytechr(val)
+        assert len(d["METAMD5"]) == 16, "Failed to pack 16 byte MD5 hash in SING table"
+        data = sstruct.pack(SINGFormat, d)
+        data = data + tobytes(self.baseGlyphName)
+        return data
+
+    def compilecompileUniqueName(self, name, length):
+        nameLen = len(name)
+        if length <= nameLen:
+            name = name[: length - 1] + "\000"
+        else:
+            name += (nameLen - length) * "\000"
+        return name
+
+    def toXML(self, writer, ttFont):
+        writer.comment("Most of this table will be recalculated by the compiler")
+        writer.newline()
+        formatstring, names, fixes = sstruct.getformat(SINGFormat)
+        for name in names:
+            value = getattr(self, name)
+            writer.simpletag(name, value=value)
+            writer.newline()
+        writer.simpletag("baseGlyphName", value=self.baseGlyphName)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        value = attrs["value"]
+        if name in ["uniqueName", "METAMD5", "baseGlyphName"]:
+            setattr(self, name, value)
+        else:
+            setattr(self, name, safeEval(value))

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/S_T_A_T_.py

@@ -0,0 +1,5 @@
+from .otBase import BaseTTXConverter
+
+
+class table_S_T_A_T_(BaseTTXConverter):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I_B_.py

@@ -0,0 +1,5 @@
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_B_(table_T_S_I_V_):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I_D_.py

@@ -0,0 +1,5 @@
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_D_(table_T_S_I_V_):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I_P_.py

@@ -0,0 +1,5 @@
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_P_(table_T_S_I_V_):
+    pass

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I__1.py

@@ -0,0 +1,164 @@
+""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its hinting source data.
+
+TSI1 contains the text of the glyph programs in the form of low-level assembly
+code, as well as the 'extra' programs 'fpgm', 'ppgm' (i.e. 'prep'), and 'cvt'.
+"""
+
+from . import DefaultTable
+from fontTools.misc.loggingTools import LogMixin
+from fontTools.misc.textTools import strjoin, tobytes, tostr
+
+
+class table_T_S_I__1(LogMixin, DefaultTable.DefaultTable):
+    extras = {0xFFFA: "ppgm", 0xFFFB: "cvt", 0xFFFC: "reserved", 0xFFFD: "fpgm"}
+
+    indextable = "TSI0"
+
+    def decompile(self, data, ttFont):
+        totalLength = len(data)
+        indextable = ttFont[self.indextable]
+        for indices, isExtra in zip(
+            (indextable.indices, indextable.extra_indices), (False, True)
+        ):
+            programs = {}
+            for i, (glyphID, textLength, textOffset) in enumerate(indices):
+                if isExtra:
+                    name = self.extras[glyphID]
+                else:
+                    name = ttFont.getGlyphName(glyphID)
+                if textOffset > totalLength:
+                    self.log.warning("textOffset > totalLength; %r skipped" % name)
+                    continue
+                if textLength < 0x8000:
+                    # If the length stored in the record is less than 32768, then use
+                    # that as the length of the record.
+                    pass
+                elif textLength == 0x8000:
+                    # If the length is 32768, compute the actual length as follows:
+                    isLast = i == (len(indices) - 1)
+                    if isLast:
+                        if isExtra:
+                            # For the last "extra" record (the very last record of the
+                            # table), the length is the difference between the total
+                            # length of the TSI1 table and the textOffset of the final
+                            # record.
+                            nextTextOffset = totalLength
+                        else:
+                            # For the last "normal" record (the last record just prior
+                            # to the record containing the "magic number"), the length
+                            # is the difference between the textOffset of the record
+                            # following the "magic number" (0xFFFE) record (i.e. the
+                            # first "extra" record), and the textOffset of the last
+                            # "normal" record.
+                            nextTextOffset = indextable.extra_indices[0][2]
+                    else:
+                        # For all other records with a length of 0x8000, the length is
+                        # the difference between the textOffset of the record in
+                        # question and the textOffset of the next record.
+                        nextTextOffset = indices[i + 1][2]
+                    assert nextTextOffset >= textOffset, "entries not sorted by offset"
+                    if nextTextOffset > totalLength:
+                        self.log.warning(
+                            "nextTextOffset > totalLength; %r truncated" % name
+                        )
+                        nextTextOffset = totalLength
+                    textLength = nextTextOffset - textOffset
+                else:
+                    from fontTools import ttLib
+
+                    raise ttLib.TTLibError(
+                        "%r textLength (%d) must not be > 32768" % (name, textLength)
+                    )
+                text = data[textOffset : textOffset + textLength]
+                assert len(text) == textLength
+                text = tostr(text, encoding="utf-8")
+                if text:
+                    programs[name] = text
+            if isExtra:
+                self.extraPrograms = programs
+            else:
+                self.glyphPrograms = programs
+
+    def compile(self, ttFont):
+        if not hasattr(self, "glyphPrograms"):
+            self.glyphPrograms = {}
+            self.extraPrograms = {}
+        data = b""
+        indextable = ttFont[self.indextable]
+        glyphNames = ttFont.getGlyphOrder()
+
+        indices = []
+        for i in range(len(glyphNames)):
+            if len(data) % 2:
+                data = (
+                    data + b"\015"
+                )  # align on 2-byte boundaries, fill with return chars. Yum.
+            name = glyphNames[i]
+            if name in self.glyphPrograms:
+                text = tobytes(self.glyphPrograms[name], encoding="utf-8")
+            else:
+                text = b""
+            textLength = len(text)
+            if textLength >= 0x8000:
+                textLength = 0x8000
+            indices.append((i, textLength, len(data)))
+            data = data + text
+
+        extra_indices = []
+        codes = sorted(self.extras.items())
+        for i in range(len(codes)):
+            if len(data) % 2:
+                data = (
+                    data + b"\015"
+                )  # align on 2-byte boundaries, fill with return chars.
+            code, name = codes[i]
+            if name in self.extraPrograms:
+                text = tobytes(self.extraPrograms[name], encoding="utf-8")
+            else:
+                text = b""
+            textLength = len(text)
+            if textLength >= 0x8000:
+                textLength = 0x8000
+            extra_indices.append((code, textLength, len(data)))
+            data = data + text
+        indextable.set(indices, extra_indices)
+        return data
+
+    def toXML(self, writer, ttFont):
+        names = sorted(self.glyphPrograms.keys())
+        writer.newline()
+        for name in names:
+            text = self.glyphPrograms[name]
+            if not text:
+                continue
+            writer.begintag("glyphProgram", name=name)
+            writer.newline()
+            writer.write_noindent(text.replace("\r", "\n"))
+            writer.newline()
+            writer.endtag("glyphProgram")
+            writer.newline()
+            writer.newline()
+        extra_names = sorted(self.extraPrograms.keys())
+        for name in extra_names:
+            text = self.extraPrograms[name]
+            if not text:
+                continue
+            writer.begintag("extraProgram", name=name)
+            writer.newline()
+            writer.write_noindent(text.replace("\r", "\n"))
+            writer.newline()
+            writer.endtag("extraProgram")
+            writer.newline()
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "glyphPrograms"):
+            self.glyphPrograms = {}
+            self.extraPrograms = {}
+        lines = strjoin(content).replace("\r", "\n").split("\n")
+        text = "\r".join(lines[1:-1])
+        if name == "glyphProgram":
+            self.glyphPrograms[attrs["name"]] = text
+        elif name == "extraProgram":
+            self.extraPrograms[attrs["name"]] = text

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/T_S_I__5.py

@@ -0,0 +1,47 @@
+""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its hinting source data.
+
+TSI5 contains the VTT character groups.
+"""
+
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import sys
+import array
+
+
+class table_T_S_I__5(DefaultTable.DefaultTable):
+    def decompile(self, data, ttFont):
+        numGlyphs = ttFont["maxp"].numGlyphs
+        assert len(data) == 2 * numGlyphs
+        a = array.array("H")
+        a.frombytes(data)
+        if sys.byteorder != "big":
+            a.byteswap()
+        self.glyphGrouping = {}
+        for i in range(numGlyphs):
+            self.glyphGrouping[ttFont.getGlyphName(i)] = a[i]
+
+    def compile(self, ttFont):
+        glyphNames = ttFont.getGlyphOrder()
+        a = array.array("H")
+        for i in range(len(glyphNames)):
+            a.append(self.glyphGrouping.get(glyphNames[i], 0))
+        if sys.byteorder != "big":
+            a.byteswap()
+        return a.tobytes()
+
+    def toXML(self, writer, ttFont):
+        names = sorted(self.glyphGrouping.keys())
+        for glyphName in names:
+            writer.simpletag(
+                "glyphgroup", name=glyphName, value=self.glyphGrouping[glyphName]
+            )
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "glyphGrouping"):
+            self.glyphGrouping = {}
+        if name != "glyphgroup":
+            return
+        self.glyphGrouping[attrs["name"]] = safeEval(attrs["value"])

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/TupleVariation.py

@@ -0,0 +1,846 @@
+from fontTools.misc.fixedTools import (
+    fixedToFloat as fi2fl,
+    floatToFixed as fl2fi,
+    floatToFixedToStr as fl2str,
+    strToFixedToFloat as str2fl,
+    otRound,
+)
+from fontTools.misc.textTools import safeEval
+import array
+from collections import Counter, defaultdict
+import io
+import logging
+import struct
+import sys
+
+
+# https://www.microsoft.com/typography/otspec/otvarcommonformats.htm
+
+EMBEDDED_PEAK_TUPLE = 0x8000
+INTERMEDIATE_REGION = 0x4000
+PRIVATE_POINT_NUMBERS = 0x2000
+
+DELTAS_ARE_ZERO = 0x80
+DELTAS_ARE_WORDS = 0x40
+DELTAS_ARE_LONGS = 0xC0
+DELTAS_SIZE_MASK = 0xC0
+DELTA_RUN_COUNT_MASK = 0x3F
+
+POINTS_ARE_WORDS = 0x80
+POINT_RUN_COUNT_MASK = 0x7F
+
+TUPLES_SHARE_POINT_NUMBERS = 0x8000
+TUPLE_COUNT_MASK = 0x0FFF
+TUPLE_INDEX_MASK = 0x0FFF
+
+log = logging.getLogger(__name__)
+
+
+class TupleVariation(object):
+    def __init__(self, axes, coordinates):
+        self.axes = axes.copy()
+        self.coordinates = list(coordinates)
+
+    def __repr__(self):
+        axes = ",".join(
+            sorted(["%s=%s" % (name, value) for (name, value) in self.axes.items()])
+        )
+        return "<TupleVariation %s %s>" % (axes, self.coordinates)
+
+    def __eq__(self, other):
+        return self.coordinates == other.coordinates and self.axes == other.axes
+
+    def getUsedPoints(self):
+        # Empty set means "all points used".
+        if None not in self.coordinates:
+            return frozenset()
+        used = frozenset([i for i, p in enumerate(self.coordinates) if p is not None])
+        # Return None if no points used.
+        return used if used else None
+
+    def hasImpact(self):
+        """Returns True if this TupleVariation has any visible impact.
+
+        If the result is False, the TupleVariation can be omitted from the font
+        without making any visible difference.
+        """
+        return any(c is not None for c in self.coordinates)
+
+    def toXML(self, writer, axisTags):
+        writer.begintag("tuple")
+        writer.newline()
+        for axis in axisTags:
+            value = self.axes.get(axis)
+            if value is not None:
+                minValue, value, maxValue = value
+                defaultMinValue = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
+                defaultMaxValue = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
+                if minValue == defaultMinValue and maxValue == defaultMaxValue:
+                    writer.simpletag("coord", axis=axis, value=fl2str(value, 14))
+                else:
+                    attrs = [
+                        ("axis", axis),
+                        ("min", fl2str(minValue, 14)),
+                        ("value", fl2str(value, 14)),
+                        ("max", fl2str(maxValue, 14)),
+                    ]
+                    writer.simpletag("coord", attrs)
+                writer.newline()
+        wrote_any_deltas = False
+        for i, delta in enumerate(self.coordinates):
+            if type(delta) == tuple and len(delta) == 2:
+                writer.simpletag("delta", pt=i, x=delta[0], y=delta[1])
+                writer.newline()
+                wrote_any_deltas = True
+            elif type(delta) == int:
+                writer.simpletag("delta", cvt=i, value=delta)
+                writer.newline()
+                wrote_any_deltas = True
+            elif delta is not None:
+                log.error("bad delta format")
+                writer.comment("bad delta #%d" % i)
+                writer.newline()
+                wrote_any_deltas = True
+        if not wrote_any_deltas:
+            writer.comment("no deltas")
+            writer.newline()
+        writer.endtag("tuple")
+        writer.newline()
+
+    def fromXML(self, name, attrs, _content):
+        if name == "coord":
+            axis = attrs["axis"]
+            value = str2fl(attrs["value"], 14)
+            defaultMinValue = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
+            defaultMaxValue = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
+            minValue = str2fl(attrs.get("min", defaultMinValue), 14)
+            maxValue = str2fl(attrs.get("max", defaultMaxValue), 14)
+            self.axes[axis] = (minValue, value, maxValue)
+        elif name == "delta":
+            if "pt" in attrs:
+                point = safeEval(attrs["pt"])
+                x = safeEval(attrs["x"])
+                y = safeEval(attrs["y"])
+                self.coordinates[point] = (x, y)
+            elif "cvt" in attrs:
+                cvt = safeEval(attrs["cvt"])
+                value = safeEval(attrs["value"])
+                self.coordinates[cvt] = value
+            else:
+                log.warning("bad delta format: %s" % ", ".join(sorted(attrs.keys())))
+
+    def compile(self, axisTags, sharedCoordIndices={}, pointData=None):
+        assert set(self.axes.keys()) <= set(axisTags), (
+            "Unknown axis tag found.",
+            self.axes.keys(),
+            axisTags,
+        )
+
+        tupleData = []
+        auxData = []
+
+        if pointData is None:
+            usedPoints = self.getUsedPoints()
+            if usedPoints is None:  # Nothing to encode
+                return b"", b""
+            pointData = self.compilePoints(usedPoints)
+
+        coord = self.compileCoord(axisTags)
+        flags = sharedCoordIndices.get(coord)
+        if flags is None:
+            flags = EMBEDDED_PEAK_TUPLE
+            tupleData.append(coord)
+
+        intermediateCoord = self.compileIntermediateCoord(axisTags)
+        if intermediateCoord is not None:
+            flags |= INTERMEDIATE_REGION
+            tupleData.append(intermediateCoord)
+
+        # pointData of b'' implies "use shared points".
+        if pointData:
+            flags |= PRIVATE_POINT_NUMBERS
+            auxData.append(pointData)
+
+        auxData.append(self.compileDeltas())
+        auxData = b"".join(auxData)
+
+        tupleData.insert(0, struct.pack(">HH", len(auxData), flags))
+        return b"".join(tupleData), auxData
+
+    def compileCoord(self, axisTags):
+        result = []
+        axes = self.axes
+        for axis in axisTags:
+            triple = axes.get(axis)
+            if triple is None:
+                result.append(b"\0\0")
+            else:
+                result.append(struct.pack(">h", fl2fi(triple[1], 14)))
+        return b"".join(result)
+
+    def compileIntermediateCoord(self, axisTags):
+        needed = False
+        for axis in axisTags:
+            minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
+            defaultMinValue = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
+            defaultMaxValue = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
+            if (minValue != defaultMinValue) or (maxValue != defaultMaxValue):
+                needed = True
+                break
+        if not needed:
+            return None
+        minCoords = []
+        maxCoords = []
+        for axis in axisTags:
+            minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
+            minCoords.append(struct.pack(">h", fl2fi(minValue, 14)))
+            maxCoords.append(struct.pack(">h", fl2fi(maxValue, 14)))
+        return b"".join(minCoords + maxCoords)
+
+    @staticmethod
+    def decompileCoord_(axisTags, data, offset):
+        coord = {}
+        pos = offset
+        for axis in axisTags:
+            coord[axis] = fi2fl(struct.unpack(">h", data[pos : pos + 2])[0], 14)
+            pos += 2
+        return coord, pos
+
+    @staticmethod
+    def compilePoints(points):
+        # If the set consists of all points in the glyph, it gets encoded with
+        # a special encoding: a single zero byte.
+        #
+        # To use this optimization, points passed in must be empty set.
+        # The following two lines are not strictly necessary as the main code
+        # below would emit the same. But this is most common and faster.
+        if not points:
+            return b"\0"
+
+        # In the 'gvar' table, the packing of point numbers is a little surprising.
+        # It consists of multiple runs, each being a delta-encoded list of integers.
+        # For example, the point set {17, 18, 19, 20, 21, 22, 23} gets encoded as
+        # [6, 17, 1, 1, 1, 1, 1, 1]. The first value (6) is the run length minus 1.
+        # There are two types of runs, with values being either 8 or 16 bit unsigned
+        # integers.
+        points = list(points)
+        points.sort()
+        numPoints = len(points)
+
+        result = bytearray()
+        # The binary representation starts with the total number of points in the set,
+        # encoded into one or two bytes depending on the value.
+        if numPoints < 0x80:
+            result.append(numPoints)
+        else:
+            result.append((numPoints >> 8) | 0x80)
+            result.append(numPoints & 0xFF)
+
+        MAX_RUN_LENGTH = 127
+        pos = 0
+        lastValue = 0
+        while pos < numPoints:
+            runLength = 0
+
+            headerPos = len(result)
+            result.append(0)
+
+            useByteEncoding = None
+            while pos < numPoints and runLength <= MAX_RUN_LENGTH:
+                curValue = points[pos]
+                delta = curValue - lastValue
+                if useByteEncoding is None:
+                    useByteEncoding = 0 <= delta <= 0xFF
+                if useByteEncoding and (delta > 0xFF or delta < 0):
+                    # we need to start a new run (which will not use byte encoding)
+                    break
+                # TODO This never switches back to a byte-encoding from a short-encoding.
+                # That's suboptimal.
+                if useByteEncoding:
+                    result.append(delta)
+                else:
+                    result.append(delta >> 8)
+                    result.append(delta & 0xFF)
+                lastValue = curValue
+                pos += 1
+                runLength += 1
+            if useByteEncoding:
+                result[headerPos] = runLength - 1
+            else:
+                result[headerPos] = (runLength - 1) | POINTS_ARE_WORDS
+
+        return result
+
+    @staticmethod
+    def decompilePoints_(numPoints, data, offset, tableTag):
+        """(numPoints, data, offset, tableTag) --> ([point1, point2, ...], newOffset)"""
+        assert tableTag in ("cvar", "gvar")
+        pos = offset
+        numPointsInData = data[pos]
+        pos += 1
+        if (numPointsInData & POINTS_ARE_WORDS) != 0:
+            numPointsInData = (numPointsInData & POINT_RUN_COUNT_MASK) << 8 | data[pos]
+            pos += 1
+        if numPointsInData == 0:
+            return (range(numPoints), pos)
+
+        result = []
+        while len(result) < numPointsInData:
+            runHeader = data[pos]
+            pos += 1
+            numPointsInRun = (runHeader & POINT_RUN_COUNT_MASK) + 1
+            point = 0
+            if (runHeader & POINTS_ARE_WORDS) != 0:
+                points = array.array("H")
+                pointsSize = numPointsInRun * 2
+            else:
+                points = array.array("B")
+                pointsSize = numPointsInRun
+            points.frombytes(data[pos : pos + pointsSize])
+            if sys.byteorder != "big":
+                points.byteswap()
+
+            assert len(points) == numPointsInRun
+            pos += pointsSize
+
+            result.extend(points)
+
+        # Convert relative to absolute
+        absolute = []
+        current = 0
+        for delta in result:
+            current += delta
+            absolute.append(current)
+        result = absolute
+        del absolute
+
+        badPoints = {str(p) for p in result if p < 0 or p >= numPoints}
+        if badPoints:
+            log.warning(
+                "point %s out of range in '%s' table"
+                % (",".join(sorted(badPoints)), tableTag)
+            )
+        return (result, pos)
+
+    def compileDeltas(self):
+        deltaX = []
+        deltaY = []
+        if self.getCoordWidth() == 2:
+            for c in self.coordinates:
+                if c is None:
+                    continue
+                deltaX.append(c[0])
+                deltaY.append(c[1])
+        else:
+            for c in self.coordinates:
+                if c is None:
+                    continue
+                deltaX.append(c)
+        bytearr = bytearray()
+        self.compileDeltaValues_(deltaX, bytearr)
+        self.compileDeltaValues_(deltaY, bytearr)
+        return bytearr
+
+    @staticmethod
+    def compileDeltaValues_(deltas, bytearr=None):
+        """[value1, value2, value3, ...] --> bytearray
+
+        Emits a sequence of runs. Each run starts with a
+        byte-sized header whose 6 least significant bits
+        (header & 0x3F) indicate how many values are encoded
+        in this run. The stored length is the actual length
+        minus one; run lengths are thus in the range [1..64].
+        If the header byte has its most significant bit (0x80)
+        set, all values in this run are zero, and no data
+        follows. Otherwise, the header byte is followed by
+        ((header & 0x3F) + 1) signed values.  If (header &
+        0x40) is clear, the delta values are stored as signed
+        bytes; if (header & 0x40) is set, the delta values are
+        signed 16-bit integers.
+        """  # Explaining the format because the 'gvar' spec is hard to understand.
+        if bytearr is None:
+            bytearr = bytearray()
+        pos = 0
+        numDeltas = len(deltas)
+        while pos < numDeltas:
+            value = deltas[pos]
+            if value == 0:
+                pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, bytearr)
+            elif -128 <= value <= 127:
+                pos = TupleVariation.encodeDeltaRunAsBytes_(deltas, pos, bytearr)
+            elif -32768 <= value <= 32767:
+                pos = TupleVariation.encodeDeltaRunAsWords_(deltas, pos, bytearr)
+            else:
+                pos = TupleVariation.encodeDeltaRunAsLongs_(deltas, pos, bytearr)
+        return bytearr
+
+    @staticmethod
+    def encodeDeltaRunAsZeroes_(deltas, offset, bytearr):
+        pos = offset
+        numDeltas = len(deltas)
+        while pos < numDeltas and deltas[pos] == 0:
+            pos += 1
+        runLength = pos - offset
+        while runLength >= 64:
+            bytearr.append(DELTAS_ARE_ZERO | 63)
+            runLength -= 64
+        if runLength:
+            bytearr.append(DELTAS_ARE_ZERO | (runLength - 1))
+        return pos
+
+    @staticmethod
+    def encodeDeltaRunAsBytes_(deltas, offset, bytearr):
+        pos = offset
+        numDeltas = len(deltas)
+        while pos < numDeltas:
+            value = deltas[pos]
+            if not (-128 <= value <= 127):
+                break
+            # Within a byte-encoded run of deltas, a single zero
+            # is best stored literally as 0x00 value. However,
+            # if are two or more zeroes in a sequence, it is
+            # better to start a new run. For example, the sequence
+            # of deltas [15, 15, 0, 15, 15] becomes 6 bytes
+            # (04 0F 0F 00 0F 0F) when storing the zero value
+            # literally, but 7 bytes (01 0F 0F 80 01 0F 0F)
+            # when starting a new run.
+            if value == 0 and pos + 1 < numDeltas and deltas[pos + 1] == 0:
+                break
+            pos += 1
+        runLength = pos - offset
+        while runLength >= 64:
+            bytearr.append(63)
+            bytearr.extend(array.array("b", deltas[offset : offset + 64]))
+            offset += 64
+            runLength -= 64
+        if runLength:
+            bytearr.append(runLength - 1)
+            bytearr.extend(array.array("b", deltas[offset:pos]))
+        return pos
+
+    @staticmethod
+    def encodeDeltaRunAsWords_(deltas, offset, bytearr):
+        pos = offset
+        numDeltas = len(deltas)
+        while pos < numDeltas:
+            value = deltas[pos]
+
+            # Within a word-encoded run of deltas, it is easiest
+            # to start a new run (with a different encoding)
+            # whenever we encounter a zero value. For example,
+            # the sequence [0x6666, 0, 0x7777] needs 7 bytes when
+            # storing the zero literally (42 66 66 00 00 77 77),
+            # and equally 7 bytes when starting a new run
+            # (40 66 66 80 40 77 77).
+            if value == 0:
+                break
+
+            # Within a word-encoded run of deltas, a single value
+            # in the range (-128..127) should be encoded literally
+            # because it is more compact. For example, the sequence
+            # [0x6666, 2, 0x7777] becomes 7 bytes when storing
+            # the value literally (42 66 66 00 02 77 77), but 8 bytes
+            # when starting a new run (40 66 66 00 02 40 77 77).
+            if (
+                (-128 <= value <= 127)
+                and pos + 1 < numDeltas
+                and (-128 <= deltas[pos + 1] <= 127)
+            ):
+                break
+
+            if not (-32768 <= value <= 32767):
+                break
+
+            pos += 1
+        runLength = pos - offset
+        while runLength >= 64:
+            bytearr.append(DELTAS_ARE_WORDS | 63)
+            a = array.array("h", deltas[offset : offset + 64])
+            if sys.byteorder != "big":
+                a.byteswap()
+            bytearr.extend(a)
+            offset += 64
+            runLength -= 64
+        if runLength:
+            bytearr.append(DELTAS_ARE_WORDS | (runLength - 1))
+            a = array.array("h", deltas[offset:pos])
+            if sys.byteorder != "big":
+                a.byteswap()
+            bytearr.extend(a)
+        return pos
+
+    @staticmethod
+    def encodeDeltaRunAsLongs_(deltas, offset, bytearr):
+        pos = offset
+        numDeltas = len(deltas)
+        while pos < numDeltas:
+            value = deltas[pos]
+            if -32768 <= value <= 32767:
+                break
+            pos += 1
+        runLength = pos - offset
+        while runLength >= 64:
+            bytearr.append(DELTAS_ARE_LONGS | 63)
+            a = array.array("i", deltas[offset : offset + 64])
+            if sys.byteorder != "big":
+                a.byteswap()
+            bytearr.extend(a)
+            offset += 64
+            runLength -= 64
+        if runLength:
+            bytearr.append(DELTAS_ARE_LONGS | (runLength - 1))
+            a = array.array("i", deltas[offset:pos])
+            if sys.byteorder != "big":
+                a.byteswap()
+            bytearr.extend(a)
+        return pos
+
+    @staticmethod
+    def decompileDeltas_(numDeltas, data, offset=0):
+        """(numDeltas, data, offset) --> ([delta, delta, ...], newOffset)"""
+        result = []
+        pos = offset
+        while len(result) < numDeltas if numDeltas is not None else pos < len(data):
+            runHeader = data[pos]
+            pos += 1
+            numDeltasInRun = (runHeader & DELTA_RUN_COUNT_MASK) + 1
+            if (runHeader & DELTAS_SIZE_MASK) == DELTAS_ARE_ZERO:
+                result.extend([0] * numDeltasInRun)
+            else:
+                if (runHeader & DELTAS_SIZE_MASK) == DELTAS_ARE_LONGS:
+                    deltas = array.array("i")
+                    deltasSize = numDeltasInRun * 4
+                elif (runHeader & DELTAS_SIZE_MASK) == DELTAS_ARE_WORDS:
+                    deltas = array.array("h")
+                    deltasSize = numDeltasInRun * 2
+                else:
+                    deltas = array.array("b")
+                    deltasSize = numDeltasInRun
+                deltas.frombytes(data[pos : pos + deltasSize])
+                if sys.byteorder != "big":
+                    deltas.byteswap()
+                assert len(deltas) == numDeltasInRun, (len(deltas), numDeltasInRun)
+                pos += deltasSize
+                result.extend(deltas)
+        assert numDeltas is None or len(result) == numDeltas
+        return (result, pos)
+
+    @staticmethod
+    def getTupleSize_(flags, axisCount):
+        size = 4
+        if (flags & EMBEDDED_PEAK_TUPLE) != 0:
+            size += axisCount * 2
+        if (flags & INTERMEDIATE_REGION) != 0:
+            size += axisCount * 4
+        return size
+
+    def getCoordWidth(self):
+        """Return 2 if coordinates are (x, y) as in gvar, 1 if single values
+        as in cvar, or 0 if empty.
+        """
+        firstDelta = next((c for c in self.coordinates if c is not None), None)
+        if firstDelta is None:
+            return 0  # empty or has no impact
+        if type(firstDelta) in (int, float):
+            return 1
+        if type(firstDelta) is tuple and len(firstDelta) == 2:
+            return 2
+        raise TypeError(
+            "invalid type of delta; expected (int or float) number, or "
+            "Tuple[number, number]: %r" % firstDelta
+        )
+
+    def scaleDeltas(self, scalar):
+        if scalar == 1.0:
+            return  # no change
+        coordWidth = self.getCoordWidth()
+        self.coordinates = [
+            (
+                None
+                if d is None
+                else d * scalar if coordWidth == 1 else (d[0] * scalar, d[1] * scalar)
+            )
+            for d in self.coordinates
+        ]
+
+    def roundDeltas(self):
+        coordWidth = self.getCoordWidth()
+        self.coordinates = [
+            (
+                None
+                if d is None
+                else otRound(d) if coordWidth == 1 else (otRound(d[0]), otRound(d[1]))
+            )
+            for d in self.coordinates
+        ]
+
+    def calcInferredDeltas(self, origCoords, endPts):
+        from fontTools.varLib.iup import iup_delta
+
+        if self.getCoordWidth() == 1:
+            raise TypeError("Only 'gvar' TupleVariation can have inferred deltas")
+        if None in self.coordinates:
+            if len(self.coordinates) != len(origCoords):
+                raise ValueError(
+                    "Expected len(origCoords) == %d; found %d"
+                    % (len(self.coordinates), len(origCoords))
+                )
+            self.coordinates = iup_delta(self.coordinates, origCoords, endPts)
+
+    def optimize(self, origCoords, endPts, tolerance=0.5, isComposite=False):
+        from fontTools.varLib.iup import iup_delta_optimize
+
+        if None in self.coordinates:
+            return  # already optimized
+
+        deltaOpt = iup_delta_optimize(
+            self.coordinates, origCoords, endPts, tolerance=tolerance
+        )
+        if None in deltaOpt:
+            if isComposite and all(d is None for d in deltaOpt):
+                # Fix for macOS composites
+                # https://github.com/fonttools/fonttools/issues/1381
+                deltaOpt = [(0, 0)] + [None] * (len(deltaOpt) - 1)
+            # Use "optimized" version only if smaller...
+            varOpt = TupleVariation(self.axes, deltaOpt)
+
+            # Shouldn't matter that this is different from fvar...?
+            axisTags = sorted(self.axes.keys())
+            tupleData, auxData = self.compile(axisTags)
+            unoptimizedLength = len(tupleData) + len(auxData)
+            tupleData, auxData = varOpt.compile(axisTags)
+            optimizedLength = len(tupleData) + len(auxData)
+
+            if optimizedLength < unoptimizedLength:
+                self.coordinates = varOpt.coordinates
+
+    def __imul__(self, scalar):
+        self.scaleDeltas(scalar)
+        return self
+
+    def __iadd__(self, other):
+        if not isinstance(other, TupleVariation):
+            return NotImplemented
+        deltas1 = self.coordinates
+        length = len(deltas1)
+        deltas2 = other.coordinates
+        if len(deltas2) != length:
+            raise ValueError("cannot sum TupleVariation deltas with different lengths")
+        # 'None' values have different meanings in gvar vs cvar TupleVariations:
+        # within the gvar, when deltas are not provided explicitly for some points,
+        # they need to be inferred; whereas for the 'cvar' table, if deltas are not
+        # provided for some CVT values, then no adjustments are made (i.e. None == 0).
+        # Thus, we cannot sum deltas for gvar TupleVariations if they contain
+        # inferred inferred deltas (the latter need to be computed first using
+        # 'calcInferredDeltas' method), but we can treat 'None' values in cvar
+        # deltas as if they are zeros.
+        if self.getCoordWidth() == 2:
+            for i, d2 in zip(range(length), deltas2):
+                d1 = deltas1[i]
+                try:
+                    deltas1[i] = (d1[0] + d2[0], d1[1] + d2[1])
+                except TypeError:
+                    raise ValueError("cannot sum gvar deltas with inferred points")
+        else:
+            for i, d2 in zip(range(length), deltas2):
+                d1 = deltas1[i]
+                if d1 is not None and d2 is not None:
+                    deltas1[i] = d1 + d2
+                elif d1 is None and d2 is not None:
+                    deltas1[i] = d2
+                # elif d2 is None do nothing
+        return self
+
+
+def decompileSharedTuples(axisTags, sharedTupleCount, data, offset):
+    result = []
+    for _ in range(sharedTupleCount):
+        t, offset = TupleVariation.decompileCoord_(axisTags, data, offset)
+        result.append(t)
+    return result
+
+
+def compileSharedTuples(
+    axisTags, variations, MAX_NUM_SHARED_COORDS=TUPLE_INDEX_MASK + 1
+):
+    coordCount = Counter()
+    for var in variations:
+        coord = var.compileCoord(axisTags)
+        coordCount[coord] += 1
+    # In python < 3.7, most_common() ordering is non-deterministic
+    # so apply a sort to make sure the ordering is consistent.
+    sharedCoords = sorted(
+        coordCount.most_common(MAX_NUM_SHARED_COORDS),
+        key=lambda item: (-item[1], item[0]),
+    )
+    return [c[0] for c in sharedCoords if c[1] > 1]
+
+
+def compileTupleVariationStore(
+    variations, pointCount, axisTags, sharedTupleIndices, useSharedPoints=True
+):
+    # pointCount is actually unused. Keeping for API compat.
+    del pointCount
+    newVariations = []
+    pointDatas = []
+    # Compile all points and figure out sharing if desired
+    sharedPoints = None
+
+    # Collect, count, and compile point-sets for all variation sets
+    pointSetCount = defaultdict(int)
+    for v in variations:
+        points = v.getUsedPoints()
+        if points is None:  # Empty variations
+            continue
+        pointSetCount[points] += 1
+        newVariations.append(v)
+        pointDatas.append(points)
+    variations = newVariations
+    del newVariations
+
+    if not variations:
+        return (0, b"", b"")
+
+    n = len(variations[0].coordinates)
+    assert all(
+        len(v.coordinates) == n for v in variations
+    ), "Variation sets have different sizes"
+
+    compiledPoints = {
+        pointSet: TupleVariation.compilePoints(pointSet) for pointSet in pointSetCount
+    }
+
+    tupleVariationCount = len(variations)
+    tuples = []
+    data = []
+
+    if useSharedPoints:
+        # Find point-set which saves most bytes.
+        def key(pn):
+            pointSet = pn[0]
+            count = pn[1]
+            return len(compiledPoints[pointSet]) * (count - 1)
+
+        sharedPoints = max(pointSetCount.items(), key=key)[0]
+
+        data.append(compiledPoints[sharedPoints])
+        tupleVariationCount |= TUPLES_SHARE_POINT_NUMBERS
+
+    # b'' implies "use shared points"
+    pointDatas = [
+        compiledPoints[points] if points != sharedPoints else b""
+        for points in pointDatas
+    ]
+
+    for v, p in zip(variations, pointDatas):
+        thisTuple, thisData = v.compile(axisTags, sharedTupleIndices, pointData=p)
+
+        tuples.append(thisTuple)
+        data.append(thisData)
+
+    tuples = b"".join(tuples)
+    data = b"".join(data)
+    return tupleVariationCount, tuples, data
+
+
+def decompileTupleVariationStore(
+    tableTag,
+    axisTags,
+    tupleVariationCount,
+    pointCount,
+    sharedTuples,
+    data,
+    pos,
+    dataPos,
+):
+    numAxes = len(axisTags)
+    result = []
+    if (tupleVariationCount & TUPLES_SHARE_POINT_NUMBERS) != 0:
+        sharedPoints, dataPos = TupleVariation.decompilePoints_(
+            pointCount, data, dataPos, tableTag
+        )
+    else:
+        sharedPoints = []
+    for _ in range(tupleVariationCount & TUPLE_COUNT_MASK):
+        dataSize, flags = struct.unpack(">HH", data[pos : pos + 4])
+        tupleSize = TupleVariation.getTupleSize_(flags, numAxes)
+        tupleData = data[pos : pos + tupleSize]
+        pointDeltaData = data[dataPos : dataPos + dataSize]
+        result.append(
+            decompileTupleVariation_(
+                pointCount,
+                sharedTuples,
+                sharedPoints,
+                tableTag,
+                axisTags,
+                tupleData,
+                pointDeltaData,
+            )
+        )
+        pos += tupleSize
+        dataPos += dataSize
+    return result
+
+
+def decompileTupleVariation_(
+    pointCount, sharedTuples, sharedPoints, tableTag, axisTags, data, tupleData
+):
+    assert tableTag in ("cvar", "gvar"), tableTag
+    flags = struct.unpack(">H", data[2:4])[0]
+    pos = 4
+    if (flags & EMBEDDED_PEAK_TUPLE) == 0:
+        peak = sharedTuples[flags & TUPLE_INDEX_MASK]
+    else:
+        peak, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
+    if (flags & INTERMEDIATE_REGION) != 0:
+        start, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
+        end, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
+    else:
+        start, end = inferRegion_(peak)
+    axes = {}
+    for axis in axisTags:
+        region = start[axis], peak[axis], end[axis]
+        if region != (0.0, 0.0, 0.0):
+            axes[axis] = region
+    pos = 0
+    if (flags & PRIVATE_POINT_NUMBERS) != 0:
+        points, pos = TupleVariation.decompilePoints_(
+            pointCount, tupleData, pos, tableTag
+        )
+    else:
+        points = sharedPoints
+
+    deltas = [None] * pointCount
+
+    if tableTag == "cvar":
+        deltas_cvt, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
+        for p, delta in zip(points, deltas_cvt):
+            if 0 <= p < pointCount:
+                deltas[p] = delta
+
+    elif tableTag == "gvar":
+        deltas_x, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
+        deltas_y, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
+        for p, x, y in zip(points, deltas_x, deltas_y):
+            if 0 <= p < pointCount:
+                deltas[p] = (x, y)
+
+    return TupleVariation(axes, deltas)
+
+
+def inferRegion_(peak):
+    """Infer start and end for a (non-intermediate) region
+
+    This helper function computes the applicability region for
+    variation tuples whose INTERMEDIATE_REGION flag is not set in the
+    TupleVariationHeader structure.  Variation tuples apply only to
+    certain regions of the variation space; outside that region, the
+    tuple has no effect.  To make the binary encoding more compact,
+    TupleVariationHeaders can omit the intermediateStartTuple and
+    intermediateEndTuple fields.
+    """
+    start, end = {}, {}
+    for axis, value in peak.items():
+        start[axis] = min(value, 0.0)  # -0.3 --> -0.3; 0.7 --> 0.0
+        end[axis] = max(value, 0.0)  # -0.3 -->  0.0; 0.7 --> 0.7
+    return (start, end)

evalkit_tf437/lib/python3.10/site-packages/fontTools/ttLib/tables/V_A_R_C_.py

@@ -0,0 +1,5 @@
+from .otBase import BaseTTXConverter
+
+
+class table_V_A_R_C_(BaseTTXConverter):
+    pass