Upload folder using huggingface_hub (part 4)

.gitattributes

@@ -47,3 +47,29 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/fontTools/misc/bezierTools.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/fontTools/pens/momentsPen.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/fontTools/qu2cu/qu2cu.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/fontTools/varLib/iup.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/_conv.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/_errors.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/_npystrings.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/_objects.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/_proxy.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/_selector.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/defs.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5a.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5ac.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5d.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5ds.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5f.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5fd.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5g.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5i.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5l.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5o.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5p.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5pl.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5r.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5s.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5t.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/h5py/h5z.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.11/site-packages/fontTools/ttLib/sfnt.py

@@ -0,0 +1,664 @@
+"""ttLib/sfnt.py -- low-level module to deal with the sfnt file format.
+
+Defines two public classes:
+
+- SFNTReader
+- SFNTWriter
+
+(Normally you don't have to use these classes explicitly; they are
+used automatically by ttLib.TTFont.)
+
+The reading and writing of sfnt files is separated in two distinct
+classes, since whenever the number of tables changes or whenever
+a table's length changes you need to rewrite the whole file anyway.
+"""
+
+from __future__ import annotations
+
+from collections.abc import KeysView
+from io import BytesIO
+from types import SimpleNamespace
+from fontTools.misc.textTools import Tag
+from fontTools.misc import sstruct
+from fontTools.ttLib import TTLibError, TTLibFileIsCollectionError
+import struct
+from collections import OrderedDict
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+class SFNTReader(object):
+    def __new__(cls, *args, **kwargs):
+        """Return an instance of the SFNTReader sub-class which is compatible
+        with the input file type.
+        """
+        if args and cls is SFNTReader:
+            infile = args[0]
+            infile.seek(0)
+            sfntVersion = Tag(infile.read(4))
+            infile.seek(0)
+            if sfntVersion == "wOF2":
+                # return new WOFF2Reader object
+                from fontTools.ttLib.woff2 import WOFF2Reader
+
+                return object.__new__(WOFF2Reader)
+        # return default object
+        return object.__new__(cls)
+
+    def __init__(self, file, checkChecksums=0, fontNumber=-1):
+        self.file = file
+        self.checkChecksums = checkChecksums
+
+        self.flavor = None
+        self.flavorData = None
+        self.DirectoryEntry = SFNTDirectoryEntry
+        self.file.seek(0)
+        self.sfntVersion = self.file.read(4)
+        self.file.seek(0)
+        if self.sfntVersion == b"ttcf":
+            header = readTTCHeader(self.file)
+            numFonts = header.numFonts
+            if not 0 <= fontNumber < numFonts:
+                raise TTLibFileIsCollectionError(
+                    "specify a font number between 0 and %d (inclusive)"
+                    % (numFonts - 1)
+                )
+            self.numFonts = numFonts
+            self.file.seek(header.offsetTable[fontNumber])
+            data = self.file.read(sfntDirectorySize)
+            if len(data) != sfntDirectorySize:
+                raise TTLibError("Not a Font Collection (not enough data)")
+            sstruct.unpack(sfntDirectoryFormat, data, self)
+        elif self.sfntVersion == b"wOFF":
+            self.flavor = "woff"
+            self.DirectoryEntry = WOFFDirectoryEntry
+            data = self.file.read(woffDirectorySize)
+            if len(data) != woffDirectorySize:
+                raise TTLibError("Not a WOFF font (not enough data)")
+            sstruct.unpack(woffDirectoryFormat, data, self)
+        else:
+            data = self.file.read(sfntDirectorySize)
+            if len(data) != sfntDirectorySize:
+                raise TTLibError("Not a TrueType or OpenType font (not enough data)")
+            sstruct.unpack(sfntDirectoryFormat, data, self)
+        self.sfntVersion = Tag(self.sfntVersion)
+
+        if self.sfntVersion not in ("\x00\x01\x00\x00", "OTTO", "true"):
+            raise TTLibError("Not a TrueType or OpenType font (bad sfntVersion)")
+        tables: dict[Tag, DirectoryEntry] = {}
+        for i in range(self.numTables):
+            entry = self.DirectoryEntry()
+            entry.fromFile(self.file)
+            tag = Tag(entry.tag)
+            tables[tag] = entry
+        self.tables = OrderedDict(sorted(tables.items(), key=lambda i: i[1].offset))
+
+        # Load flavor data if any
+        if self.flavor == "woff":
+            self.flavorData = WOFFFlavorData(self)
+
+    def has_key(self, tag: str | bytes) -> bool:
+        return tag in self.tables
+
+    __contains__ = has_key
+
+    def keys(self) -> KeysView[Tag]:
+        return self.tables.keys()
+
+    def __getitem__(self, tag: str | bytes) -> bytes:
+        """Fetch the raw table data."""
+        entry = self.tables[Tag(tag)]
+        data = entry.loadData(self.file)
+        if self.checkChecksums:
+            if tag == "head":
+                # Beh: we have to special-case the 'head' table.
+                checksum = calcChecksum(data[:8] + b"\0\0\0\0" + data[12:])
+            else:
+                checksum = calcChecksum(data)
+            if self.checkChecksums > 1:
+                # Be obnoxious, and barf when it's wrong
+                assert checksum == entry.checkSum, "bad checksum for '%s' table" % tag
+            elif checksum != entry.checkSum:
+                # Be friendly, and just log a warning.
+                log.warning("bad checksum for '%s' table", tag)
+        return data
+
+    def __delitem__(self, tag: str | bytes) -> None:
+        del self.tables[Tag(tag)]
+
+    def close(self) -> None:
+        self.file.close()
+
+    # We define custom __getstate__ and __setstate__ to make SFNTReader pickle-able
+    # and deepcopy-able. When a TTFont is loaded as lazy=True, SFNTReader holds a
+    # reference to an external file object which is not pickleable. So in __getstate__
+    # we store the file name and current position, and in __setstate__ we reopen the
+    # same named file after unpickling.
+
+    def __getstate__(self):
+        if isinstance(self.file, BytesIO):
+            # BytesIO is already pickleable, return the state unmodified
+            return self.__dict__
+
+        # remove unpickleable file attribute, and only store its name and pos
+        state = self.__dict__.copy()
+        del state["file"]
+        state["_filename"] = self.file.name
+        state["_filepos"] = self.file.tell()
+        return state
+
+    def __setstate__(self, state):
+        if "file" not in state:
+            self.file = open(state.pop("_filename"), "rb")
+            self.file.seek(state.pop("_filepos"))
+        self.__dict__.update(state)
+
+
+# default compression level for WOFF 1.0 tables and metadata
+ZLIB_COMPRESSION_LEVEL = 6
+
+# if set to True, use zopfli instead of zlib for compressing WOFF 1.0.
+# The Python bindings are available at https://pypi.python.org/pypi/zopfli
+USE_ZOPFLI = False
+
+# mapping between zlib's compression levels and zopfli's 'numiterations'.
+# Use lower values for files over several MB in size or it will be too slow
+ZOPFLI_LEVELS = {
+    # 0: 0,  # can't do 0 iterations...
+    1: 1,
+    2: 3,
+    3: 5,
+    4: 8,
+    5: 10,
+    6: 15,
+    7: 25,
+    8: 50,
+    9: 100,
+}
+
+
+def compress(data, level=ZLIB_COMPRESSION_LEVEL):
+    """Compress 'data' to Zlib format. If 'USE_ZOPFLI' variable is True,
+    zopfli is used instead of the zlib module.
+    The compression 'level' must be between 0 and 9. 1 gives best speed,
+    9 gives best compression (0 gives no compression at all).
+    The default value is a compromise between speed and compression (6).
+    """
+    if not (0 <= level <= 9):
+        raise ValueError("Bad compression level: %s" % level)
+    if not USE_ZOPFLI or level == 0:
+        from zlib import compress
+
+        return compress(data, level)
+    else:
+        from zopfli.zlib import compress
+
+        return compress(data, numiterations=ZOPFLI_LEVELS[level])
+
+
+class SFNTWriter(object):
+    def __new__(cls, *args, **kwargs):
+        """Return an instance of the SFNTWriter sub-class which is compatible
+        with the specified 'flavor'.
+        """
+        flavor = None
+        if kwargs and "flavor" in kwargs:
+            flavor = kwargs["flavor"]
+        elif args and len(args) > 3:
+            flavor = args[3]
+        if cls is SFNTWriter:
+            if flavor == "woff2":
+                # return new WOFF2Writer object
+                from fontTools.ttLib.woff2 import WOFF2Writer
+
+                return object.__new__(WOFF2Writer)
+        # return default object
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        file,
+        numTables,
+        sfntVersion="\000\001\000\000",
+        flavor=None,
+        flavorData=None,
+    ):
+        self.file = file
+        self.numTables = numTables
+        self.sfntVersion = Tag(sfntVersion)
+        self.flavor = flavor
+        self.flavorData = flavorData
+
+        if self.flavor == "woff":
+            self.directoryFormat = woffDirectoryFormat
+            self.directorySize = woffDirectorySize
+            self.DirectoryEntry = WOFFDirectoryEntry
+
+            self.signature = "wOFF"
+
+            # to calculate WOFF checksum adjustment, we also need the original SFNT offsets
+            self.origNextTableOffset = (
+                sfntDirectorySize + numTables * sfntDirectoryEntrySize
+            )
+        else:
+            assert not self.flavor, "Unknown flavor '%s'" % self.flavor
+            self.directoryFormat = sfntDirectoryFormat
+            self.directorySize = sfntDirectorySize
+            self.DirectoryEntry = SFNTDirectoryEntry
+
+            from fontTools.ttLib import getSearchRange
+
+            self.searchRange, self.entrySelector, self.rangeShift = getSearchRange(
+                numTables, 16
+            )
+
+        self.directoryOffset = self.file.tell()
+        self.nextTableOffset = (
+            self.directoryOffset
+            + self.directorySize
+            + numTables * self.DirectoryEntry.formatSize
+        )
+        # clear out directory area
+        self.file.seek(self.nextTableOffset)
+        # make sure we're actually where we want to be. (old cStringIO bug)
+        self.file.write(b"\0" * (self.nextTableOffset - self.file.tell()))
+        self.tables = OrderedDict()
+
+    def setEntry(self, tag, entry):
+        if tag in self.tables:
+            raise TTLibError("cannot rewrite '%s' table" % tag)
+
+        self.tables[tag] = entry
+
+    def __setitem__(self, tag, data):
+        """Write raw table data to disk."""
+        if tag in self.tables:
+            raise TTLibError("cannot rewrite '%s' table" % tag)
+
+        entry = self.DirectoryEntry()
+        entry.tag = tag
+        entry.offset = self.nextTableOffset
+        if tag == "head":
+            entry.checkSum = calcChecksum(data[:8] + b"\0\0\0\0" + data[12:])
+            self.headTable = data
+            entry.uncompressed = True
+        else:
+            entry.checkSum = calcChecksum(data)
+        entry.saveData(self.file, data)
+
+        if self.flavor == "woff":
+            entry.origOffset = self.origNextTableOffset
+            self.origNextTableOffset += (entry.origLength + 3) & ~3
+
+        self.nextTableOffset = self.nextTableOffset + ((entry.length + 3) & ~3)
+        # Add NUL bytes to pad the table data to a 4-byte boundary.
+        # Don't depend on f.seek() as we need to add the padding even if no
+        # subsequent write follows (seek is lazy), ie. after the final table
+        # in the font.
+        self.file.write(b"\0" * (self.nextTableOffset - self.file.tell()))
+        assert self.nextTableOffset == self.file.tell()
+
+        self.setEntry(tag, entry)
+
+    def __getitem__(self, tag):
+        return self.tables[tag]
+
+    def close(self):
+        """All tables must have been written to disk. Now write the
+        directory.
+        """
+        tables = sorted(self.tables.items())
+        if len(tables) != self.numTables:
+            raise TTLibError(
+                "wrong number of tables; expected %d, found %d"
+                % (self.numTables, len(tables))
+            )
+
+        if self.flavor == "woff":
+            self.signature = b"wOFF"
+            self.reserved = 0
+
+            self.totalSfntSize = 12
+            self.totalSfntSize += 16 * len(tables)
+            for tag, entry in tables:
+                self.totalSfntSize += (entry.origLength + 3) & ~3
+
+            data = self.flavorData if self.flavorData else WOFFFlavorData()
+            if data.majorVersion is not None and data.minorVersion is not None:
+                self.majorVersion = data.majorVersion
+                self.minorVersion = data.minorVersion
+            else:
+                if hasattr(self, "headTable"):
+                    self.majorVersion, self.minorVersion = struct.unpack(
+                        ">HH", self.headTable[4:8]
+                    )
+                else:
+                    self.majorVersion = self.minorVersion = 0
+            if data.metaData:
+                self.metaOrigLength = len(data.metaData)
+                self.file.seek(0, 2)
+                self.metaOffset = self.file.tell()
+                compressedMetaData = compress(data.metaData)
+                self.metaLength = len(compressedMetaData)
+                self.file.write(compressedMetaData)
+            else:
+                self.metaOffset = self.metaLength = self.metaOrigLength = 0
+            if data.privData:
+                self.file.seek(0, 2)
+                off = self.file.tell()
+                paddedOff = (off + 3) & ~3
+                self.file.write(b"\0" * (paddedOff - off))
+                self.privOffset = self.file.tell()
+                self.privLength = len(data.privData)
+                self.file.write(data.privData)
+            else:
+                self.privOffset = self.privLength = 0
+
+            self.file.seek(0, 2)
+            self.length = self.file.tell()
+
+        else:
+            assert not self.flavor, "Unknown flavor '%s'" % self.flavor
+            pass
+
+        directory = sstruct.pack(self.directoryFormat, self)
+
+        self.file.seek(self.directoryOffset + self.directorySize)
+        seenHead = 0
+        for tag, entry in tables:
+            if tag == "head":
+                seenHead = 1
+            directory = directory + entry.toString()
+        if seenHead:
+            self.writeMasterChecksum(directory)
+        self.file.seek(self.directoryOffset)
+        self.file.write(directory)
+
+    def _calcMasterChecksum(self, directory):
+        # calculate checkSumAdjustment
+        checksums = []
+        for tag in self.tables.keys():
+            checksums.append(self.tables[tag].checkSum)
+
+        if self.DirectoryEntry != SFNTDirectoryEntry:
+            # Create a SFNT directory for checksum calculation purposes
+            from fontTools.ttLib import getSearchRange
+
+            self.searchRange, self.entrySelector, self.rangeShift = getSearchRange(
+                self.numTables, 16
+            )
+            directory = sstruct.pack(sfntDirectoryFormat, self)
+            tables = sorted(self.tables.items())
+            for tag, entry in tables:
+                sfntEntry = SFNTDirectoryEntry()
+                sfntEntry.tag = entry.tag
+                sfntEntry.checkSum = entry.checkSum
+                sfntEntry.offset = entry.origOffset
+                sfntEntry.length = entry.origLength
+                directory = directory + sfntEntry.toString()
+
+        directory_end = sfntDirectorySize + len(self.tables) * sfntDirectoryEntrySize
+        assert directory_end == len(directory)
+
+        checksums.append(calcChecksum(directory))
+        checksum = sum(checksums) & 0xFFFFFFFF
+        # BiboAfba!
+        checksumadjustment = (0xB1B0AFBA - checksum) & 0xFFFFFFFF
+        return checksumadjustment
+
+    def writeMasterChecksum(self, directory):
+        checksumadjustment = self._calcMasterChecksum(directory)
+        # write the checksum to the file
+        self.file.seek(self.tables["head"].offset + 8)
+        self.file.write(struct.pack(">L", checksumadjustment))
+
+    def reordersTables(self):
+        return False
+
+
+# -- sfnt directory helpers and cruft
+
+ttcHeaderFormat = """
+		> # big endian
+		TTCTag:                  4s # "ttcf"
+		Version:                 L  # 0x00010000 or 0x00020000
+		numFonts:                L  # number of fonts
+		# OffsetTable[numFonts]: L  # array with offsets from beginning of file
+		# ulDsigTag:             L  # version 2.0 only
+		# ulDsigLength:          L  # version 2.0 only
+		# ulDsigOffset:          L  # version 2.0 only
+"""
+
+ttcHeaderSize = sstruct.calcsize(ttcHeaderFormat)
+
+sfntDirectoryFormat = """
+		> # big endian
+		sfntVersion:    4s
+		numTables:      H    # number of tables
+		searchRange:    H    # (max2 <= numTables)*16
+		entrySelector:  H    # log2(max2 <= numTables)
+		rangeShift:     H    # numTables*16-searchRange
+"""
+
+sfntDirectorySize = sstruct.calcsize(sfntDirectoryFormat)
+
+sfntDirectoryEntryFormat = """
+		> # big endian
+		tag:            4s
+		checkSum:       L
+		offset:         L
+		length:         L
+"""
+
+sfntDirectoryEntrySize = sstruct.calcsize(sfntDirectoryEntryFormat)
+
+woffDirectoryFormat = """
+		> # big endian
+		signature:      4s   # "wOFF"
+		sfntVersion:    4s
+		length:         L    # total woff file size
+		numTables:      H    # number of tables
+		reserved:       H    # set to 0
+		totalSfntSize:  L    # uncompressed size
+		majorVersion:   H    # major version of WOFF file
+		minorVersion:   H    # minor version of WOFF file
+		metaOffset:     L    # offset to metadata block
+		metaLength:     L    # length of compressed metadata
+		metaOrigLength: L    # length of uncompressed metadata
+		privOffset:     L    # offset to private data block
+		privLength:     L    # length of private data block
+"""
+
+woffDirectorySize = sstruct.calcsize(woffDirectoryFormat)
+
+woffDirectoryEntryFormat = """
+		> # big endian
+		tag:            4s
+		offset:         L
+		length:         L    # compressed length
+		origLength:     L    # original length
+		checkSum:       L    # original checksum
+"""
+
+woffDirectoryEntrySize = sstruct.calcsize(woffDirectoryEntryFormat)
+
+
+class DirectoryEntry(object):
+    def __init__(self):
+        self.uncompressed = False  # if True, always embed entry raw
+
+    def fromFile(self, file):
+        sstruct.unpack(self.format, file.read(self.formatSize), self)
+
+    def fromString(self, str):
+        sstruct.unpack(self.format, str, self)
+
+    def toString(self):
+        return sstruct.pack(self.format, self)
+
+    def __repr__(self):
+        if hasattr(self, "tag"):
+            return "<%s '%s' at %x>" % (self.__class__.__name__, self.tag, id(self))
+        else:
+            return "<%s at %x>" % (self.__class__.__name__, id(self))
+
+    def loadData(self, file):
+        file.seek(self.offset)
+        data = file.read(self.length)
+        assert len(data) == self.length
+        if hasattr(self.__class__, "decodeData"):
+            data = self.decodeData(data)
+        return data
+
+    def saveData(self, file, data):
+        if hasattr(self.__class__, "encodeData"):
+            data = self.encodeData(data)
+        self.length = len(data)
+        file.seek(self.offset)
+        file.write(data)
+
+    def decodeData(self, rawData):
+        return rawData
+
+    def encodeData(self, data):
+        return data
+
+
+class SFNTDirectoryEntry(DirectoryEntry):
+    format = sfntDirectoryEntryFormat
+    formatSize = sfntDirectoryEntrySize
+
+
+class WOFFDirectoryEntry(DirectoryEntry):
+    format = woffDirectoryEntryFormat
+    formatSize = woffDirectoryEntrySize
+
+    def __init__(self):
+        super(WOFFDirectoryEntry, self).__init__()
+        # With fonttools<=3.1.2, the only way to set a different zlib
+        # compression level for WOFF directory entries was to set the class
+        # attribute 'zlibCompressionLevel'. This is now replaced by a globally
+        # defined `ZLIB_COMPRESSION_LEVEL`, which is also applied when
+        # compressing the metadata. For backward compatibility, we still
+        # use the class attribute if it was already set.
+        if not hasattr(WOFFDirectoryEntry, "zlibCompressionLevel"):
+            self.zlibCompressionLevel = ZLIB_COMPRESSION_LEVEL
+
+    def decodeData(self, rawData):
+        import zlib
+
+        if self.length == self.origLength:
+            data = rawData
+        else:
+            assert self.length < self.origLength
+            data = zlib.decompress(rawData)
+            assert len(data) == self.origLength
+        return data
+
+    def encodeData(self, data):
+        self.origLength = len(data)
+        if not self.uncompressed:
+            compressedData = compress(data, self.zlibCompressionLevel)
+        if self.uncompressed or len(compressedData) >= self.origLength:
+            # Encode uncompressed
+            rawData = data
+            self.length = self.origLength
+        else:
+            rawData = compressedData
+            self.length = len(rawData)
+        return rawData
+
+
+class WOFFFlavorData:
+    Flavor = "woff"
+
+    def __init__(self, reader=None):
+        self.majorVersion = None
+        self.minorVersion = None
+        self.metaData = None
+        self.privData = None
+        if reader:
+            self.majorVersion = reader.majorVersion
+            self.minorVersion = reader.minorVersion
+            if reader.metaLength:
+                reader.file.seek(reader.metaOffset)
+                rawData = reader.file.read(reader.metaLength)
+                assert len(rawData) == reader.metaLength
+                data = self._decompress(rawData)
+                assert len(data) == reader.metaOrigLength
+                self.metaData = data
+            if reader.privLength:
+                reader.file.seek(reader.privOffset)
+                data = reader.file.read(reader.privLength)
+                assert len(data) == reader.privLength
+                self.privData = data
+
+    def _decompress(self, rawData):
+        import zlib
+
+        return zlib.decompress(rawData)
+
+
+def calcChecksum(data):
+    """Calculate the checksum for an arbitrary block of data.
+
+    If the data length is not a multiple of four, it assumes
+    it is to be padded with null byte.
+
+            >>> print(calcChecksum(b"abcd"))
+            1633837924
+            >>> print(calcChecksum(b"abcdxyz"))
+            3655064932
+    """
+    remainder = len(data) % 4
+    if remainder:
+        data += b"\0" * (4 - remainder)
+    value = 0
+    blockSize = 4096
+    assert blockSize % 4 == 0
+    for i in range(0, len(data), blockSize):
+        block = data[i : i + blockSize]
+        longs = struct.unpack(">%dL" % (len(block) // 4), block)
+        value = (value + sum(longs)) & 0xFFFFFFFF
+    return value
+
+
+def readTTCHeader(file):
+    file.seek(0)
+    data = file.read(ttcHeaderSize)
+    if len(data) != ttcHeaderSize:
+        raise TTLibError("Not a Font Collection (not enough data)")
+    self = SimpleNamespace()
+    sstruct.unpack(ttcHeaderFormat, data, self)
+    if self.TTCTag != "ttcf":
+        raise TTLibError("Not a Font Collection")
+    assert self.Version == 0x00010000 or self.Version == 0x00020000, (
+        "unrecognized TTC version 0x%08x" % self.Version
+    )
+    self.offsetTable = struct.unpack(
+        ">%dL" % self.numFonts, file.read(self.numFonts * 4)
+    )
+    if self.Version == 0x00020000:
+        pass  # ignoring version 2.0 signatures
+    return self
+
+
+def writeTTCHeader(file, numFonts):
+    self = SimpleNamespace()
+    self.TTCTag = "ttcf"
+    self.Version = 0x00010000
+    self.numFonts = numFonts
+    file.seek(0)
+    file.write(sstruct.pack(ttcHeaderFormat, self))
+    offset = file.tell()
+    file.write(struct.pack(">%dL" % self.numFonts, *([0] * self.numFonts)))
+    return offset
+
+
+if __name__ == "__main__":
+    import sys
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

.venv/lib/python3.11/site-packages/fontTools/ttLib/standardGlyphOrder.py

@@ -0,0 +1,271 @@
+#
+# 'post' table formats 1.0 and 2.0 rely on this list of "standard"
+# glyphs.
+#
+# My list is correct according to the Apple documentation for the 'post'  table:
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6post.html
+# (However, it seems that TTFdump (from MS) and FontLab disagree, at
+# least with respect to the last glyph, which they list as 'dslash'
+# instead of 'dcroat'.)
+#
+
+standardGlyphOrder = [
+    ".notdef",  # 0
+    ".null",  # 1
+    "nonmarkingreturn",  # 2
+    "space",  # 3
+    "exclam",  # 4
+    "quotedbl",  # 5
+    "numbersign",  # 6
+    "dollar",  # 7
+    "percent",  # 8
+    "ampersand",  # 9
+    "quotesingle",  # 10
+    "parenleft",  # 11
+    "parenright",  # 12
+    "asterisk",  # 13
+    "plus",  # 14
+    "comma",  # 15
+    "hyphen",  # 16
+    "period",  # 17
+    "slash",  # 18
+    "zero",  # 19
+    "one",  # 20
+    "two",  # 21
+    "three",  # 22
+    "four",  # 23
+    "five",  # 24
+    "six",  # 25
+    "seven",  # 26
+    "eight",  # 27
+    "nine",  # 28
+    "colon",  # 29
+    "semicolon",  # 30
+    "less",  # 31
+    "equal",  # 32
+    "greater",  # 33
+    "question",  # 34
+    "at",  # 35
+    "A",  # 36
+    "B",  # 37
+    "C",  # 38
+    "D",  # 39
+    "E",  # 40
+    "F",  # 41
+    "G",  # 42
+    "H",  # 43
+    "I",  # 44
+    "J",  # 45
+    "K",  # 46
+    "L",  # 47
+    "M",  # 48
+    "N",  # 49
+    "O",  # 50
+    "P",  # 51
+    "Q",  # 52
+    "R",  # 53
+    "S",  # 54
+    "T",  # 55
+    "U",  # 56
+    "V",  # 57
+    "W",  # 58
+    "X",  # 59
+    "Y",  # 60
+    "Z",  # 61
+    "bracketleft",  # 62
+    "backslash",  # 63
+    "bracketright",  # 64
+    "asciicircum",  # 65
+    "underscore",  # 66
+    "grave",  # 67
+    "a",  # 68
+    "b",  # 69
+    "c",  # 70
+    "d",  # 71
+    "e",  # 72
+    "f",  # 73
+    "g",  # 74
+    "h",  # 75
+    "i",  # 76
+    "j",  # 77
+    "k",  # 78
+    "l",  # 79
+    "m",  # 80
+    "n",  # 81
+    "o",  # 82
+    "p",  # 83
+    "q",  # 84
+    "r",  # 85
+    "s",  # 86
+    "t",  # 87
+    "u",  # 88
+    "v",  # 89
+    "w",  # 90
+    "x",  # 91
+    "y",  # 92
+    "z",  # 93
+    "braceleft",  # 94
+    "bar",  # 95
+    "braceright",  # 96
+    "asciitilde",  # 97
+    "Adieresis",  # 98
+    "Aring",  # 99
+    "Ccedilla",  # 100
+    "Eacute",  # 101
+    "Ntilde",  # 102
+    "Odieresis",  # 103
+    "Udieresis",  # 104
+    "aacute",  # 105
+    "agrave",  # 106
+    "acircumflex",  # 107
+    "adieresis",  # 108
+    "atilde",  # 109
+    "aring",  # 110
+    "ccedilla",  # 111
+    "eacute",  # 112
+    "egrave",  # 113
+    "ecircumflex",  # 114
+    "edieresis",  # 115
+    "iacute",  # 116
+    "igrave",  # 117
+    "icircumflex",  # 118
+    "idieresis",  # 119
+    "ntilde",  # 120
+    "oacute",  # 121
+    "ograve",  # 122
+    "ocircumflex",  # 123
+    "odieresis",  # 124
+    "otilde",  # 125
+    "uacute",  # 126
+    "ugrave",  # 127
+    "ucircumflex",  # 128
+    "udieresis",  # 129
+    "dagger",  # 130
+    "degree",  # 131
+    "cent",  # 132
+    "sterling",  # 133
+    "section",  # 134
+    "bullet",  # 135
+    "paragraph",  # 136
+    "germandbls",  # 137
+    "registered",  # 138
+    "copyright",  # 139
+    "trademark",  # 140
+    "acute",  # 141
+    "dieresis",  # 142
+    "notequal",  # 143
+    "AE",  # 144
+    "Oslash",  # 145
+    "infinity",  # 146
+    "plusminus",  # 147
+    "lessequal",  # 148
+    "greaterequal",  # 149
+    "yen",  # 150
+    "mu",  # 151
+    "partialdiff",  # 152
+    "summation",  # 153
+    "product",  # 154
+    "pi",  # 155
+    "integral",  # 156
+    "ordfeminine",  # 157
+    "ordmasculine",  # 158
+    "Omega",  # 159
+    "ae",  # 160
+    "oslash",  # 161
+    "questiondown",  # 162
+    "exclamdown",  # 163
+    "logicalnot",  # 164
+    "radical",  # 165
+    "florin",  # 166
+    "approxequal",  # 167
+    "Delta",  # 168
+    "guillemotleft",  # 169
+    "guillemotright",  # 170
+    "ellipsis",  # 171
+    "nonbreakingspace",  # 172
+    "Agrave",  # 173
+    "Atilde",  # 174
+    "Otilde",  # 175
+    "OE",  # 176
+    "oe",  # 177
+    "endash",  # 178
+    "emdash",  # 179
+    "quotedblleft",  # 180
+    "quotedblright",  # 181
+    "quoteleft",  # 182
+    "quoteright",  # 183
+    "divide",  # 184
+    "lozenge",  # 185
+    "ydieresis",  # 186
+    "Ydieresis",  # 187
+    "fraction",  # 188
+    "currency",  # 189
+    "guilsinglleft",  # 190
+    "guilsinglright",  # 191
+    "fi",  # 192
+    "fl",  # 193
+    "daggerdbl",  # 194
+    "periodcentered",  # 195
+    "quotesinglbase",  # 196
+    "quotedblbase",  # 197
+    "perthousand",  # 198
+    "Acircumflex",  # 199
+    "Ecircumflex",  # 200
+    "Aacute",  # 201
+    "Edieresis",  # 202
+    "Egrave",  # 203
+    "Iacute",  # 204
+    "Icircumflex",  # 205
+    "Idieresis",  # 206
+    "Igrave",  # 207
+    "Oacute",  # 208
+    "Ocircumflex",  # 209
+    "apple",  # 210
+    "Ograve",  # 211
+    "Uacute",  # 212
+    "Ucircumflex",  # 213
+    "Ugrave",  # 214
+    "dotlessi",  # 215
+    "circumflex",  # 216
+    "tilde",  # 217
+    "macron",  # 218
+    "breve",  # 219
+    "dotaccent",  # 220
+    "ring",  # 221
+    "cedilla",  # 222
+    "hungarumlaut",  # 223
+    "ogonek",  # 224
+    "caron",  # 225
+    "Lslash",  # 226
+    "lslash",  # 227
+    "Scaron",  # 228
+    "scaron",  # 229
+    "Zcaron",  # 230
+    "zcaron",  # 231
+    "brokenbar",  # 232
+    "Eth",  # 233
+    "eth",  # 234
+    "Yacute",  # 235
+    "yacute",  # 236
+    "Thorn",  # 237
+    "thorn",  # 238
+    "minus",  # 239
+    "multiply",  # 240
+    "onesuperior",  # 241
+    "twosuperior",  # 242
+    "threesuperior",  # 243
+    "onehalf",  # 244
+    "onequarter",  # 245
+    "threequarters",  # 246
+    "franc",  # 247
+    "Gbreve",  # 248
+    "gbreve",  # 249
+    "Idotaccent",  # 250
+    "Scedilla",  # 251
+    "scedilla",  # 252
+    "Cacute",  # 253
+    "cacute",  # 254
+    "Ccaron",  # 255
+    "ccaron",  # 256
+    "dcroat",  # 257
+]

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/B_A_S_E_.py

@@ -0,0 +1,14 @@
+from .otBase import BaseTTXConverter
+
+
+class table_B_A_S_E_(BaseTTXConverter):
+    """Baseline table
+
+    The ``BASE`` table contains information needed to align glyphs in
+    different scripts, from different fonts, or at different sizes
+    within the same line of text.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/base
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/BitmapGlyphMetrics.py

@@ -0,0 +1,64 @@
+# Since bitmap glyph metrics are shared between EBLC and EBDT
+# this class gets its own python file.
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+import logging
+
+
+log = logging.getLogger(__name__)
+
+bigGlyphMetricsFormat = """
+  > # big endian
+  height:       B
+  width:        B
+  horiBearingX: b
+  horiBearingY: b
+  horiAdvance:  B
+  vertBearingX: b
+  vertBearingY: b
+  vertAdvance:  B
+"""
+
+smallGlyphMetricsFormat = """
+  > # big endian
+  height:   B
+  width:    B
+  BearingX: b
+  BearingY: b
+  Advance:  B
+"""
+
+
+class BitmapGlyphMetrics(object):
+    def toXML(self, writer, ttFont):
+        writer.begintag(self.__class__.__name__)
+        writer.newline()
+        for metricName in sstruct.getformat(self.__class__.binaryFormat)[1]:
+            writer.simpletag(metricName, value=getattr(self, metricName))
+            writer.newline()
+        writer.endtag(self.__class__.__name__)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        metricNames = set(sstruct.getformat(self.__class__.binaryFormat)[1])
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            # Make sure this is a metric that is needed by GlyphMetrics.
+            if name in metricNames:
+                vars(self)[name] = safeEval(attrs["value"])
+            else:
+                log.warning(
+                    "unknown name '%s' being ignored in %s.",
+                    name,
+                    self.__class__.__name__,
+                )
+
+
+class BigGlyphMetrics(BitmapGlyphMetrics):
+    binaryFormat = bigGlyphMetricsFormat
+
+
+class SmallGlyphMetrics(BitmapGlyphMetrics):
+    binaryFormat = smallGlyphMetricsFormat

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/C_B_D_T_.py

@@ -0,0 +1,113 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Matt Fontaine
+
+
+from fontTools.misc.textTools import bytesjoin
+from fontTools.misc import sstruct
+from . import E_B_D_T_
+from .BitmapGlyphMetrics import (
+    BigGlyphMetrics,
+    bigGlyphMetricsFormat,
+    SmallGlyphMetrics,
+    smallGlyphMetricsFormat,
+)
+from .E_B_D_T_ import (
+    BitmapGlyph,
+    BitmapPlusSmallMetricsMixin,
+    BitmapPlusBigMetricsMixin,
+)
+import struct
+
+
+class table_C_B_D_T_(E_B_D_T_.table_E_B_D_T_):
+    """Color Bitmap Data table
+
+    The ``CBDT`` table contains color bitmap data for glyphs. It must
+    be used in concert with the ``CBLC`` table.
+
+    It is backwards-compatible with the monochrome/grayscale ``EBDT`` table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cbdt
+    """
+
+    # Change the data locator table being referenced.
+    locatorName = "CBLC"
+
+    # Modify the format class accessor for color bitmap use.
+    def getImageFormatClass(self, imageFormat):
+        try:
+            return E_B_D_T_.table_E_B_D_T_.getImageFormatClass(self, imageFormat)
+        except KeyError:
+            return cbdt_bitmap_classes[imageFormat]
+
+
+# Helper method for removing export features not supported by color bitmaps.
+# Write data in the parent class will default to raw if an option is unsupported.
+def _removeUnsupportedForColor(dataFunctions):
+    dataFunctions = dict(dataFunctions)
+    del dataFunctions["row"]
+    return dataFunctions
+
+
+class ColorBitmapGlyph(BitmapGlyph):
+    fileExtension = ".png"
+    xmlDataFunctions = _removeUnsupportedForColor(BitmapGlyph.xmlDataFunctions)
+
+
+class cbdt_bitmap_format_17(BitmapPlusSmallMetricsMixin, ColorBitmapGlyph):
+    def decompile(self):
+        self.metrics = SmallGlyphMetrics()
+        dummy, data = sstruct.unpack2(smallGlyphMetricsFormat, self.data, self.metrics)
+        (dataLen,) = struct.unpack(">L", data[:4])
+        data = data[4:]
+
+        # For the image data cut it to the size specified by dataLen.
+        assert dataLen <= len(data), "Data overun in format 17"
+        self.imageData = data[:dataLen]
+
+    def compile(self, ttFont):
+        dataList = []
+        dataList.append(sstruct.pack(smallGlyphMetricsFormat, self.metrics))
+        dataList.append(struct.pack(">L", len(self.imageData)))
+        dataList.append(self.imageData)
+        return bytesjoin(dataList)
+
+
+class cbdt_bitmap_format_18(BitmapPlusBigMetricsMixin, ColorBitmapGlyph):
+    def decompile(self):
+        self.metrics = BigGlyphMetrics()
+        dummy, data = sstruct.unpack2(bigGlyphMetricsFormat, self.data, self.metrics)
+        (dataLen,) = struct.unpack(">L", data[:4])
+        data = data[4:]
+
+        # For the image data cut it to the size specified by dataLen.
+        assert dataLen <= len(data), "Data overun in format 18"
+        self.imageData = data[:dataLen]
+
+    def compile(self, ttFont):
+        dataList = []
+        dataList.append(sstruct.pack(bigGlyphMetricsFormat, self.metrics))
+        dataList.append(struct.pack(">L", len(self.imageData)))
+        dataList.append(self.imageData)
+        return bytesjoin(dataList)
+
+
+class cbdt_bitmap_format_19(ColorBitmapGlyph):
+    def decompile(self):
+        (dataLen,) = struct.unpack(">L", self.data[:4])
+        data = self.data[4:]
+
+        assert dataLen <= len(data), "Data overun in format 19"
+        self.imageData = data[:dataLen]
+
+    def compile(self, ttFont):
+        return struct.pack(">L", len(self.imageData)) + self.imageData
+
+
+# Dict for CBDT extended formats.
+cbdt_bitmap_classes = {
+    17: cbdt_bitmap_format_17,
+    18: cbdt_bitmap_format_18,
+    19: cbdt_bitmap_format_19,
+}

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/C_B_L_C_.py

@@ -0,0 +1,19 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Matt Fontaine
+
+from . import E_B_L_C_
+
+
+class table_C_B_L_C_(E_B_L_C_.table_E_B_L_C_):
+    """Color Bitmap Location table
+
+    The ``CBLC`` table contains the locations of color bitmaps for glyphs. It must
+    be used in concert with the ``CBDT`` table.
+
+    It is backwards-compatible with the monochrome/grayscale ``EBLC`` table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cblc
+    """
+
+    dependencies = ["CBDT"]

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/C_F_F_.py

@@ -0,0 +1,61 @@
+from io import BytesIO
+from fontTools import cffLib
+from . import DefaultTable
+
+
+class table_C_F_F_(DefaultTable.DefaultTable):
+    """Compact Font Format table (version 1)
+
+    The ``CFF`` table embeds a CFF-formatted font. The CFF font format
+    predates OpenType and could be used as a standalone font file, but the
+    ``CFF`` table is also used to package CFF fonts into an OpenType
+    container.
+
+    .. note::
+       ``CFF`` has been succeeded by ``CFF2``, which eliminates much of
+       the redundancy incurred by embedding CFF version 1 in an OpenType
+       font.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cff
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.cff = cffLib.CFFFontSet()
+        self._gaveGlyphOrder = False
+
+    def decompile(self, data, otFont):
+        self.cff.decompile(BytesIO(data), otFont, isCFF2=False)
+        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=False)
+        return f.getvalue()
+
+    def haveGlyphNames(self):
+        if hasattr(self.cff[self.cff.fontNames[0]], "ROS"):
+            return False  # CID-keyed font
+        else:
+            return True
+
+    def getGlyphOrder(self):
+        if self._gaveGlyphOrder:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError("illegal use of getGlyphOrder()")
+        self._gaveGlyphOrder = True
+        return self.cff[self.cff.fontNames[0]].getGlyphOrder()
+
+    def setGlyphOrder(self, glyphOrder):
+        pass
+        # XXX
+        # self.cff[self.cff.fontNames[0]].setGlyphOrder(glyphOrder)
+
+    def toXML(self, writer, otFont):
+        self.cff.toXML(writer)
+
+    def fromXML(self, name, attrs, content, otFont):
+        if not hasattr(self, "cff"):
+            self.cff = cffLib.CFFFontSet()
+        self.cff.fromXML(name, attrs, content, otFont)

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/C_F_F__2.py

@@ -0,0 +1,26 @@
+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_):
+    """Compact Font Format version 2 table
+
+    The ``CFF2`` table contains glyph data for a CFF2-flavored OpenType
+    font.
+
+    .. note::
+       ``CFF2`` is the successor to ``CFF``, and eliminates much of
+       the redundancy incurred by embedding CFF version 1 in an OpenType
+       font.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cff2
+    """
+
+    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()

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/C_O_L_R_.py

@@ -0,0 +1,165 @@
+# 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):
+    """Color table
+
+    The ``COLR`` table defines color presentation of outline glyphs. It must
+    be used in concert with the ``CPAL`` table, which contains the color
+    descriptors used.
+
+    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.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/colr
+    """
+
+    @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))

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/C_P_A_L_.py

@@ -0,0 +1,305 @@
+# 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):
+    """Color Palette table
+
+    The ``CPAL`` table contains a set of one or more color palettes. The color
+    records in each palette can be referenced by the ``COLR`` table to specify
+    the colors used in a color glyph.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/cpal
+    """
+
+    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)

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/D_S_I_G_.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import base64
+from typing import TYPE_CHECKING
+
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytesjoin, safeEval, strjoin, tobytes, tostr
+
+from . import DefaultTable
+
+if TYPE_CHECKING:
+    from fontTools.misc.xmlWriter import XMLWriter
+    from fontTools.ttLib import TTFont
+
+DSIG_HeaderFormat = """
+	> # big endian
+	ulVersion:      L
+	usNumSigs:      H
+	usFlag:         H
+"""
+# followed by an array of usNumSigs DSIG_Signature records
+DSIG_SignatureFormat = """
+	> # big endian
+	ulFormat:       L
+	ulLength:       L # length includes DSIG_SignatureBlock header
+	ulOffset:       L
+"""
+# followed by an array of usNumSigs DSIG_SignatureBlock records,
+# each followed immediately by the pkcs7 bytes
+DSIG_SignatureBlockFormat = """
+	> # big endian
+	usReserved1:    H
+	usReserved2:    H
+	cbSignature:    l # length of following raw pkcs7 data
+"""
+
+#
+# NOTE
+# the DSIG table format allows for SignatureBlocks residing
+# anywhere in the table and possibly in a different order as
+# listed in the array after the first table header
+#
+# this implementation does not keep track of any gaps and/or data
+# before or after the actual signature blocks while decompiling,
+# and puts them in the same physical order as listed in the header
+# on compilation with no padding whatsoever.
+#
+
+
+class table_D_S_I_G_(DefaultTable.DefaultTable):
+    """Digital Signature table
+
+    The ``DSIG`` table contains cryptographic signatures for the font.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/dsig
+    """
+
+    def decompile(self, data: bytes, ttFont: TTFont) -> None:
+        dummy, newData = sstruct.unpack2(DSIG_HeaderFormat, data, self)
+        assert self.ulVersion == 1, "DSIG ulVersion must be 1"
+        assert self.usFlag & ~1 == 0, "DSIG usFlag must be 0x1 or 0x0"
+        self.signatureRecords: list[SignatureRecord] = []
+        sigrecs = self.signatureRecords
+        for n in range(self.usNumSigs):
+            sigrec, newData = sstruct.unpack2(
+                DSIG_SignatureFormat, newData, SignatureRecord()
+            )
+            assert sigrec.ulFormat == 1, (
+                "DSIG signature record #%d ulFormat must be 1" % n
+            )
+            sigrecs.append(sigrec)
+        for sigrec in sigrecs:
+            dummy, newData = sstruct.unpack2(
+                DSIG_SignatureBlockFormat, data[sigrec.ulOffset :], sigrec
+            )
+            assert sigrec.usReserved1 == 0, (
+                "DSIG signature record #%d usReserverd1 must be 0" % n
+            )
+            assert sigrec.usReserved2 == 0, (
+                "DSIG signature record #%d usReserverd2 must be 0" % n
+            )
+            sigrec.pkcs7 = newData[: sigrec.cbSignature]
+
+    def compile(self, ttFont: TTFont) -> bytes:
+        packed = sstruct.pack(DSIG_HeaderFormat, self)
+        headers = [packed]
+        offset = len(packed) + self.usNumSigs * sstruct.calcsize(DSIG_SignatureFormat)
+        data = []
+        for sigrec in self.signatureRecords:
+            # first pack signature block
+            sigrec.cbSignature = len(sigrec.pkcs7)
+            packed = sstruct.pack(DSIG_SignatureBlockFormat, sigrec) + sigrec.pkcs7
+            data.append(packed)
+            # update redundant length field
+            sigrec.ulLength = len(packed)
+            # update running table offset
+            sigrec.ulOffset = offset
+            headers.append(sstruct.pack(DSIG_SignatureFormat, sigrec))
+            offset += sigrec.ulLength
+        if offset % 2:
+            # Pad to even bytes
+            data.append(b"\0")
+        return bytesjoin(headers + data)
+
+    def toXML(self, xmlWriter: XMLWriter, ttFont: TTFont) -> None:
+        xmlWriter.comment(
+            "note that the Digital Signature will be invalid after recompilation!"
+        )
+        xmlWriter.newline()
+        xmlWriter.simpletag(
+            "tableHeader",
+            version=self.ulVersion,
+            numSigs=self.usNumSigs,
+            flag="0x%X" % self.usFlag,
+        )
+        for sigrec in self.signatureRecords:
+            xmlWriter.newline()
+            sigrec.toXML(xmlWriter, ttFont)
+        xmlWriter.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "tableHeader":
+            self.signatureRecords = []
+            self.ulVersion = safeEval(attrs["version"])
+            self.usNumSigs = safeEval(attrs["numSigs"])
+            self.usFlag = safeEval(attrs["flag"])
+            return
+        if name == "SignatureRecord":
+            sigrec = SignatureRecord()
+            sigrec.fromXML(name, attrs, content, ttFont)
+            self.signatureRecords.append(sigrec)
+
+
+pem_spam = lambda l, spam={
+    "-----BEGIN PKCS7-----": True,
+    "-----END PKCS7-----": True,
+    "": True,
+}: not spam.get(l.strip())
+
+
+def b64encode(b):
+    s = base64.b64encode(b)
+    # Line-break at 76 chars.
+    items = []
+    while s:
+        items.append(tostr(s[:76]))
+        items.append("\n")
+        s = s[76:]
+    return strjoin(items)
+
+
+class SignatureRecord:
+    def __repr__(self) -> str:
+        return "<%s: %s>" % (self.__class__.__name__, self.__dict__)
+
+    def toXML(self, writer, ttFont: TTFont) -> None:
+        writer.begintag(self.__class__.__name__, format=self.ulFormat)
+        writer.newline()
+        writer.write_noindent("-----BEGIN PKCS7-----\n")
+        writer.write_noindent(b64encode(self.pkcs7))
+        writer.write_noindent("-----END PKCS7-----\n")
+        writer.endtag(self.__class__.__name__)
+
+    def fromXML(
+        self, name: str, attrs: dict[str, str], content: str, ttFont: TTFont
+    ) -> None:
+        self.ulFormat: int = safeEval(attrs["format"])
+        self.usReserved1: int = safeEval(attrs.get("reserved1", "0"))
+        self.usReserved2: int = safeEval(attrs.get("reserved2", "0"))
+        self.pkcs7 = base64.b64decode(tobytes(strjoin(filter(pem_spam, content))))

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/D__e_b_g.py

@@ -0,0 +1,35 @@
+import json
+from textwrap import indent
+
+from . import DefaultTable
+from fontTools.misc.textTools import tostr
+
+
+class table_D__e_b_g(DefaultTable.DefaultTable):
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.data = {}
+
+    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):
+        # make sure json indentation inside CDATA block matches XMLWriter's
+        data = json.dumps(self.data, indent=len(writer.indentwhite))
+        prefix = tostr(writer.indentwhite) * (writer.indentlevel + 1)
+        # but don't indent the first json line so it's adjacent to `<![CDATA[{`
+        cdata = indent(data, prefix, lambda ln: ln != "{\n")
+
+        writer.begintag("json")
+        writer.newline()
+        writer.writecdata(cdata)
+        writer.newline()
+        writer.endtag("json")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "json":
+            self.data = json.loads("".join(content))

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/DefaultTable.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from fontTools.misc.textTools import Tag
+from fontTools.ttLib import getClassTag
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    from fontTools.misc.xmlWriter import XMLWriter
+    from fontTools.ttLib import TTFont
+
+
+class DefaultTable:
+    dependencies: list[str] = []
+
+    def __init__(self, tag: str | bytes | None = None) -> None:
+        if tag is None:
+            tag = getClassTag(self.__class__)
+        self.tableTag = Tag(tag)
+
+    def decompile(self, data: bytes, ttFont: TTFont) -> None:
+        self.data = data
+
+    def compile(self, ttFont: TTFont) -> bytes:
+        return self.data
+
+    def toXML(
+        self, writer: XMLWriter, ttFont: TTFont, **kwargs: dict[str, Any]
+    ) -> None:
+        if hasattr(self, "ERROR"):
+            writer.comment("An error occurred during the decompilation of this table")
+            writer.newline()
+            writer.comment(self.ERROR)
+            writer.newline()
+        writer.begintag("hexdata")
+        writer.newline()
+        writer.dumphex(self.compile(ttFont))
+        writer.endtag("hexdata")
+        writer.newline()
+
+    def fromXML(
+        self, name: str, attrs: dict[str, str], content: str, ttFont: TTFont
+    ) -> None:
+        from fontTools import ttLib
+        from fontTools.misc.textTools import readHex
+
+        if name != "hexdata":
+            raise ttLib.TTLibError("can't handle '%s' element" % name)
+        self.decompile(readHex(content), ttFont)
+
+    def __repr__(self) -> str:
+        return "<'%s' table at %x>" % (self.tableTag, id(self))
+
+    def __eq__(self, other: Any) -> bool:
+        if type(self) != type(other):
+            return NotImplemented
+        return self.__dict__ == other.__dict__
+
+    def __ne__(self, other: Any) -> bool:
+        result = self.__eq__(other)
+        return result if result is NotImplemented else not result

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/E_B_D_T_.py

@@ -0,0 +1,835 @@
+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):
+    """Embedded Bitmap Data table
+
+    The ``EBDT`` table contains monochrome or grayscale bitmap data for
+    glyphs. It must be used in concert with the ``EBLC`` table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/ebdt
+    """
+
+    # 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,
+}

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/E_B_L_C_.py

@@ -0,0 +1,718 @@
+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):
+    """Embedded Bitmap Location table
+
+    The ``EBLC`` table contains the locations of monochrome or grayscale
+    bitmaps for glyphs. It must be used in concert with the ``EBDT`` table.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/eblc
+    """
+
+    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,
+}

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/F_F_T_M_.py

@@ -0,0 +1,52 @@
+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):
+    """FontForge Time Stamp table
+
+    The ``FFTM`` table is used by the free-software font editor
+    FontForge to record timestamps for the creation and modification
+    of font source (.sfd) files and a timestamp for FontForge's
+    own source code.
+
+    See also https://fontforge.org/docs/techref/non-standard.html
+    """
+
+    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)

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/F__e_a_t.py

@@ -0,0 +1,159 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import floatToFixedToStr
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+from . import grUtils
+import struct
+
+Feat_hdr_format = """
+    >
+    version:    16.16F
+"""
+
+
+class table_F__e_a_t(DefaultTable.DefaultTable):
+    """Feature table
+
+    The ``Feat`` table is used exclusively by the Graphite shaping engine
+    to store features and possible settings specified in GDL. Graphite features
+    determine what rules are applied to transform a glyph stream.
+
+    Not to be confused with ``feat``, or the OpenType Layout tables
+    ``GSUB``/``GPOS``.
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-tables
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.features = {}
+
+    def decompile(self, data, ttFont):
+        (_, data) = sstruct.unpack2(Feat_hdr_format, data, self)
+        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
+        (numFeats,) = struct.unpack(">H", data[:2])
+        data = data[8:]
+        allfeats = []
+        maxsetting = 0
+        for i in range(numFeats):
+            if self.version >= 2.0:
+                (fid, nums, _, offset, flags, lid) = struct.unpack(
+                    ">LHHLHH", data[16 * i : 16 * (i + 1)]
+                )
+                offset = int((offset - 12 - 16 * numFeats) / 4)
+            else:
+                (fid, nums, offset, flags, lid) = struct.unpack(
+                    ">HHLHH", data[12 * i : 12 * (i + 1)]
+                )
+                offset = int((offset - 12 - 12 * numFeats) / 4)
+            allfeats.append((fid, nums, offset, flags, lid))
+            maxsetting = max(maxsetting, offset + nums)
+        data = data[16 * numFeats :]
+        allsettings = []
+        for i in range(maxsetting):
+            if len(data) >= 4 * (i + 1):
+                (val, lid) = struct.unpack(">HH", data[4 * i : 4 * (i + 1)])
+                allsettings.append((val, lid))
+        for i, f in enumerate(allfeats):
+            (fid, nums, offset, flags, lid) = f
+            fobj = Feature()
+            fobj.flags = flags
+            fobj.label = lid
+            self.features[grUtils.num2tag(fid)] = fobj
+            fobj.settings = {}
+            fobj.default = None
+            fobj.index = i
+            for i in range(offset, offset + nums):
+                if i >= len(allsettings):
+                    continue
+                (vid, vlid) = allsettings[i]
+                fobj.settings[vid] = vlid
+                if fobj.default is None:
+                    fobj.default = vid
+
+    def compile(self, ttFont):
+        fdat = b""
+        vdat = b""
+        offset = 0
+        for f, v in sorted(self.features.items(), key=lambda x: x[1].index):
+            fnum = grUtils.tag2num(f)
+            if self.version >= 2.0:
+                fdat += struct.pack(
+                    ">LHHLHH",
+                    grUtils.tag2num(f),
+                    len(v.settings),
+                    0,
+                    offset * 4 + 12 + 16 * len(self.features),
+                    v.flags,
+                    v.label,
+                )
+            elif fnum > 65535:  # self healing for alphabetic ids
+                self.version = 2.0
+                return self.compile(ttFont)
+            else:
+                fdat += struct.pack(
+                    ">HHLHH",
+                    grUtils.tag2num(f),
+                    len(v.settings),
+                    offset * 4 + 12 + 12 * len(self.features),
+                    v.flags,
+                    v.label,
+                )
+            for s, l in sorted(
+                v.settings.items(), key=lambda x: (-1, x[1]) if x[0] == v.default else x
+            ):
+                vdat += struct.pack(">HH", s, l)
+            offset += len(v.settings)
+        hdr = sstruct.pack(Feat_hdr_format, self)
+        return hdr + struct.pack(">HHL", len(self.features), 0, 0) + fdat + vdat
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", version=self.version)
+        writer.newline()
+        nameTable = ttFont["name"] if "name" in ttFont else None
+        for f, v in sorted(self.features.items(), key=lambda x: x[1].index):
+            name = nameTable.getDebugName(v.label) if nameTable else None
+            if name is not None:
+                writer.newline()
+                writer.comment(name)
+                writer.newline()
+            writer.begintag(
+                "feature",
+                fid=f,
+                label=v.label,
+                flags=v.flags,
+                default=(v.default if v.default else 0),
+            )
+            writer.newline()
+            for s, l in sorted(v.settings.items()):
+                writer.simpletag("setting", value=s, label=l)
+                name = nameTable.getDebugName(l) if nameTable else None
+                if name is not None:
+                    writer.write("  ")
+                    writer.comment(name)
+                writer.newline()
+            writer.endtag("feature")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = float(safeEval(attrs["version"]))
+        elif name == "feature":
+            fid = attrs["fid"]
+            fobj = Feature()
+            fobj.flags = int(safeEval(attrs["flags"]))
+            fobj.label = int(safeEval(attrs["label"]))
+            fobj.default = int(safeEval(attrs.get("default", "0")))
+            fobj.index = len(self.features)
+            self.features[fid] = fobj
+            fobj.settings = {}
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, a, c = element
+                if tag == "setting":
+                    fobj.settings[int(safeEval(a["value"]))] = int(safeEval(a["label"]))
+
+
+class Feature(object):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G_D_E_F_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_G_D_E_F_(BaseTTXConverter):
+    """Glyph Definition table
+
+    The ``GDEF`` table stores various glyph properties that are used
+    by OpenType Layout.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/gdef
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G_P_O_S_.py

@@ -0,0 +1,14 @@
+from .otBase import BaseTTXConverter
+
+
+class table_G_P_O_S_(BaseTTXConverter):
+    """Glyph Positioning table
+
+    The ``GPOS`` table stores advanced glyph-positioning data
+    used in OpenType Layout features, such as mark attachment,
+    cursive attachment, kerning, and other position adjustments.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/gpos
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G_S_U_B_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_G_S_U_B_(BaseTTXConverter):
+    """Glyph Substitution table
+
+    The ``GSUB`` table contains glyph-substitution rules used in
+    OpenType Layout.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/gsub
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G_V_A_R_.py

@@ -0,0 +1,5 @@
+from ._g_v_a_r import table__g_v_a_r
+
+
+class table_G_V_A_R_(table__g_v_a_r):
+    gid_size = 3

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G__l_a_t.py

@@ -0,0 +1,235 @@
+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):
+    """Graphite Glyph Attributes table
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-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

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/G__l_o_c.py

@@ -0,0 +1,85 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import array
+import sys
+
+
+Gloc_header = """
+    >        # big endian
+    version: 16.16F    # Table version
+    flags:        H    # bit 0: 1=long format, 0=short format
+                       # bit 1: 1=attribute names, 0=no names
+    numAttribs:   H    # NUmber of attributes
+"""
+
+
+class table_G__l_o_c(DefaultTable.DefaultTable):
+    """Graphite Index to Glyph Atttributes table
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-tables
+    """
+
+    dependencies = ["Glat"]
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.attribIds = None
+        self.numAttribs = 0
+
+    def decompile(self, data, ttFont):
+        _, data = sstruct.unpack2(Gloc_header, data, self)
+        flags = self.flags
+        del self.flags
+        self.locations = array.array("I" if flags & 1 else "H")
+        self.locations.frombytes(data[: len(data) - self.numAttribs * (flags & 2)])
+        if sys.byteorder != "big":
+            self.locations.byteswap()
+        self.attribIds = array.array("H")
+        if flags & 2:
+            self.attribIds.frombytes(data[-self.numAttribs * 2 :])
+            if sys.byteorder != "big":
+                self.attribIds.byteswap()
+
+    def compile(self, ttFont):
+        data = sstruct.pack(
+            Gloc_header,
+            dict(
+                version=1.0,
+                flags=(bool(self.attribIds) << 1) + (self.locations.typecode == "I"),
+                numAttribs=self.numAttribs,
+            ),
+        )
+        if sys.byteorder != "big":
+            self.locations.byteswap()
+        data += self.locations.tobytes()
+        if sys.byteorder != "big":
+            self.locations.byteswap()
+        if self.attribIds:
+            if sys.byteorder != "big":
+                self.attribIds.byteswap()
+            data += self.attribIds.tobytes()
+            if sys.byteorder != "big":
+                self.attribIds.byteswap()
+        return data
+
+    def set(self, locations):
+        long_format = max(locations) >= 65536
+        self.locations = array.array("I" if long_format else "H", locations)
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("attributes", number=self.numAttribs)
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "attributes":
+            self.numAttribs = int(safeEval(attrs["number"]))
+
+    def __getitem__(self, index):
+        return self.locations[index]
+
+    def __len__(self):
+        return len(self.locations)
+
+    def __iter__(self):
+        return iter(self.locations)

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/H_V_A_R_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_H_V_A_R_(BaseTTXConverter):
+    """Horizontal Metrics Variations table
+
+    The ``HVAR`` table contains variations in horizontal glyph metrics
+    in variable fonts.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/hvar
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/I_F_T_.py

@@ -0,0 +1,12 @@
+"""IFT - Incremental Font Transfer table."""
+
+# Reference: https://github.com/googlefonts/fontations/blob/main/read-fonts/src/tables/ift.rs
+
+
+from .otBase import BaseTTXConverter
+
+
+class table_I_F_T_(BaseTTXConverter):
+    """Incremental Font Transfer table."""
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/I_F_T_X_.py

@@ -0,0 +1,12 @@
+"""IFT - Incremental Font Transfer table."""
+
+# Reference: https://github.com/googlefonts/fontations/blob/main/read-fonts/src/tables/ift.rs
+
+
+from .otBase import BaseTTXConverter
+
+
+class table_I_F_T_X_(BaseTTXConverter):
+    """Incremental Font Transfer table."""
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/J_S_T_F_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_J_S_T_F_(BaseTTXConverter):
+    """Justification table
+
+    The ``JSTF`` table contains glyph substitution and positioning
+    data used to perform text justification.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/jstf
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/L_T_S_H_.py

@@ -0,0 +1,58 @@
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+import struct
+import array
+
+# XXX I've lowered the strictness, to make sure Apple's own Chicago
+# XXX gets through. They're looking into it, I hope to raise the standards
+# XXX back to normal eventually.
+
+
+class table_L_T_S_H_(DefaultTable.DefaultTable):
+    """Linear Threshold table
+
+    The ``LTSH`` table contains per-glyph settings indicating the ppem sizes
+    at which the advance width metric should be scaled linearly, despite the
+    effects of any TrueType instructions that might otherwise alter the
+    advance width.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/ltsh
+    """
+
+    def decompile(self, data, ttFont):
+        version, numGlyphs = struct.unpack(">HH", data[:4])
+        data = data[4:]
+        assert version == 0, "unknown version: %s" % version
+        assert (len(data) % numGlyphs) < 4, "numGlyphs doesn't match data length"
+        # ouch: the assertion is not true in Chicago!
+        # assert numGlyphs == ttFont['maxp'].numGlyphs
+        yPels = array.array("B")
+        yPels.frombytes(data)
+        self.yPels = {}
+        for i in range(numGlyphs):
+            self.yPels[ttFont.getGlyphName(i)] = yPels[i]
+
+    def compile(self, ttFont):
+        version = 0
+        names = list(self.yPels.keys())
+        numGlyphs = len(names)
+        yPels = [0] * numGlyphs
+        # ouch: the assertion is not true in Chicago!
+        # assert len(self.yPels) == ttFont['maxp'].numGlyphs == numGlyphs
+        for name in names:
+            yPels[ttFont.getGlyphID(name)] = self.yPels[name]
+        yPels = array.array("B", yPels)
+        return struct.pack(">HH", version, numGlyphs) + yPels.tobytes()
+
+    def toXML(self, writer, ttFont):
+        names = sorted(self.yPels.keys())
+        for name in names:
+            writer.simpletag("yPel", name=name, value=self.yPels[name])
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if not hasattr(self, "yPels"):
+            self.yPels = {}
+        if name != "yPel":
+            return  # ignore unknown tags
+        self.yPels[attrs["name"]] = safeEval(attrs["value"])

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/M_A_T_H_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_M_A_T_H_(BaseTTXConverter):
+    """Mathematical Typesetting table
+
+    The ``MATH`` table contains a variety of information needed to
+    typeset glyphs in mathematical formulas and expressions.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/math
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/M_V_A_R_.py

@@ -0,0 +1,13 @@
+from .otBase import BaseTTXConverter
+
+
+class table_M_V_A_R_(BaseTTXConverter):
+    """Metrics Variations table
+
+    The ``MVAR`` table contains variation information for font-wide
+    metrics in a variable font.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/mvar
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/O_S_2f_2.py

@@ -0,0 +1,752 @@
+from fontTools.misc import sstruct
+from fontTools.misc.roundTools import otRound
+from fontTools.misc.textTools import safeEval, num2binary, binary2num
+from fontTools.ttLib.tables import DefaultTable
+import bisect
+import logging
+
+
+log = logging.getLogger(__name__)
+
+# panose classification
+
+panoseFormat = """
+	bFamilyType:        B
+	bSerifStyle:        B
+	bWeight:            B
+	bProportion:        B
+	bContrast:          B
+	bStrokeVariation:   B
+	bArmStyle:          B
+	bLetterForm:        B
+	bMidline:           B
+	bXHeight:           B
+"""
+
+
+class Panose(object):
+    def __init__(self, **kwargs):
+        _, names, _ = sstruct.getformat(panoseFormat)
+        for name in names:
+            setattr(self, name, kwargs.pop(name, 0))
+        for k in kwargs:
+            raise TypeError(f"Panose() got an unexpected keyword argument {k!r}")
+
+    def toXML(self, writer, ttFont):
+        formatstring, names, fixes = sstruct.getformat(panoseFormat)
+        for name in names:
+            writer.simpletag(name, value=getattr(self, name))
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        setattr(self, name, safeEval(attrs["value"]))
+
+
+# 'sfnt' OS/2 and Windows Metrics table - 'OS/2'
+
+OS2_format_0 = """
+	>   # big endian
+	version:                H       # version
+	xAvgCharWidth:          h       # average character width
+	usWeightClass:          H       # degree of thickness of strokes
+	usWidthClass:           H       # aspect ratio
+	fsType:                 H       # type flags
+	ySubscriptXSize:        h       # subscript horizontal font size
+	ySubscriptYSize:        h       # subscript vertical font size
+	ySubscriptXOffset:      h       # subscript x offset
+	ySubscriptYOffset:      h       # subscript y offset
+	ySuperscriptXSize:      h       # superscript horizontal font size
+	ySuperscriptYSize:      h       # superscript vertical font size
+	ySuperscriptXOffset:    h       # superscript x offset
+	ySuperscriptYOffset:    h       # superscript y offset
+	yStrikeoutSize:         h       # strikeout size
+	yStrikeoutPosition:     h       # strikeout position
+	sFamilyClass:           h       # font family class and subclass
+	panose:                 10s     # panose classification number
+	ulUnicodeRange1:        L       # character range
+	ulUnicodeRange2:        L       # character range
+	ulUnicodeRange3:        L       # character range
+	ulUnicodeRange4:        L       # character range
+	achVendID:              4s      # font vendor identification
+	fsSelection:            H       # font selection flags
+	usFirstCharIndex:       H       # first unicode character index
+	usLastCharIndex:        H       # last unicode character index
+	sTypoAscender:          h       # typographic ascender
+	sTypoDescender:         h       # typographic descender
+	sTypoLineGap:           h       # typographic line gap
+	usWinAscent:            H       # Windows ascender
+	usWinDescent:           H       # Windows descender
+"""
+
+OS2_format_1_addition = """
+	ulCodePageRange1:   L
+	ulCodePageRange2:   L
+"""
+
+OS2_format_2_addition = (
+    OS2_format_1_addition
+    + """
+	sxHeight:           h
+	sCapHeight:         h
+	usDefaultChar:      H
+	usBreakChar:        H
+	usMaxContext:       H
+"""
+)
+
+OS2_format_5_addition = (
+    OS2_format_2_addition
+    + """
+	usLowerOpticalPointSize:    H
+	usUpperOpticalPointSize:    H
+"""
+)
+
+bigendian = "	>	# big endian\n"
+
+OS2_format_1 = OS2_format_0 + OS2_format_1_addition
+OS2_format_2 = OS2_format_0 + OS2_format_2_addition
+OS2_format_5 = OS2_format_0 + OS2_format_5_addition
+OS2_format_1_addition = bigendian + OS2_format_1_addition
+OS2_format_2_addition = bigendian + OS2_format_2_addition
+OS2_format_5_addition = bigendian + OS2_format_5_addition
+
+
+class table_O_S_2f_2(DefaultTable.DefaultTable):
+    """OS/2 and Windows Metrics table
+
+    The ``OS/2`` table contains a variety of font-wide metrics and
+    parameters that may be useful to an operating system or other
+    software for system-integration purposes.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/os2
+    """
+
+    dependencies = ["head"]
+
+    def decompile(self, data, ttFont):
+        dummy, data = sstruct.unpack2(OS2_format_0, data, self)
+
+        if self.version == 1:
+            dummy, data = sstruct.unpack2(OS2_format_1_addition, data, self)
+        elif self.version in (2, 3, 4):
+            dummy, data = sstruct.unpack2(OS2_format_2_addition, data, self)
+        elif self.version == 5:
+            dummy, data = sstruct.unpack2(OS2_format_5_addition, data, self)
+            self.usLowerOpticalPointSize /= 20
+            self.usUpperOpticalPointSize /= 20
+        elif self.version != 0:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError(
+                "unknown format for OS/2 table: version %s" % self.version
+            )
+        if len(data):
+            log.warning("too much 'OS/2' table data")
+
+        self.panose = sstruct.unpack(panoseFormat, self.panose, Panose())
+
+    def compile(self, ttFont):
+        self.updateFirstAndLastCharIndex(ttFont)
+        panose = self.panose
+        head = ttFont["head"]
+        if (self.fsSelection & 1) and not (head.macStyle & 1 << 1):
+            log.warning(
+                "fsSelection bit 0 (italic) and "
+                "head table macStyle bit 1 (italic) should match"
+            )
+        if (self.fsSelection & 1 << 5) and not (head.macStyle & 1):
+            log.warning(
+                "fsSelection bit 5 (bold) and "
+                "head table macStyle bit 0 (bold) should match"
+            )
+        if (self.fsSelection & 1 << 6) and (self.fsSelection & 1 + (1 << 5)):
+            log.warning(
+                "fsSelection bit 6 (regular) is set, "
+                "bits 0 (italic) and 5 (bold) must be clear"
+            )
+        if self.version < 4 and self.fsSelection & 0b1110000000:
+            log.warning(
+                "fsSelection bits 7, 8 and 9 are only defined in "
+                "OS/2 table version 4 and up: version %s",
+                self.version,
+            )
+        self.panose = sstruct.pack(panoseFormat, self.panose)
+        if self.version == 0:
+            data = sstruct.pack(OS2_format_0, self)
+        elif self.version == 1:
+            data = sstruct.pack(OS2_format_1, self)
+        elif self.version in (2, 3, 4):
+            data = sstruct.pack(OS2_format_2, self)
+        elif self.version == 5:
+            d = self.__dict__.copy()
+            d["usLowerOpticalPointSize"] = round(self.usLowerOpticalPointSize * 20)
+            d["usUpperOpticalPointSize"] = round(self.usUpperOpticalPointSize * 20)
+            data = sstruct.pack(OS2_format_5, d)
+        else:
+            from fontTools import ttLib
+
+            raise ttLib.TTLibError(
+                "unknown format for OS/2 table: version %s" % self.version
+            )
+        self.panose = panose
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.comment(
+            "The fields 'usFirstCharIndex' and 'usLastCharIndex'\n"
+            "will be recalculated by the compiler"
+        )
+        writer.newline()
+        if self.version == 1:
+            format = OS2_format_1
+        elif self.version in (2, 3, 4):
+            format = OS2_format_2
+        elif self.version == 5:
+            format = OS2_format_5
+        else:
+            format = OS2_format_0
+        formatstring, names, fixes = sstruct.getformat(format)
+        for name in names:
+            value = getattr(self, name)
+            if name == "panose":
+                writer.begintag("panose")
+                writer.newline()
+                value.toXML(writer, ttFont)
+                writer.endtag("panose")
+            elif name in (
+                "ulUnicodeRange1",
+                "ulUnicodeRange2",
+                "ulUnicodeRange3",
+                "ulUnicodeRange4",
+                "ulCodePageRange1",
+                "ulCodePageRange2",
+            ):
+                writer.simpletag(name, value=num2binary(value))
+            elif name in ("fsType", "fsSelection"):
+                writer.simpletag(name, value=num2binary(value, 16))
+            elif name == "achVendID":
+                writer.simpletag(name, value=repr(value)[1:-1])
+            else:
+                writer.simpletag(name, value=value)
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "panose":
+            self.panose = panose = Panose()
+            for element in content:
+                if isinstance(element, tuple):
+                    name, attrs, content = element
+                    panose.fromXML(name, attrs, content, ttFont)
+        elif name in (
+            "ulUnicodeRange1",
+            "ulUnicodeRange2",
+            "ulUnicodeRange3",
+            "ulUnicodeRange4",
+            "ulCodePageRange1",
+            "ulCodePageRange2",
+            "fsType",
+            "fsSelection",
+        ):
+            setattr(self, name, binary2num(attrs["value"]))
+        elif name == "achVendID":
+            setattr(self, name, safeEval("'''" + attrs["value"] + "'''"))
+        else:
+            setattr(self, name, safeEval(attrs["value"]))
+
+    def updateFirstAndLastCharIndex(self, ttFont):
+        if "cmap" not in ttFont:
+            return
+        codes = set()
+        for table in getattr(ttFont["cmap"], "tables", []):
+            if table.isUnicode():
+                codes.update(table.cmap.keys())
+        if codes:
+            minCode = min(codes)
+            maxCode = max(codes)
+            # USHORT cannot hold codepoints greater than 0xFFFF
+            self.usFirstCharIndex = min(0xFFFF, minCode)
+            self.usLastCharIndex = min(0xFFFF, maxCode)
+
+    # misspelled attributes kept for legacy reasons
+
+    @property
+    def usMaxContex(self):
+        return self.usMaxContext
+
+    @usMaxContex.setter
+    def usMaxContex(self, value):
+        self.usMaxContext = value
+
+    @property
+    def fsFirstCharIndex(self):
+        return self.usFirstCharIndex
+
+    @fsFirstCharIndex.setter
+    def fsFirstCharIndex(self, value):
+        self.usFirstCharIndex = value
+
+    @property
+    def fsLastCharIndex(self):
+        return self.usLastCharIndex
+
+    @fsLastCharIndex.setter
+    def fsLastCharIndex(self, value):
+        self.usLastCharIndex = value
+
+    def getUnicodeRanges(self):
+        """Return the set of 'ulUnicodeRange*' bits currently enabled."""
+        bits = set()
+        ul1, ul2 = self.ulUnicodeRange1, self.ulUnicodeRange2
+        ul3, ul4 = self.ulUnicodeRange3, self.ulUnicodeRange4
+        for i in range(32):
+            if ul1 & (1 << i):
+                bits.add(i)
+            if ul2 & (1 << i):
+                bits.add(i + 32)
+            if ul3 & (1 << i):
+                bits.add(i + 64)
+            if ul4 & (1 << i):
+                bits.add(i + 96)
+        return bits
+
+    def setUnicodeRanges(self, bits):
+        """Set the 'ulUnicodeRange*' fields to the specified 'bits'."""
+        ul1, ul2, ul3, ul4 = 0, 0, 0, 0
+        for bit in bits:
+            if 0 <= bit < 32:
+                ul1 |= 1 << bit
+            elif 32 <= bit < 64:
+                ul2 |= 1 << (bit - 32)
+            elif 64 <= bit < 96:
+                ul3 |= 1 << (bit - 64)
+            elif 96 <= bit < 128:
+                ul4 |= 1 << (bit - 96)
+            else:
+                raise ValueError("expected 0 <= int <= 127, found: %r" % bit)
+        self.ulUnicodeRange1, self.ulUnicodeRange2 = ul1, ul2
+        self.ulUnicodeRange3, self.ulUnicodeRange4 = ul3, ul4
+
+    def recalcUnicodeRanges(self, ttFont, pruneOnly=False):
+        """Intersect the codepoints in the font's Unicode cmap subtables with
+        the Unicode block ranges defined in the OpenType specification (v1.7),
+        and set the respective 'ulUnicodeRange*' bits if there is at least ONE
+        intersection.
+        If 'pruneOnly' is True, only clear unused bits with NO intersection.
+        """
+        unicodes = set()
+        for table in ttFont["cmap"].tables:
+            if table.isUnicode():
+                unicodes.update(table.cmap.keys())
+        if pruneOnly:
+            empty = intersectUnicodeRanges(unicodes, inverse=True)
+            bits = self.getUnicodeRanges() - empty
+        else:
+            bits = intersectUnicodeRanges(unicodes)
+        self.setUnicodeRanges(bits)
+        return bits
+
+    def getCodePageRanges(self):
+        """Return the set of 'ulCodePageRange*' bits currently enabled."""
+        bits = set()
+        if self.version < 1:
+            return bits
+        ul1, ul2 = self.ulCodePageRange1, self.ulCodePageRange2
+        for i in range(32):
+            if ul1 & (1 << i):
+                bits.add(i)
+            if ul2 & (1 << i):
+                bits.add(i + 32)
+        return bits
+
+    def setCodePageRanges(self, bits):
+        """Set the 'ulCodePageRange*' fields to the specified 'bits'."""
+        ul1, ul2 = 0, 0
+        for bit in bits:
+            if 0 <= bit < 32:
+                ul1 |= 1 << bit
+            elif 32 <= bit < 64:
+                ul2 |= 1 << (bit - 32)
+            else:
+                raise ValueError(f"expected 0 <= int <= 63, found: {bit:r}")
+        if self.version < 1:
+            self.version = 1
+        self.ulCodePageRange1, self.ulCodePageRange2 = ul1, ul2
+
+    def recalcCodePageRanges(self, ttFont, pruneOnly=False):
+        unicodes = set()
+        for table in ttFont["cmap"].tables:
+            if table.isUnicode():
+                unicodes.update(table.cmap.keys())
+        bits = calcCodePageRanges(unicodes)
+        if pruneOnly:
+            bits &= self.getCodePageRanges()
+        # when no codepage ranges can be enabled, fall back to enabling bit 0
+        # (Latin 1) so that the font works in MS Word:
+        # https://github.com/googlei18n/fontmake/issues/468
+        if not bits:
+            bits = {0}
+        self.setCodePageRanges(bits)
+        return bits
+
+    def recalcAvgCharWidth(self, ttFont):
+        """Recalculate xAvgCharWidth using metrics from ttFont's 'hmtx' table.
+
+        Set it to 0 if the unlikely event 'hmtx' table is not found.
+        """
+        avg_width = 0
+        hmtx = ttFont.get("hmtx")
+        if hmtx is not None:
+            widths = [width for width, _ in hmtx.metrics.values() if width > 0]
+            if widths:
+                avg_width = otRound(sum(widths) / len(widths))
+        self.xAvgCharWidth = avg_width
+        return avg_width
+
+
+# Unicode ranges data from the OpenType OS/2 table specification v1.7
+
+OS2_UNICODE_RANGES = (
+    (("Basic Latin", (0x0000, 0x007F)),),
+    (("Latin-1 Supplement", (0x0080, 0x00FF)),),
+    (("Latin Extended-A", (0x0100, 0x017F)),),
+    (("Latin Extended-B", (0x0180, 0x024F)),),
+    (
+        ("IPA Extensions", (0x0250, 0x02AF)),
+        ("Phonetic Extensions", (0x1D00, 0x1D7F)),
+        ("Phonetic Extensions Supplement", (0x1D80, 0x1DBF)),
+    ),
+    (
+        ("Spacing Modifier Letters", (0x02B0, 0x02FF)),
+        ("Modifier Tone Letters", (0xA700, 0xA71F)),
+    ),
+    (
+        ("Combining Diacritical Marks", (0x0300, 0x036F)),
+        ("Combining Diacritical Marks Supplement", (0x1DC0, 0x1DFF)),
+    ),
+    (("Greek and Coptic", (0x0370, 0x03FF)),),
+    (("Coptic", (0x2C80, 0x2CFF)),),
+    (
+        ("Cyrillic", (0x0400, 0x04FF)),
+        ("Cyrillic Supplement", (0x0500, 0x052F)),
+        ("Cyrillic Extended-A", (0x2DE0, 0x2DFF)),
+        ("Cyrillic Extended-B", (0xA640, 0xA69F)),
+    ),
+    (("Armenian", (0x0530, 0x058F)),),
+    (("Hebrew", (0x0590, 0x05FF)),),
+    (("Vai", (0xA500, 0xA63F)),),
+    (("Arabic", (0x0600, 0x06FF)), ("Arabic Supplement", (0x0750, 0x077F))),
+    (("NKo", (0x07C0, 0x07FF)),),
+    (("Devanagari", (0x0900, 0x097F)),),
+    (("Bengali", (0x0980, 0x09FF)),),
+    (("Gurmukhi", (0x0A00, 0x0A7F)),),
+    (("Gujarati", (0x0A80, 0x0AFF)),),
+    (("Oriya", (0x0B00, 0x0B7F)),),
+    (("Tamil", (0x0B80, 0x0BFF)),),
+    (("Telugu", (0x0C00, 0x0C7F)),),
+    (("Kannada", (0x0C80, 0x0CFF)),),
+    (("Malayalam", (0x0D00, 0x0D7F)),),
+    (("Thai", (0x0E00, 0x0E7F)),),
+    (("Lao", (0x0E80, 0x0EFF)),),
+    (("Georgian", (0x10A0, 0x10FF)), ("Georgian Supplement", (0x2D00, 0x2D2F))),
+    (("Balinese", (0x1B00, 0x1B7F)),),
+    (("Hangul Jamo", (0x1100, 0x11FF)),),
+    (
+        ("Latin Extended Additional", (0x1E00, 0x1EFF)),
+        ("Latin Extended-C", (0x2C60, 0x2C7F)),
+        ("Latin Extended-D", (0xA720, 0xA7FF)),
+    ),
+    (("Greek Extended", (0x1F00, 0x1FFF)),),
+    (
+        ("General Punctuation", (0x2000, 0x206F)),
+        ("Supplemental Punctuation", (0x2E00, 0x2E7F)),
+    ),
+    (("Superscripts And Subscripts", (0x2070, 0x209F)),),
+    (("Currency Symbols", (0x20A0, 0x20CF)),),
+    (("Combining Diacritical Marks For Symbols", (0x20D0, 0x20FF)),),
+    (("Letterlike Symbols", (0x2100, 0x214F)),),
+    (("Number Forms", (0x2150, 0x218F)),),
+    (
+        ("Arrows", (0x2190, 0x21FF)),
+        ("Supplemental Arrows-A", (0x27F0, 0x27FF)),
+        ("Supplemental Arrows-B", (0x2900, 0x297F)),
+        ("Miscellaneous Symbols and Arrows", (0x2B00, 0x2BFF)),
+    ),
+    (
+        ("Mathematical Operators", (0x2200, 0x22FF)),
+        ("Supplemental Mathematical Operators", (0x2A00, 0x2AFF)),
+        ("Miscellaneous Mathematical Symbols-A", (0x27C0, 0x27EF)),
+        ("Miscellaneous Mathematical Symbols-B", (0x2980, 0x29FF)),
+    ),
+    (("Miscellaneous Technical", (0x2300, 0x23FF)),),
+    (("Control Pictures", (0x2400, 0x243F)),),
+    (("Optical Character Recognition", (0x2440, 0x245F)),),
+    (("Enclosed Alphanumerics", (0x2460, 0x24FF)),),
+    (("Box Drawing", (0x2500, 0x257F)),),
+    (("Block Elements", (0x2580, 0x259F)),),
+    (("Geometric Shapes", (0x25A0, 0x25FF)),),
+    (("Miscellaneous Symbols", (0x2600, 0x26FF)),),
+    (("Dingbats", (0x2700, 0x27BF)),),
+    (("CJK Symbols And Punctuation", (0x3000, 0x303F)),),
+    (("Hiragana", (0x3040, 0x309F)),),
+    (
+        ("Katakana", (0x30A0, 0x30FF)),
+        ("Katakana Phonetic Extensions", (0x31F0, 0x31FF)),
+    ),
+    (("Bopomofo", (0x3100, 0x312F)), ("Bopomofo Extended", (0x31A0, 0x31BF))),
+    (("Hangul Compatibility Jamo", (0x3130, 0x318F)),),
+    (("Phags-pa", (0xA840, 0xA87F)),),
+    (("Enclosed CJK Letters And Months", (0x3200, 0x32FF)),),
+    (("CJK Compatibility", (0x3300, 0x33FF)),),
+    (("Hangul Syllables", (0xAC00, 0xD7AF)),),
+    (("Non-Plane 0 *", (0xD800, 0xDFFF)),),
+    (("Phoenician", (0x10900, 0x1091F)),),
+    (
+        ("CJK Unified Ideographs", (0x4E00, 0x9FFF)),
+        ("CJK Radicals Supplement", (0x2E80, 0x2EFF)),
+        ("Kangxi Radicals", (0x2F00, 0x2FDF)),
+        ("Ideographic Description Characters", (0x2FF0, 0x2FFF)),
+        ("CJK Unified Ideographs Extension A", (0x3400, 0x4DBF)),
+        ("CJK Unified Ideographs Extension B", (0x20000, 0x2A6DF)),
+        ("Kanbun", (0x3190, 0x319F)),
+    ),
+    (("Private Use Area (plane 0)", (0xE000, 0xF8FF)),),
+    (
+        ("CJK Strokes", (0x31C0, 0x31EF)),
+        ("CJK Compatibility Ideographs", (0xF900, 0xFAFF)),
+        ("CJK Compatibility Ideographs Supplement", (0x2F800, 0x2FA1F)),
+    ),
+    (("Alphabetic Presentation Forms", (0xFB00, 0xFB4F)),),
+    (("Arabic Presentation Forms-A", (0xFB50, 0xFDFF)),),
+    (("Combining Half Marks", (0xFE20, 0xFE2F)),),
+    (
+        ("Vertical Forms", (0xFE10, 0xFE1F)),
+        ("CJK Compatibility Forms", (0xFE30, 0xFE4F)),
+    ),
+    (("Small Form Variants", (0xFE50, 0xFE6F)),),
+    (("Arabic Presentation Forms-B", (0xFE70, 0xFEFF)),),
+    (("Halfwidth And Fullwidth Forms", (0xFF00, 0xFFEF)),),
+    (("Specials", (0xFFF0, 0xFFFF)),),
+    (("Tibetan", (0x0F00, 0x0FFF)),),
+    (("Syriac", (0x0700, 0x074F)),),
+    (("Thaana", (0x0780, 0x07BF)),),
+    (("Sinhala", (0x0D80, 0x0DFF)),),
+    (("Myanmar", (0x1000, 0x109F)),),
+    (
+        ("Ethiopic", (0x1200, 0x137F)),
+        ("Ethiopic Supplement", (0x1380, 0x139F)),
+        ("Ethiopic Extended", (0x2D80, 0x2DDF)),
+    ),
+    (("Cherokee", (0x13A0, 0x13FF)),),
+    (("Unified Canadian Aboriginal Syllabics", (0x1400, 0x167F)),),
+    (("Ogham", (0x1680, 0x169F)),),
+    (("Runic", (0x16A0, 0x16FF)),),
+    (("Khmer", (0x1780, 0x17FF)), ("Khmer Symbols", (0x19E0, 0x19FF))),
+    (("Mongolian", (0x1800, 0x18AF)),),
+    (("Braille Patterns", (0x2800, 0x28FF)),),
+    (("Yi Syllables", (0xA000, 0xA48F)), ("Yi Radicals", (0xA490, 0xA4CF))),
+    (
+        ("Tagalog", (0x1700, 0x171F)),
+        ("Hanunoo", (0x1720, 0x173F)),
+        ("Buhid", (0x1740, 0x175F)),
+        ("Tagbanwa", (0x1760, 0x177F)),
+    ),
+    (("Old Italic", (0x10300, 0x1032F)),),
+    (("Gothic", (0x10330, 0x1034F)),),
+    (("Deseret", (0x10400, 0x1044F)),),
+    (
+        ("Byzantine Musical Symbols", (0x1D000, 0x1D0FF)),
+        ("Musical Symbols", (0x1D100, 0x1D1FF)),
+        ("Ancient Greek Musical Notation", (0x1D200, 0x1D24F)),
+    ),
+    (("Mathematical Alphanumeric Symbols", (0x1D400, 0x1D7FF)),),
+    (
+        ("Private Use (plane 15)", (0xF0000, 0xFFFFD)),
+        ("Private Use (plane 16)", (0x100000, 0x10FFFD)),
+    ),
+    (
+        ("Variation Selectors", (0xFE00, 0xFE0F)),
+        ("Variation Selectors Supplement", (0xE0100, 0xE01EF)),
+    ),
+    (("Tags", (0xE0000, 0xE007F)),),
+    (("Limbu", (0x1900, 0x194F)),),
+    (("Tai Le", (0x1950, 0x197F)),),
+    (("New Tai Lue", (0x1980, 0x19DF)),),
+    (("Buginese", (0x1A00, 0x1A1F)),),
+    (("Glagolitic", (0x2C00, 0x2C5F)),),
+    (("Tifinagh", (0x2D30, 0x2D7F)),),
+    (("Yijing Hexagram Symbols", (0x4DC0, 0x4DFF)),),
+    (("Syloti Nagri", (0xA800, 0xA82F)),),
+    (
+        ("Linear B Syllabary", (0x10000, 0x1007F)),
+        ("Linear B Ideograms", (0x10080, 0x100FF)),
+        ("Aegean Numbers", (0x10100, 0x1013F)),
+    ),
+    (("Ancient Greek Numbers", (0x10140, 0x1018F)),),
+    (("Ugaritic", (0x10380, 0x1039F)),),
+    (("Old Persian", (0x103A0, 0x103DF)),),
+    (("Shavian", (0x10450, 0x1047F)),),
+    (("Osmanya", (0x10480, 0x104AF)),),
+    (("Cypriot Syllabary", (0x10800, 0x1083F)),),
+    (("Kharoshthi", (0x10A00, 0x10A5F)),),
+    (("Tai Xuan Jing Symbols", (0x1D300, 0x1D35F)),),
+    (
+        ("Cuneiform", (0x12000, 0x123FF)),
+        ("Cuneiform Numbers and Punctuation", (0x12400, 0x1247F)),
+    ),
+    (("Counting Rod Numerals", (0x1D360, 0x1D37F)),),
+    (("Sundanese", (0x1B80, 0x1BBF)),),
+    (("Lepcha", (0x1C00, 0x1C4F)),),
+    (("Ol Chiki", (0x1C50, 0x1C7F)),),
+    (("Saurashtra", (0xA880, 0xA8DF)),),
+    (("Kayah Li", (0xA900, 0xA92F)),),
+    (("Rejang", (0xA930, 0xA95F)),),
+    (("Cham", (0xAA00, 0xAA5F)),),
+    (("Ancient Symbols", (0x10190, 0x101CF)),),
+    (("Phaistos Disc", (0x101D0, 0x101FF)),),
+    (
+        ("Carian", (0x102A0, 0x102DF)),
+        ("Lycian", (0x10280, 0x1029F)),
+        ("Lydian", (0x10920, 0x1093F)),
+    ),
+    (("Domino Tiles", (0x1F030, 0x1F09F)), ("Mahjong Tiles", (0x1F000, 0x1F02F))),
+)
+
+
+_unicodeStarts = []
+_unicodeValues = [None]
+
+
+def _getUnicodeRanges():
+    # build the ranges of codepoints for each unicode range bit, and cache result
+    if not _unicodeStarts:
+        unicodeRanges = [
+            (start, (stop, bit))
+            for bit, blocks in enumerate(OS2_UNICODE_RANGES)
+            for _, (start, stop) in blocks
+        ]
+        for start, (stop, bit) in sorted(unicodeRanges):
+            _unicodeStarts.append(start)
+            _unicodeValues.append((stop, bit))
+    return _unicodeStarts, _unicodeValues
+
+
+def intersectUnicodeRanges(unicodes, inverse=False):
+    """Intersect a sequence of (int) Unicode codepoints with the Unicode block
+    ranges defined in the OpenType specification v1.7, and return the set of
+    'ulUnicodeRanges' bits for which there is at least ONE intersection.
+    If 'inverse' is True, return the the bits for which there is NO intersection.
+
+    >>> intersectUnicodeRanges([0x0410]) == {9}
+    True
+    >>> intersectUnicodeRanges([0x0410, 0x1F000]) == {9, 57, 122}
+    True
+    >>> intersectUnicodeRanges([0x0410, 0x1F000], inverse=True) == (
+    ...     set(range(len(OS2_UNICODE_RANGES))) - {9, 57, 122})
+    True
+    """
+    unicodes = set(unicodes)
+    unicodestarts, unicodevalues = _getUnicodeRanges()
+    bits = set()
+    for code in unicodes:
+        stop, bit = unicodevalues[bisect.bisect(unicodestarts, code)]
+        if code <= stop:
+            bits.add(bit)
+    # The spec says that bit 57 ("Non Plane 0") implies that there's
+    # at least one codepoint beyond the BMP; so I also include all
+    # the non-BMP codepoints here
+    if any(0x10000 <= code < 0x110000 for code in unicodes):
+        bits.add(57)
+    return set(range(len(OS2_UNICODE_RANGES))) - bits if inverse else bits
+
+
+def calcCodePageRanges(unicodes):
+    """Given a set of Unicode codepoints (integers), calculate the
+    corresponding OS/2 CodePage range bits.
+    This is a direct translation of FontForge implementation:
+    https://github.com/fontforge/fontforge/blob/7b2c074/fontforge/tottf.c#L3158
+    """
+    bits = set()
+    hasAscii = set(range(0x20, 0x7E)).issubset(unicodes)
+    hasLineart = ord("┤") in unicodes
+
+    for uni in unicodes:
+        if uni == ord("Þ") and hasAscii:
+            bits.add(0)  # Latin 1
+        elif uni == ord("Ľ") and hasAscii:
+            bits.add(1)  # Latin 2: Eastern Europe
+            if hasLineart:
+                bits.add(58)  # Latin 2
+        elif uni == ord("Б"):
+            bits.add(2)  # Cyrillic
+            if ord("Ѕ") in unicodes and hasLineart:
+                bits.add(57)  # IBM Cyrillic
+            if ord("╜") in unicodes and hasLineart:
+                bits.add(49)  # MS-DOS Russian
+        elif uni == ord("Ά"):
+            bits.add(3)  # Greek
+            if hasLineart and ord("½") in unicodes:
+                bits.add(48)  # IBM Greek
+            if hasLineart and ord("√") in unicodes:
+                bits.add(60)  # Greek, former 437 G
+        elif uni == ord("İ") and hasAscii:
+            bits.add(4)  # Turkish
+            if hasLineart:
+                bits.add(56)  # IBM turkish
+        elif uni == ord("א"):
+            bits.add(5)  # Hebrew
+            if hasLineart and ord("√") in unicodes:
+                bits.add(53)  # Hebrew
+        elif uni == ord("ر"):
+            bits.add(6)  # Arabic
+            if ord("√") in unicodes:
+                bits.add(51)  # Arabic
+            if hasLineart:
+                bits.add(61)  # Arabic; ASMO 708
+        elif uni == ord("ŗ") and hasAscii:
+            bits.add(7)  # Windows Baltic
+            if hasLineart:
+                bits.add(59)  # MS-DOS Baltic
+        elif uni == ord("₫") and hasAscii:
+            bits.add(8)  # Vietnamese
+        elif uni == ord("ๅ"):
+            bits.add(16)  # Thai
+        elif uni == ord("エ"):
+            bits.add(17)  # JIS/Japan
+        elif uni == ord("ㄅ"):
+            bits.add(18)  # Chinese: Simplified
+        elif uni == ord("ㄱ"):
+            bits.add(19)  # Korean wansung
+        elif uni == ord("央"):
+            bits.add(20)  # Chinese: Traditional
+        elif uni == ord("곴"):
+            bits.add(21)  # Korean Johab
+        elif uni == ord("♥") and hasAscii:
+            bits.add(30)  # OEM Character Set
+        # TODO: Symbol bit has a special meaning (check the spec), we need
+        # to confirm if this is wanted by default.
+        # elif chr(0xF000) <= char <= chr(0xF0FF):
+        #    codepageRanges.add(31)          # Symbol Character Set
+        elif uni == ord("þ") and hasAscii and hasLineart:
+            bits.add(54)  # MS-DOS Icelandic
+        elif uni == ord("╚") and hasAscii:
+            bits.add(62)  # WE/Latin 1
+            bits.add(63)  # US
+        elif hasAscii and hasLineart and ord("√") in unicodes:
+            if uni == ord("Å"):
+                bits.add(50)  # MS-DOS Nordic
+            elif uni == ord("é"):
+                bits.add(52)  # MS-DOS Canadian French
+            elif uni == ord("õ"):
+                bits.add(55)  # MS-DOS Portuguese
+
+    if hasAscii and ord("‰") in unicodes and ord("∑") in unicodes:
+        bits.add(29)  # Macintosh Character Set (US Roman)
+
+    return bits
+
+
+if __name__ == "__main__":
+    import doctest, sys
+
+    sys.exit(doctest.testmod().failed)

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/S_T_A_T_.py

@@ -0,0 +1,15 @@
+from .otBase import BaseTTXConverter
+
+
+class table_S_T_A_T_(BaseTTXConverter):
+    """Style Attributes table
+
+    The ``STAT`` table records stylistic or typeface-design attributes that
+    differentiate the individual fonts within a font family from one another.
+    Those attributes can be used to assist users when navigating the style
+    variations of a variable font or a family of static fonts.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/stat
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/S_V_G_.py

@@ -0,0 +1,223 @@
+"""Compiles/decompiles SVG table.
+
+https://docs.microsoft.com/en-us/typography/opentype/spec/svg
+
+The XML format is:
+
+.. code-block:: xml
+
+	<SVG>
+		<svgDoc endGlyphID="1" startGlyphID="1">
+			<![CDATA[ <complete SVG doc> ]]
+		</svgDoc>
+	...
+		<svgDoc endGlyphID="n" startGlyphID="m">
+			<![CDATA[ <complete SVG doc> ]]
+		</svgDoc>
+	</SVG>
+"""
+
+from fontTools.misc.textTools import bytesjoin, safeEval, strjoin, tobytes, tostr
+from fontTools.misc import sstruct
+from . import DefaultTable
+from collections.abc import Sequence
+from dataclasses import dataclass, astuple
+from io import BytesIO
+import struct
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+SVG_format_0 = """
+	>   # big endian
+	version:                  H
+	offsetToSVGDocIndex:      L
+	reserved:                 L
+"""
+
+SVG_format_0Size = sstruct.calcsize(SVG_format_0)
+
+doc_index_entry_format_0 = """
+	>   # big endian
+	startGlyphID:             H
+	endGlyphID:               H
+	svgDocOffset:             L
+	svgDocLength:             L
+"""
+
+doc_index_entry_format_0Size = sstruct.calcsize(doc_index_entry_format_0)
+
+
+class table_S_V_G_(DefaultTable.DefaultTable):
+    """Scalable Vector Graphics table
+
+    The ``SVG`` table contains representations for glyphs in the SVG
+    image format.
+
+    See also https://learn.microsoft.com/en-us/typography/opentype/spec/stat
+    """
+
+    def decompile(self, data, ttFont):
+        self.docList = []
+        # Version 0 is the standardized version of the table; and current.
+        # https://www.microsoft.com/typography/otspec/svg.htm
+        sstruct.unpack(SVG_format_0, data[:SVG_format_0Size], self)
+        if self.version != 0:
+            log.warning(
+                "Unknown SVG table version '%s'. Decompiling as version 0.",
+                self.version,
+            )
+        # read in SVG Documents Index
+        # data starts with the first entry of the entry list.
+        pos = subTableStart = self.offsetToSVGDocIndex
+        self.numEntries = struct.unpack(">H", data[pos : pos + 2])[0]
+        pos += 2
+        if self.numEntries > 0:
+            data2 = data[pos:]
+            entries = []
+            for i in range(self.numEntries):
+                record_data = data2[
+                    i
+                    * doc_index_entry_format_0Size : (i + 1)
+                    * doc_index_entry_format_0Size
+                ]
+                docIndexEntry = sstruct.unpack(
+                    doc_index_entry_format_0, record_data, DocumentIndexEntry()
+                )
+                entries.append(docIndexEntry)
+
+            for entry in entries:
+                start = entry.svgDocOffset + subTableStart
+                end = start + entry.svgDocLength
+                doc = data[start:end]
+                compressed = False
+                if doc.startswith(b"\x1f\x8b"):
+                    import gzip
+
+                    bytesIO = BytesIO(doc)
+                    with gzip.GzipFile(None, "r", fileobj=bytesIO) as gunzipper:
+                        doc = gunzipper.read()
+                    del bytesIO
+                    compressed = True
+                doc = tostr(doc, "utf_8")
+                self.docList.append(
+                    SVGDocument(doc, entry.startGlyphID, entry.endGlyphID, compressed)
+                )
+
+    def compile(self, ttFont):
+        version = 0
+        offsetToSVGDocIndex = (
+            SVG_format_0Size  # I start the SVGDocIndex right after the header.
+        )
+        # get SGVDoc info.
+        docList = []
+        entryList = []
+        numEntries = len(self.docList)
+        datum = struct.pack(">H", numEntries)
+        entryList.append(datum)
+        curOffset = len(datum) + doc_index_entry_format_0Size * numEntries
+        seenDocs = {}
+        allCompressed = getattr(self, "compressed", False)
+        for i, doc in enumerate(self.docList):
+            if isinstance(doc, (list, tuple)):
+                doc = SVGDocument(*doc)
+                self.docList[i] = doc
+            docBytes = tobytes(doc.data, encoding="utf_8")
+            if (allCompressed or doc.compressed) and not docBytes.startswith(
+                b"\x1f\x8b"
+            ):
+                import gzip
+
+                bytesIO = BytesIO()
+                # mtime=0 strips the useless timestamp and makes gzip output reproducible;
+                # equivalent to `gzip -n`
+                with gzip.GzipFile(None, "w", fileobj=bytesIO, mtime=0) as gzipper:
+                    gzipper.write(docBytes)
+                gzipped = bytesIO.getvalue()
+                if len(gzipped) < len(docBytes):
+                    docBytes = gzipped
+                del gzipped, bytesIO
+            docLength = len(docBytes)
+            if docBytes in seenDocs:
+                docOffset = seenDocs[docBytes]
+            else:
+                docOffset = curOffset
+                curOffset += docLength
+                seenDocs[docBytes] = docOffset
+                docList.append(docBytes)
+            entry = struct.pack(
+                ">HHLL", doc.startGlyphID, doc.endGlyphID, docOffset, docLength
+            )
+            entryList.append(entry)
+        entryList.extend(docList)
+        svgDocData = bytesjoin(entryList)
+
+        reserved = 0
+        header = struct.pack(">HLL", version, offsetToSVGDocIndex, reserved)
+        data = [header, svgDocData]
+        data = bytesjoin(data)
+        return data
+
+    def toXML(self, writer, ttFont):
+        for i, doc in enumerate(self.docList):
+            if isinstance(doc, (list, tuple)):
+                doc = SVGDocument(*doc)
+                self.docList[i] = doc
+            attrs = {"startGlyphID": doc.startGlyphID, "endGlyphID": doc.endGlyphID}
+            if doc.compressed:
+                attrs["compressed"] = 1
+            writer.begintag("svgDoc", **attrs)
+            writer.newline()
+            writer.writecdata(doc.data)
+            writer.newline()
+            writer.endtag("svgDoc")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "svgDoc":
+            if not hasattr(self, "docList"):
+                self.docList = []
+            doc = strjoin(content)
+            doc = doc.strip()
+            startGID = int(attrs["startGlyphID"])
+            endGID = int(attrs["endGlyphID"])
+            compressed = bool(safeEval(attrs.get("compressed", "0")))
+            self.docList.append(SVGDocument(doc, startGID, endGID, compressed))
+        else:
+            log.warning("Unknown %s %s", name, content)
+
+
+class DocumentIndexEntry(object):
+    def __init__(self):
+        self.startGlyphID = None  # USHORT
+        self.endGlyphID = None  # USHORT
+        self.svgDocOffset = None  # ULONG
+        self.svgDocLength = None  # ULONG
+
+    def __repr__(self):
+        return (
+            "startGlyphID: %s, endGlyphID: %s, svgDocOffset: %s, svgDocLength: %s"
+            % (self.startGlyphID, self.endGlyphID, self.svgDocOffset, self.svgDocLength)
+        )
+
+
+@dataclass
+class SVGDocument(Sequence):
+    data: str
+    startGlyphID: int
+    endGlyphID: int
+    compressed: bool = False
+
+    # Previously, the SVG table's docList attribute contained a lists of 3 items:
+    # [doc, startGlyphID, endGlyphID]; later, we added a `compressed` attribute.
+    # For backward compatibility with code that depends of them being sequences of
+    # fixed length=3, we subclass the Sequence abstract base class and pretend only
+    # the first three items are present. 'compressed' is only accessible via named
+    # attribute lookup like regular dataclasses: i.e. `doc.compressed`, not `doc[3]`
+    def __getitem__(self, index):
+        return astuple(self)[:3][index]
+
+    def __len__(self):
+        return 3

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/S__i_l_f.py

@@ -0,0 +1,1040 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import floatToFixedToStr
+from fontTools.misc.textTools import byteord, safeEval
+
+# from itertools import *
+from . import DefaultTable
+from . import grUtils
+from array import array
+from functools import reduce
+import struct, re, sys
+
+Silf_hdr_format = """
+    >
+    version:            16.16F
+"""
+
+Silf_hdr_format_3 = """
+    >
+    version:            16.16F
+    compilerVersion:    L
+    numSilf:            H
+                        x
+                        x
+"""
+
+Silf_part1_format_v3 = """
+    >
+    ruleVersion:        16.16F
+    passOffset:         H
+    pseudosOffset:      H
+"""
+
+Silf_part1_format = """
+    >
+    maxGlyphID:         H
+    extraAscent:        h
+    extraDescent:       h
+    numPasses:          B
+    iSubst:             B
+    iPos:               B
+    iJust:              B
+    iBidi:              B
+    flags:              B
+    maxPreContext:      B
+    maxPostContext:     B
+    attrPseudo:         B
+    attrBreakWeight:    B
+    attrDirectionality: B
+    attrMirroring:      B
+    attrSkipPasses:     B
+    numJLevels:         B
+"""
+
+Silf_justify_format = """
+    >
+    attrStretch:        B
+    attrShrink:         B
+    attrStep:           B
+    attrWeight:         B
+    runto:              B
+                        x
+                        x
+                        x
+"""
+
+Silf_part2_format = """
+    >
+    numLigComp:         H
+    numUserDefn:        B
+    maxCompPerLig:      B
+    direction:          B
+    attCollisions:      B
+                        x
+                        x
+                        x
+    numCritFeatures:    B
+"""
+
+Silf_pseudomap_format = """
+    >
+    unicode:            L
+    nPseudo:            H
+"""
+
+Silf_pseudomap_format_h = """
+    >
+    unicode:            H
+    nPseudo:            H
+"""
+
+Silf_classmap_format = """
+    >
+    numClass:           H
+    numLinear:          H
+"""
+
+Silf_lookupclass_format = """
+    >
+    numIDs:             H
+    searchRange:        H
+    entrySelector:      H
+    rangeShift:         H
+"""
+
+Silf_lookuppair_format = """
+    >
+    glyphId:            H
+    index:              H
+"""
+
+Silf_pass_format = """
+    >
+    flags:              B
+    maxRuleLoop:        B
+    maxRuleContext:     B
+    maxBackup:          B
+    numRules:           H
+    fsmOffset:          H
+    pcCode:             L
+    rcCode:             L
+    aCode:              L
+    oDebug:             L
+    numRows:            H
+    numTransitional:    H
+    numSuccess:         H
+    numColumns:         H
+"""
+
+aCode_info = (
+    ("NOP", 0),
+    ("PUSH_BYTE", "b"),
+    ("PUSH_BYTE_U", "B"),
+    ("PUSH_SHORT", ">h"),
+    ("PUSH_SHORT_U", ">H"),
+    ("PUSH_LONG", ">L"),
+    ("ADD", 0),
+    ("SUB", 0),
+    ("MUL", 0),
+    ("DIV", 0),
+    ("MIN", 0),
+    ("MAX", 0),
+    ("NEG", 0),
+    ("TRUNC8", 0),
+    ("TRUNC16", 0),
+    ("COND", 0),
+    ("AND", 0),  # x10
+    ("OR", 0),
+    ("NOT", 0),
+    ("EQUAL", 0),
+    ("NOT_EQ", 0),
+    ("LESS", 0),
+    ("GTR", 0),
+    ("LESS_EQ", 0),
+    ("GTR_EQ", 0),
+    ("NEXT", 0),
+    ("NEXT_N", "b"),
+    ("COPY_NEXT", 0),
+    ("PUT_GLYPH_8BIT_OBS", "B"),
+    ("PUT_SUBS_8BIT_OBS", "bBB"),
+    ("PUT_COPY", "b"),
+    ("INSERT", 0),
+    ("DELETE", 0),  # x20
+    ("ASSOC", -1),
+    ("CNTXT_ITEM", "bB"),
+    ("ATTR_SET", "B"),
+    ("ATTR_ADD", "B"),
+    ("ATTR_SUB", "B"),
+    ("ATTR_SET_SLOT", "B"),
+    ("IATTR_SET_SLOT", "BB"),
+    ("PUSH_SLOT_ATTR", "Bb"),
+    ("PUSH_GLYPH_ATTR_OBS", "Bb"),
+    ("PUSH_GLYPH_METRIC", "Bbb"),
+    ("PUSH_FEAT", "Bb"),
+    ("PUSH_ATT_TO_GATTR_OBS", "Bb"),
+    ("PUSH_ATT_TO_GLYPH_METRIC", "Bbb"),
+    ("PUSH_ISLOT_ATTR", "Bbb"),
+    ("PUSH_IGLYPH_ATTR", "Bbb"),
+    ("POP_RET", 0),  # x30
+    ("RET_ZERO", 0),
+    ("RET_TRUE", 0),
+    ("IATTR_SET", "BB"),
+    ("IATTR_ADD", "BB"),
+    ("IATTR_SUB", "BB"),
+    ("PUSH_PROC_STATE", "B"),
+    ("PUSH_VERSION", 0),
+    ("PUT_SUBS", ">bHH"),
+    ("PUT_SUBS2", 0),
+    ("PUT_SUBS3", 0),
+    ("PUT_GLYPH", ">H"),
+    ("PUSH_GLYPH_ATTR", ">Hb"),
+    ("PUSH_ATT_TO_GLYPH_ATTR", ">Hb"),
+    ("BITOR", 0),
+    ("BITAND", 0),
+    ("BITNOT", 0),  # x40
+    ("BITSET", ">HH"),
+    ("SET_FEAT", "Bb"),
+)
+aCode_map = dict([(x[0], (i, x[1])) for i, x in enumerate(aCode_info)])
+
+
+def disassemble(aCode):
+    codelen = len(aCode)
+    pc = 0
+    res = []
+    while pc < codelen:
+        opcode = byteord(aCode[pc : pc + 1])
+        if opcode > len(aCode_info):
+            instr = aCode_info[0]
+        else:
+            instr = aCode_info[opcode]
+        pc += 1
+        if instr[1] != 0 and pc >= codelen:
+            return res
+        if instr[1] == -1:
+            count = byteord(aCode[pc])
+            fmt = "%dB" % count
+            pc += 1
+        elif instr[1] == 0:
+            fmt = ""
+        else:
+            fmt = instr[1]
+        if fmt == "":
+            res.append(instr[0])
+            continue
+        parms = struct.unpack_from(fmt, aCode[pc:])
+        res.append(instr[0] + "(" + ", ".join(map(str, parms)) + ")")
+        pc += struct.calcsize(fmt)
+    return res
+
+
+instre = re.compile(r"^\s*([^(]+)\s*(?:\(([^)]+)\))?")
+
+
+def assemble(instrs):
+    res = b""
+    for inst in instrs:
+        m = instre.match(inst)
+        if not m or not m.group(1) in aCode_map:
+            continue
+        opcode, parmfmt = aCode_map[m.group(1)]
+        res += struct.pack("B", opcode)
+        if m.group(2):
+            if parmfmt == 0:
+                continue
+            parms = [int(x) for x in re.split(r",\s*", m.group(2))]
+            if parmfmt == -1:
+                l = len(parms)
+                res += struct.pack(("%dB" % (l + 1)), l, *parms)
+            else:
+                res += struct.pack(parmfmt, *parms)
+    return res
+
+
+def writecode(tag, writer, instrs):
+    writer.begintag(tag)
+    writer.newline()
+    for l in disassemble(instrs):
+        writer.write(l)
+        writer.newline()
+    writer.endtag(tag)
+    writer.newline()
+
+
+def readcode(content):
+    res = []
+    for e in content_string(content).split("\n"):
+        e = e.strip()
+        if not len(e):
+            continue
+        res.append(e)
+    return assemble(res)
+
+
+attrs_info = (
+    "flags",
+    "extraAscent",
+    "extraDescent",
+    "maxGlyphID",
+    "numLigComp",
+    "numUserDefn",
+    "maxCompPerLig",
+    "direction",
+    "lbGID",
+)
+attrs_passindexes = ("iSubst", "iPos", "iJust", "iBidi")
+attrs_contexts = ("maxPreContext", "maxPostContext")
+attrs_attributes = (
+    "attrPseudo",
+    "attrBreakWeight",
+    "attrDirectionality",
+    "attrMirroring",
+    "attrSkipPasses",
+    "attCollisions",
+)
+pass_attrs_info = (
+    "flags",
+    "maxRuleLoop",
+    "maxRuleContext",
+    "maxBackup",
+    "minRulePreContext",
+    "maxRulePreContext",
+    "collisionThreshold",
+)
+pass_attrs_fsm = ("numRows", "numTransitional", "numSuccess", "numColumns")
+
+
+def writesimple(tag, self, writer, *attrkeys):
+    attrs = dict([(k, getattr(self, k)) for k in attrkeys])
+    writer.simpletag(tag, **attrs)
+    writer.newline()
+
+
+def getSimple(self, attrs, *attr_list):
+    for k in attr_list:
+        if k in attrs:
+            setattr(self, k, int(safeEval(attrs[k])))
+
+
+def content_string(contents):
+    res = ""
+    for element in contents:
+        if isinstance(element, tuple):
+            continue
+        res += element
+    return res.strip()
+
+
+def wrapline(writer, dat, length=80):
+    currline = ""
+    for d in dat:
+        if len(currline) > length:
+            writer.write(currline[:-1])
+            writer.newline()
+            currline = ""
+        currline += d + " "
+    if len(currline):
+        writer.write(currline[:-1])
+        writer.newline()
+
+
+class _Object:
+    pass
+
+
+class table_S__i_l_f(DefaultTable.DefaultTable):
+    """Graphite Rules table
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-tables
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.silfs = []
+
+    def decompile(self, data, ttFont):
+        sstruct.unpack2(Silf_hdr_format, data, self)
+        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
+        if self.version >= 5.0:
+            (data, self.scheme) = grUtils.decompress(data)
+            sstruct.unpack2(Silf_hdr_format_3, data, self)
+            base = sstruct.calcsize(Silf_hdr_format_3)
+        elif self.version < 3.0:
+            self.numSilf = struct.unpack(">H", data[4:6])
+            self.scheme = 0
+            self.compilerVersion = 0
+            base = 8
+        else:
+            self.scheme = 0
+            sstruct.unpack2(Silf_hdr_format_3, data, self)
+            base = sstruct.calcsize(Silf_hdr_format_3)
+
+        silfoffsets = struct.unpack_from((">%dL" % self.numSilf), data[base:])
+        for offset in silfoffsets:
+            s = Silf()
+            self.silfs.append(s)
+            s.decompile(data[offset:], ttFont, self.version)
+
+    def compile(self, ttFont):
+        self.numSilf = len(self.silfs)
+        if self.version < 3.0:
+            hdr = sstruct.pack(Silf_hdr_format, self)
+            hdr += struct.pack(">HH", self.numSilf, 0)
+        else:
+            hdr = sstruct.pack(Silf_hdr_format_3, self)
+        offset = len(hdr) + 4 * self.numSilf
+        data = b""
+        for s in self.silfs:
+            hdr += struct.pack(">L", offset)
+            subdata = s.compile(ttFont, self.version)
+            offset += len(subdata)
+            data += subdata
+        if self.version >= 5.0:
+            return grUtils.compress(self.scheme, hdr + data)
+        return hdr + data
+
+    def toXML(self, writer, ttFont):
+        writer.comment("Attributes starting with _ are informative only")
+        writer.newline()
+        writer.simpletag(
+            "version",
+            version=self.version,
+            compilerVersion=self.compilerVersion,
+            compressionScheme=self.scheme,
+        )
+        writer.newline()
+        for s in self.silfs:
+            writer.begintag("silf")
+            writer.newline()
+            s.toXML(writer, ttFont, self.version)
+            writer.endtag("silf")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.scheme = int(safeEval(attrs["compressionScheme"]))
+            self.version = float(safeEval(attrs["version"]))
+            self.compilerVersion = int(safeEval(attrs["compilerVersion"]))
+            return
+        if name == "silf":
+            s = Silf()
+            self.silfs.append(s)
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, attrs, subcontent = element
+                s.fromXML(tag, attrs, subcontent, ttFont, self.version)
+
+
+class Silf(object):
+    """A particular Silf subtable"""
+
+    def __init__(self):
+        self.passes = []
+        self.scriptTags = []
+        self.critFeatures = []
+        self.jLevels = []
+        self.pMap = {}
+
+    def decompile(self, data, ttFont, version=2.0):
+        if version >= 3.0:
+            _, data = sstruct.unpack2(Silf_part1_format_v3, data, self)
+            self.ruleVersion = float(
+                floatToFixedToStr(self.ruleVersion, precisionBits=16)
+            )
+        _, data = sstruct.unpack2(Silf_part1_format, data, self)
+        for jlevel in range(self.numJLevels):
+            j, data = sstruct.unpack2(Silf_justify_format, data, _Object())
+            self.jLevels.append(j)
+        _, data = sstruct.unpack2(Silf_part2_format, data, self)
+        if self.numCritFeatures:
+            self.critFeatures = struct.unpack_from(
+                (">%dH" % self.numCritFeatures), data
+            )
+        data = data[self.numCritFeatures * 2 + 1 :]
+        (numScriptTag,) = struct.unpack_from("B", data)
+        if numScriptTag:
+            self.scriptTags = [
+                struct.unpack("4s", data[x : x + 4])[0].decode("ascii")
+                for x in range(1, 1 + 4 * numScriptTag, 4)
+            ]
+        data = data[1 + 4 * numScriptTag :]
+        (self.lbGID,) = struct.unpack(">H", data[:2])
+        if self.numPasses:
+            self.oPasses = struct.unpack(
+                (">%dL" % (self.numPasses + 1)), data[2 : 6 + 4 * self.numPasses]
+            )
+        data = data[6 + 4 * self.numPasses :]
+        (numPseudo,) = struct.unpack(">H", data[:2])
+        for i in range(numPseudo):
+            if version >= 3.0:
+                pseudo = sstruct.unpack(
+                    Silf_pseudomap_format, data[8 + 6 * i : 14 + 6 * i], _Object()
+                )
+            else:
+                pseudo = sstruct.unpack(
+                    Silf_pseudomap_format_h, data[8 + 4 * i : 12 + 4 * i], _Object()
+                )
+            self.pMap[pseudo.unicode] = ttFont.getGlyphName(pseudo.nPseudo)
+        data = data[8 + 6 * numPseudo :]
+        currpos = (
+            sstruct.calcsize(Silf_part1_format)
+            + sstruct.calcsize(Silf_justify_format) * self.numJLevels
+            + sstruct.calcsize(Silf_part2_format)
+            + 2 * self.numCritFeatures
+            + 1
+            + 1
+            + 4 * numScriptTag
+            + 6
+            + 4 * self.numPasses
+            + 8
+            + 6 * numPseudo
+        )
+        if version >= 3.0:
+            currpos += sstruct.calcsize(Silf_part1_format_v3)
+        self.classes = Classes()
+        self.classes.decompile(data, ttFont, version)
+        for i in range(self.numPasses):
+            p = Pass()
+            self.passes.append(p)
+            p.decompile(
+                data[self.oPasses[i] - currpos : self.oPasses[i + 1] - currpos],
+                ttFont,
+                version,
+            )
+
+    def compile(self, ttFont, version=2.0):
+        self.numPasses = len(self.passes)
+        self.numJLevels = len(self.jLevels)
+        self.numCritFeatures = len(self.critFeatures)
+        numPseudo = len(self.pMap)
+        data = b""
+        if version >= 3.0:
+            hdroffset = sstruct.calcsize(Silf_part1_format_v3)
+        else:
+            hdroffset = 0
+        data += sstruct.pack(Silf_part1_format, self)
+        for j in self.jLevels:
+            data += sstruct.pack(Silf_justify_format, j)
+        data += sstruct.pack(Silf_part2_format, self)
+        if self.numCritFeatures:
+            data += struct.pack((">%dH" % self.numCritFeaturs), *self.critFeatures)
+        data += struct.pack("BB", 0, len(self.scriptTags))
+        if len(self.scriptTags):
+            tdata = [struct.pack("4s", x.encode("ascii")) for x in self.scriptTags]
+            data += b"".join(tdata)
+        data += struct.pack(">H", self.lbGID)
+        self.passOffset = len(data)
+
+        data1 = grUtils.bininfo(numPseudo, 6)
+        currpos = hdroffset + len(data) + 4 * (self.numPasses + 1)
+        self.pseudosOffset = currpos + len(data1)
+        for u, p in sorted(self.pMap.items()):
+            data1 += struct.pack(
+                (">LH" if version >= 3.0 else ">HH"), u, ttFont.getGlyphID(p)
+            )
+        data1 += self.classes.compile(ttFont, version)
+        currpos += len(data1)
+        data2 = b""
+        datao = b""
+        for i, p in enumerate(self.passes):
+            base = currpos + len(data2)
+            datao += struct.pack(">L", base)
+            data2 += p.compile(ttFont, base, version)
+        datao += struct.pack(">L", currpos + len(data2))
+
+        if version >= 3.0:
+            data3 = sstruct.pack(Silf_part1_format_v3, self)
+        else:
+            data3 = b""
+        return data3 + data + datao + data1 + data2
+
+    def toXML(self, writer, ttFont, version=2.0):
+        if version >= 3.0:
+            writer.simpletag("version", ruleVersion=self.ruleVersion)
+            writer.newline()
+        writesimple("info", self, writer, *attrs_info)
+        writesimple("passindexes", self, writer, *attrs_passindexes)
+        writesimple("contexts", self, writer, *attrs_contexts)
+        writesimple("attributes", self, writer, *attrs_attributes)
+        if len(self.jLevels):
+            writer.begintag("justifications")
+            writer.newline()
+            jformat, jnames, jfixes = sstruct.getformat(Silf_justify_format)
+            for i, j in enumerate(self.jLevels):
+                attrs = dict([(k, getattr(j, k)) for k in jnames])
+                writer.simpletag("justify", **attrs)
+                writer.newline()
+            writer.endtag("justifications")
+            writer.newline()
+        if len(self.critFeatures):
+            writer.begintag("critFeatures")
+            writer.newline()
+            writer.write(" ".join(map(str, self.critFeatures)))
+            writer.newline()
+            writer.endtag("critFeatures")
+            writer.newline()
+        if len(self.scriptTags):
+            writer.begintag("scriptTags")
+            writer.newline()
+            writer.write(" ".join(self.scriptTags))
+            writer.newline()
+            writer.endtag("scriptTags")
+            writer.newline()
+        if self.pMap:
+            writer.begintag("pseudoMap")
+            writer.newline()
+            for k, v in sorted(self.pMap.items()):
+                writer.simpletag("pseudo", unicode=hex(k), pseudo=v)
+                writer.newline()
+            writer.endtag("pseudoMap")
+            writer.newline()
+        self.classes.toXML(writer, ttFont, version)
+        if len(self.passes):
+            writer.begintag("passes")
+            writer.newline()
+            for i, p in enumerate(self.passes):
+                writer.begintag("pass", _index=i)
+                writer.newline()
+                p.toXML(writer, ttFont, version)
+                writer.endtag("pass")
+                writer.newline()
+            writer.endtag("passes")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont, version=2.0):
+        if name == "version":
+            self.ruleVersion = float(safeEval(attrs.get("ruleVersion", "0")))
+        if name == "info":
+            getSimple(self, attrs, *attrs_info)
+        elif name == "passindexes":
+            getSimple(self, attrs, *attrs_passindexes)
+        elif name == "contexts":
+            getSimple(self, attrs, *attrs_contexts)
+        elif name == "attributes":
+            getSimple(self, attrs, *attrs_attributes)
+        elif name == "justifications":
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                (tag, attrs, subcontent) = element
+                if tag == "justify":
+                    j = _Object()
+                    for k, v in attrs.items():
+                        setattr(j, k, int(v))
+                    self.jLevels.append(j)
+        elif name == "critFeatures":
+            self.critFeatures = []
+            element = content_string(content)
+            self.critFeatures.extend(map(int, element.split()))
+        elif name == "scriptTags":
+            self.scriptTags = []
+            element = content_string(content)
+            for n in element.split():
+                self.scriptTags.append(n)
+        elif name == "pseudoMap":
+            self.pMap = {}
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                (tag, attrs, subcontent) = element
+                if tag == "pseudo":
+                    k = int(attrs["unicode"], 16)
+                    v = attrs["pseudo"]
+                self.pMap[k] = v
+        elif name == "classes":
+            self.classes = Classes()
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, attrs, subcontent = element
+                self.classes.fromXML(tag, attrs, subcontent, ttFont, version)
+        elif name == "passes":
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, attrs, subcontent = element
+                if tag == "pass":
+                    p = Pass()
+                    for e in subcontent:
+                        if not isinstance(e, tuple):
+                            continue
+                        p.fromXML(e[0], e[1], e[2], ttFont, version)
+                    self.passes.append(p)
+
+
+class Classes(object):
+    def __init__(self):
+        self.linear = []
+        self.nonLinear = []
+
+    def decompile(self, data, ttFont, version=2.0):
+        sstruct.unpack2(Silf_classmap_format, data, self)
+        if version >= 4.0:
+            oClasses = struct.unpack(
+                (">%dL" % (self.numClass + 1)), data[4 : 8 + 4 * self.numClass]
+            )
+        else:
+            oClasses = struct.unpack(
+                (">%dH" % (self.numClass + 1)), data[4 : 6 + 2 * self.numClass]
+            )
+        for s, e in zip(oClasses[: self.numLinear], oClasses[1 : self.numLinear + 1]):
+            self.linear.append(
+                ttFont.getGlyphName(x)
+                for x in struct.unpack((">%dH" % ((e - s) / 2)), data[s:e])
+            )
+        for s, e in zip(
+            oClasses[self.numLinear : self.numClass],
+            oClasses[self.numLinear + 1 : self.numClass + 1],
+        ):
+            nonLinids = [
+                struct.unpack(">HH", data[x : x + 4]) for x in range(s + 8, e, 4)
+            ]
+            nonLin = dict([(ttFont.getGlyphName(x[0]), x[1]) for x in nonLinids])
+            self.nonLinear.append(nonLin)
+
+    def compile(self, ttFont, version=2.0):
+        data = b""
+        oClasses = []
+        if version >= 4.0:
+            offset = 8 + 4 * (len(self.linear) + len(self.nonLinear))
+        else:
+            offset = 6 + 2 * (len(self.linear) + len(self.nonLinear))
+        for l in self.linear:
+            oClasses.append(len(data) + offset)
+            gs = [ttFont.getGlyphID(x) for x in l]
+            data += struct.pack((">%dH" % len(l)), *gs)
+        for l in self.nonLinear:
+            oClasses.append(len(data) + offset)
+            gs = [(ttFont.getGlyphID(x[0]), x[1]) for x in l.items()]
+            data += grUtils.bininfo(len(gs))
+            data += b"".join([struct.pack(">HH", *x) for x in sorted(gs)])
+        oClasses.append(len(data) + offset)
+        self.numClass = len(oClasses) - 1
+        self.numLinear = len(self.linear)
+        return (
+            sstruct.pack(Silf_classmap_format, self)
+            + struct.pack(
+                ((">%dL" if version >= 4.0 else ">%dH") % len(oClasses)), *oClasses
+            )
+            + data
+        )
+
+    def toXML(self, writer, ttFont, version=2.0):
+        writer.begintag("classes")
+        writer.newline()
+        writer.begintag("linearClasses")
+        writer.newline()
+        for i, l in enumerate(self.linear):
+            writer.begintag("linear", _index=i)
+            writer.newline()
+            wrapline(writer, l)
+            writer.endtag("linear")
+            writer.newline()
+        writer.endtag("linearClasses")
+        writer.newline()
+        writer.begintag("nonLinearClasses")
+        writer.newline()
+        for i, l in enumerate(self.nonLinear):
+            writer.begintag("nonLinear", _index=i + self.numLinear)
+            writer.newline()
+            for inp, ind in l.items():
+                writer.simpletag("map", glyph=inp, index=ind)
+                writer.newline()
+            writer.endtag("nonLinear")
+            writer.newline()
+        writer.endtag("nonLinearClasses")
+        writer.newline()
+        writer.endtag("classes")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont, version=2.0):
+        if name == "linearClasses":
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, attrs, subcontent = element
+                if tag == "linear":
+                    l = content_string(subcontent).split()
+                    self.linear.append(l)
+        elif name == "nonLinearClasses":
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, attrs, subcontent = element
+                if tag == "nonLinear":
+                    l = {}
+                    for e in subcontent:
+                        if not isinstance(e, tuple):
+                            continue
+                        tag, attrs, subsubcontent = e
+                        if tag == "map":
+                            l[attrs["glyph"]] = int(safeEval(attrs["index"]))
+                    self.nonLinear.append(l)
+
+
+class Pass(object):
+    def __init__(self):
+        self.colMap = {}
+        self.rules = []
+        self.rulePreContexts = []
+        self.ruleSortKeys = []
+        self.ruleConstraints = []
+        self.passConstraints = b""
+        self.actions = []
+        self.stateTrans = []
+        self.startStates = []
+
+    def decompile(self, data, ttFont, version=2.0):
+        _, data = sstruct.unpack2(Silf_pass_format, data, self)
+        (numRange, _, _, _) = struct.unpack(">4H", data[:8])
+        data = data[8:]
+        for i in range(numRange):
+            (first, last, col) = struct.unpack(">3H", data[6 * i : 6 * i + 6])
+            for g in range(first, last + 1):
+                self.colMap[ttFont.getGlyphName(g)] = col
+        data = data[6 * numRange :]
+        oRuleMap = struct.unpack_from((">%dH" % (self.numSuccess + 1)), data)
+        data = data[2 + 2 * self.numSuccess :]
+        rules = struct.unpack_from((">%dH" % oRuleMap[-1]), data)
+        self.rules = [rules[s:e] for (s, e) in zip(oRuleMap, oRuleMap[1:])]
+        data = data[2 * oRuleMap[-1] :]
+        (self.minRulePreContext, self.maxRulePreContext) = struct.unpack("BB", data[:2])
+        numStartStates = self.maxRulePreContext - self.minRulePreContext + 1
+        self.startStates = struct.unpack(
+            (">%dH" % numStartStates), data[2 : 2 + numStartStates * 2]
+        )
+        data = data[2 + numStartStates * 2 :]
+        self.ruleSortKeys = struct.unpack(
+            (">%dH" % self.numRules), data[: 2 * self.numRules]
+        )
+        data = data[2 * self.numRules :]
+        self.rulePreContexts = struct.unpack(
+            ("%dB" % self.numRules), data[: self.numRules]
+        )
+        data = data[self.numRules :]
+        (self.collisionThreshold, pConstraint) = struct.unpack(">BH", data[:3])
+        oConstraints = list(
+            struct.unpack(
+                (">%dH" % (self.numRules + 1)), data[3 : 5 + self.numRules * 2]
+            )
+        )
+        data = data[5 + self.numRules * 2 :]
+        oActions = list(
+            struct.unpack((">%dH" % (self.numRules + 1)), data[: 2 + self.numRules * 2])
+        )
+        data = data[2 * self.numRules + 2 :]
+        for i in range(self.numTransitional):
+            a = array(
+                "H", data[i * self.numColumns * 2 : (i + 1) * self.numColumns * 2]
+            )
+            if sys.byteorder != "big":
+                a.byteswap()
+            self.stateTrans.append(a)
+        data = data[self.numTransitional * self.numColumns * 2 + 1 :]
+        self.passConstraints = data[:pConstraint]
+        data = data[pConstraint:]
+        for i in range(len(oConstraints) - 2, -1, -1):
+            if oConstraints[i] == 0:
+                oConstraints[i] = oConstraints[i + 1]
+        self.ruleConstraints = [
+            (data[s:e] if (e - s > 1) else b"")
+            for (s, e) in zip(oConstraints, oConstraints[1:])
+        ]
+        data = data[oConstraints[-1] :]
+        self.actions = [
+            (data[s:e] if (e - s > 1) else "") for (s, e) in zip(oActions, oActions[1:])
+        ]
+        data = data[oActions[-1] :]
+        # not using debug
+
+    def compile(self, ttFont, base, version=2.0):
+        # build it all up backwards
+        oActions = reduce(
+            lambda a, x: (a[0] + len(x), a[1] + [a[0]]), self.actions + [b""], (0, [])
+        )[1]
+        oConstraints = reduce(
+            lambda a, x: (a[0] + len(x), a[1] + [a[0]]),
+            self.ruleConstraints + [b""],
+            (1, []),
+        )[1]
+        constraintCode = b"\000" + b"".join(self.ruleConstraints)
+        transes = []
+        for t in self.stateTrans:
+            if sys.byteorder != "big":
+                t.byteswap()
+            transes.append(t.tobytes())
+            if sys.byteorder != "big":
+                t.byteswap()
+        if not len(transes):
+            self.startStates = [0]
+        oRuleMap = reduce(
+            lambda a, x: (a[0] + len(x), a[1] + [a[0]]), self.rules + [[]], (0, [])
+        )[1]
+        passRanges = []
+        gidcolmap = dict([(ttFont.getGlyphID(x[0]), x[1]) for x in self.colMap.items()])
+        for e in grUtils.entries(gidcolmap, sameval=True):
+            if e[1]:
+                passRanges.append((e[0], e[0] + e[1] - 1, e[2][0]))
+        self.numRules = len(self.actions)
+        self.fsmOffset = (
+            sstruct.calcsize(Silf_pass_format)
+            + 8
+            + len(passRanges) * 6
+            + len(oRuleMap) * 2
+            + 2 * oRuleMap[-1]
+            + 2
+            + 2 * len(self.startStates)
+            + 3 * self.numRules
+            + 3
+            + 4 * self.numRules
+            + 4
+        )
+        self.pcCode = (
+            self.fsmOffset + 2 * self.numTransitional * self.numColumns + 1 + base
+        )
+        self.rcCode = self.pcCode + len(self.passConstraints)
+        self.aCode = self.rcCode + len(constraintCode)
+        self.oDebug = 0
+        # now generate output
+        data = sstruct.pack(Silf_pass_format, self)
+        data += grUtils.bininfo(len(passRanges), 6)
+        data += b"".join(struct.pack(">3H", *p) for p in passRanges)
+        data += struct.pack((">%dH" % len(oRuleMap)), *oRuleMap)
+        flatrules = reduce(lambda a, x: a + x, self.rules, [])
+        data += struct.pack((">%dH" % oRuleMap[-1]), *flatrules)
+        data += struct.pack("BB", self.minRulePreContext, self.maxRulePreContext)
+        data += struct.pack((">%dH" % len(self.startStates)), *self.startStates)
+        data += struct.pack((">%dH" % self.numRules), *self.ruleSortKeys)
+        data += struct.pack(("%dB" % self.numRules), *self.rulePreContexts)
+        data += struct.pack(">BH", self.collisionThreshold, len(self.passConstraints))
+        data += struct.pack((">%dH" % (self.numRules + 1)), *oConstraints)
+        data += struct.pack((">%dH" % (self.numRules + 1)), *oActions)
+        return (
+            data
+            + b"".join(transes)
+            + struct.pack("B", 0)
+            + self.passConstraints
+            + constraintCode
+            + b"".join(self.actions)
+        )
+
+    def toXML(self, writer, ttFont, version=2.0):
+        writesimple("info", self, writer, *pass_attrs_info)
+        writesimple("fsminfo", self, writer, *pass_attrs_fsm)
+        writer.begintag("colmap")
+        writer.newline()
+        wrapline(
+            writer,
+            [
+                "{}={}".format(*x)
+                for x in sorted(
+                    self.colMap.items(), key=lambda x: ttFont.getGlyphID(x[0])
+                )
+            ],
+        )
+        writer.endtag("colmap")
+        writer.newline()
+        writer.begintag("staterulemap")
+        writer.newline()
+        for i, r in enumerate(self.rules):
+            writer.simpletag(
+                "state",
+                number=self.numRows - self.numSuccess + i,
+                rules=" ".join(map(str, r)),
+            )
+            writer.newline()
+        writer.endtag("staterulemap")
+        writer.newline()
+        writer.begintag("rules")
+        writer.newline()
+        for i, action in enumerate(self.actions):
+            writer.begintag(
+                "rule",
+                index=i,
+                precontext=self.rulePreContexts[i],
+                sortkey=self.ruleSortKeys[i],
+            )
+            writer.newline()
+            if len(self.ruleConstraints[i]):
+                writecode("constraint", writer, self.ruleConstraints[i])
+            writecode("action", writer, action)
+            writer.endtag("rule")
+            writer.newline()
+        writer.endtag("rules")
+        writer.newline()
+        if len(self.passConstraints):
+            writecode("passConstraint", writer, self.passConstraints)
+        if len(self.stateTrans):
+            writer.begintag("fsm")
+            writer.newline()
+            writer.begintag("starts")
+            writer.write(" ".join(map(str, self.startStates)))
+            writer.endtag("starts")
+            writer.newline()
+            for i, s in enumerate(self.stateTrans):
+                writer.begintag("row", _i=i)
+                # no newlines here
+                writer.write(" ".join(map(str, s)))
+                writer.endtag("row")
+                writer.newline()
+            writer.endtag("fsm")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont, version=2.0):
+        if name == "info":
+            getSimple(self, attrs, *pass_attrs_info)
+        elif name == "fsminfo":
+            getSimple(self, attrs, *pass_attrs_fsm)
+        elif name == "colmap":
+            e = content_string(content)
+            for w in e.split():
+                x = w.split("=")
+                if len(x) != 2 or x[0] == "" or x[1] == "":
+                    continue
+                self.colMap[x[0]] = int(x[1])
+        elif name == "staterulemap":
+            for e in content:
+                if not isinstance(e, tuple):
+                    continue
+                tag, a, c = e
+                if tag == "state":
+                    self.rules.append([int(x) for x in a["rules"].split(" ")])
+        elif name == "rules":
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, a, c = element
+                if tag != "rule":
+                    continue
+                self.rulePreContexts.append(int(a["precontext"]))
+                self.ruleSortKeys.append(int(a["sortkey"]))
+                con = b""
+                act = b""
+                for e in c:
+                    if not isinstance(e, tuple):
+                        continue
+                    tag, a, subc = e
+                    if tag == "constraint":
+                        con = readcode(subc)
+                    elif tag == "action":
+                        act = readcode(subc)
+                self.actions.append(act)
+                self.ruleConstraints.append(con)
+        elif name == "passConstraint":
+            self.passConstraints = readcode(content)
+        elif name == "fsm":
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, a, c = element
+                if tag == "row":
+                    s = array("H")
+                    e = content_string(c)
+                    s.extend(map(int, e.split()))
+                    self.stateTrans.append(s)
+                elif tag == "starts":
+                    s = []
+                    e = content_string(c)
+                    s.extend(map(int, e.split()))
+                    self.startStates = s

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/S__i_l_l.py

@@ -0,0 +1,92 @@
+from fontTools.misc import sstruct
+from fontTools.misc.fixedTools import floatToFixedToStr
+from fontTools.misc.textTools import safeEval
+from . import DefaultTable
+from . import grUtils
+import struct
+
+Sill_hdr = """
+    >
+    version:    16.16F
+"""
+
+
+class table_S__i_l_l(DefaultTable.DefaultTable):
+    """Graphite Languages table
+
+    See also https://graphite.sil.org/graphite_techAbout#graphite-font-tables
+    """
+
+    def __init__(self, tag=None):
+        DefaultTable.DefaultTable.__init__(self, tag)
+        self.langs = {}
+
+    def decompile(self, data, ttFont):
+        (_, data) = sstruct.unpack2(Sill_hdr, data, self)
+        self.version = float(floatToFixedToStr(self.version, precisionBits=16))
+        (numLangs,) = struct.unpack(">H", data[:2])
+        data = data[8:]
+        maxsetting = 0
+        langinfo = []
+        for i in range(numLangs):
+            (langcode, numsettings, offset) = struct.unpack(
+                ">4sHH", data[i * 8 : (i + 1) * 8]
+            )
+            offset = int(offset / 8) - (numLangs + 1)
+            langcode = langcode.replace(b"\000", b"")
+            langinfo.append((langcode.decode("utf-8"), numsettings, offset))
+            maxsetting = max(maxsetting, offset + numsettings)
+        data = data[numLangs * 8 :]
+        finfo = []
+        for i in range(maxsetting):
+            (fid, val, _) = struct.unpack(">LHH", data[i * 8 : (i + 1) * 8])
+            finfo.append((fid, val))
+        self.langs = {}
+        for c, n, o in langinfo:
+            self.langs[c] = []
+            for i in range(o, o + n):
+                self.langs[c].append(finfo[i])
+
+    def compile(self, ttFont):
+        ldat = b""
+        fdat = b""
+        offset = len(self.langs)
+        for c, inf in sorted(self.langs.items()):
+            ldat += struct.pack(">4sHH", c.encode("utf8"), len(inf), 8 * offset + 20)
+            for fid, val in inf:
+                fdat += struct.pack(">LHH", fid, val, 0)
+            offset += len(inf)
+        ldat += struct.pack(">LHH", 0x80808080, 0, 8 * offset + 20)
+        return (
+            sstruct.pack(Sill_hdr, self)
+            + grUtils.bininfo(len(self.langs))
+            + ldat
+            + fdat
+        )
+
+    def toXML(self, writer, ttFont):
+        writer.simpletag("version", version=self.version)
+        writer.newline()
+        for c, inf in sorted(self.langs.items()):
+            writer.begintag("lang", name=c)
+            writer.newline()
+            for fid, val in inf:
+                writer.simpletag("feature", fid=grUtils.num2tag(fid), val=val)
+                writer.newline()
+            writer.endtag("lang")
+            writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "version":
+            self.version = float(safeEval(attrs["version"]))
+        elif name == "lang":
+            c = attrs["name"]
+            self.langs[c] = []
+            for element in content:
+                if not isinstance(element, tuple):
+                    continue
+                tag, a, subcontent = element
+                if tag == "feature":
+                    self.langs[c].append(
+                        (grUtils.tag2num(a["fid"]), int(safeEval(a["val"])))
+                    )

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_B_.py

@@ -0,0 +1,13 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+TSIB contains the source text for the ``BASE`` table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_B_(table_T_S_I_V_):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_C_.py

@@ -0,0 +1,14 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+TSIC contains the source text for the Variation CVT window and data for
+the ``cvar`` table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from .otBase import BaseTTXConverter
+
+
+class table_T_S_I_C_(BaseTTXConverter):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_D_.py

@@ -0,0 +1,13 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+TSID contains the source text for the ``GDEF`` table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_D_(table_T_S_I_V_):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_J_.py

@@ -0,0 +1,13 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+TSIJ contains the source text for the ``JSTF`` table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_J_(table_T_S_I_V_):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_P_.py

@@ -0,0 +1,13 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+TSIP contains the source text for the ``GPOS`` table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_P_(table_T_S_I_V_):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_S_.py

@@ -0,0 +1,13 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+TSIS contains the source text for the ``GSUB`` table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from .T_S_I_V_ import table_T_S_I_V_
+
+
+class table_T_S_I_S_(table_T_S_I_V_):
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_V_.py

@@ -0,0 +1,26 @@
+""" TSI{B,C,D,J,P,S,V} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its table source data.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from fontTools.misc.textTools import strjoin, tobytes, tostr
+from . import asciiTable
+
+
+class table_T_S_I_V_(asciiTable.asciiTable):
+    def toXML(self, writer, ttFont):
+        data = tostr(self.data)
+        # removing null bytes. XXX needed??
+        data = data.split("\0")
+        data = strjoin(data)
+        writer.begintag("source")
+        writer.newline()
+        writer.write_noindent(data.replace("\r", "\n"))
+        writer.newline()
+        writer.endtag("source")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        lines = strjoin(content).split("\n")
+        self.data = tobytes("\r".join(lines[1:-1]))

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I__0.py

@@ -0,0 +1,70 @@
+"""TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its hinting source data.
+
+TSI0 is the index table containing the lengths and offsets for the glyph
+programs and 'extra' programs ('fpgm', 'prep', and 'cvt') that are contained
+in the TSI1 table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+import logging
+import struct
+
+from . import DefaultTable
+
+log = logging.getLogger(__name__)
+
+tsi0Format = ">HHL"
+
+
+def fixlongs(glyphID, textLength, textOffset):
+    return int(glyphID), int(textLength), textOffset
+
+
+class table_T_S_I__0(DefaultTable.DefaultTable):
+    dependencies = ["TSI1"]
+
+    def decompile(self, data, ttFont):
+        numGlyphs = ttFont["maxp"].numGlyphs
+        indices = []
+        size = struct.calcsize(tsi0Format)
+        numEntries = len(data) // size
+        if numEntries != numGlyphs + 5:
+            diff = numEntries - numGlyphs - 5
+            log.warning(
+                "Number of glyphPrograms differs from the number of glyphs in the font "
+                f"by {abs(diff)} ({numEntries - 5} programs vs. {numGlyphs} glyphs)."
+            )
+        for _ in range(numEntries):
+            glyphID, textLength, textOffset = fixlongs(
+                *struct.unpack(tsi0Format, data[:size])
+            )
+            indices.append((glyphID, textLength, textOffset))
+            data = data[size:]
+        assert len(data) == 0
+        assert indices[-5] == (0xFFFE, 0, 0xABFC1F34), "bad magic number"
+        self.indices = indices[:-5]
+        self.extra_indices = indices[-4:]
+
+    def compile(self, ttFont):
+        if not hasattr(self, "indices"):
+            # We have no corresponding table (TSI1 or TSI3); let's return
+            # no data, which effectively means "ignore us".
+            return b""
+        data = b""
+        for index, textLength, textOffset in self.indices:
+            data = data + struct.pack(tsi0Format, index, textLength, textOffset)
+        data = data + struct.pack(tsi0Format, 0xFFFE, 0, 0xABFC1F34)
+        for index, textLength, textOffset in self.extra_indices:
+            data = data + struct.pack(tsi0Format, index, textLength, textOffset)
+        return data
+
+    def set(self, indices, extra_indices):
+        # gets called by 'TSI1' or 'TSI3'
+        self.indices = indices
+        self.extra_indices = extra_indices
+
+    def toXML(self, writer, ttFont):
+        writer.comment("This table will be calculated by the compiler")
+        writer.newline()

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I__1.py

@@ -0,0 +1,163 @@
+""" 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'.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+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, name in enumerate(glyphNames):
+            if len(data) % 2:
+                data = (
+                    data + b"\015"
+                )  # align on 2-byte boundaries, fill with return chars. Yum.
+            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 = []
+        for code, name in sorted(self.extras.items()):
+            if len(data) % 2:
+                data = (
+                    data + b"\015"
+                )  # align on 2-byte boundaries, fill with return chars.
+            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

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I__2.py

@@ -0,0 +1,17 @@
+""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its hinting source data.
+
+TSI2 is the index table containing the lengths and offsets for the glyph
+programs that are contained in the TSI3 table. It uses the same format as
+the TSI0 table.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from fontTools import ttLib
+
+superclass = ttLib.getTableClass("TSI0")
+
+
+class table_T_S_I__2(superclass):
+    dependencies = ["TSI3"]

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I__3.py

@@ -0,0 +1,22 @@
+""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+tool to store its hinting source data.
+
+TSI3 contains the text of the glyph programs in the form of 'VTTTalk' code.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+from fontTools import ttLib
+
+superclass = ttLib.getTableClass("TSI1")
+
+
+class table_T_S_I__3(superclass):
+    extras = {
+        0xFFFA: "reserved0",
+        0xFFFB: "reserved1",
+        0xFFFC: "reserved2",
+        0xFFFD: "reserved3",
+    }
+
+    indextable = "TSI2"

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I__5.py

@@ -0,0 +1,60 @@
+"""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.
+
+See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
+"""
+
+import array
+import logging
+import sys
+
+from fontTools.misc.textTools import safeEval
+
+from . import DefaultTable
+
+log = logging.getLogger(__name__)
+
+
+class table_T_S_I__5(DefaultTable.DefaultTable):
+    def decompile(self, data, ttFont):
+        numGlyphs = ttFont["maxp"].numGlyphs
+        a = array.array("H")
+        a.frombytes(data)
+        if sys.byteorder != "big":
+            a.byteswap()
+        self.glyphGrouping = {}
+        numEntries = len(data) // 2
+        if numEntries != numGlyphs:
+            diff = numEntries - numGlyphs
+            log.warning(
+                "Number of entries differs from the number of glyphs in the font "
+                f"by {abs(diff)} ({numEntries} entries vs. {numGlyphs} glyphs)."
+            )
+        for i in range(numEntries):
+            self.glyphGrouping[ttFont.getGlyphName(i)] = a[i]
+
+    def compile(self, ttFont):
+        glyphNames = ttFont.getGlyphOrder()
+        a = array.array("H")
+        for glyphName in glyphNames:
+            a.append(self.glyphGrouping.get(glyphName, 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"])

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_T_F_A_.py

@@ -0,0 +1,14 @@
+from . import asciiTable
+
+
+class table_T_T_F_A_(asciiTable.asciiTable):
+    """ttfautohint parameters table
+
+    The ``TTFA`` table is used by the free-software `ttfautohint` program
+    to record the parameters that `ttfautohint` was called with when it
+    was used to auto-hint the font.
+
+    See also http://freetype.org/ttfautohint/doc/ttfautohint.html#miscellaneous-1
+    """
+
+    pass

.venv/lib/python3.11/site-packages/fontTools/ttLib/tables/TupleVariation.py

@@ -0,0 +1,886 @@
+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 logging
+import struct
+import sys
+import warnings
+
+
+# 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, *, optimizeSize=True
+    ):
+        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(optimizeSize=optimizeSize))
+        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, optimizeSize=True):
+        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, optimizeSize=optimizeSize)
+        self.compileDeltaValues_(deltaY, bytearr, optimizeSize=optimizeSize)
+        return bytearr
+
+    @staticmethod
+    def compileDeltaValues_(deltas, bytearr=None, *, optimizeSize=True):
+        """[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)
+
+        if optimizeSize:
+            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)
+        else:
+            minVal, maxVal = min(deltas), max(deltas)
+            if minVal == 0 == maxVal:
+                pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, bytearr)
+            elif -128 <= minVal <= maxVal <= 127:
+                pos = TupleVariation.encodeDeltaRunAsBytes_(
+                    deltas, pos, bytearr, optimizeSize=False
+                )
+            elif -32768 <= minVal <= maxVal <= 32767:
+                pos = TupleVariation.encodeDeltaRunAsWords_(
+                    deltas, pos, bytearr, optimizeSize=False
+                )
+            else:
+                pos = TupleVariation.encodeDeltaRunAsLongs_(
+                    deltas, pos, bytearr, optimizeSize=False
+                )
+
+        assert pos == numDeltas, (pos, numDeltas)
+
+        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, optimizeSize=True):
+        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 (
+                optimizeSize
+                and 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, optimizeSize=True):
+        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 optimizeSize and 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 (
+                optimizeSize
+                and (-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, optimizeSize=True):
+        pos = offset
+        numDeltas = len(deltas)
+        while pos < numDeltas:
+            value = deltas[pos]
+            if optimizeSize and -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 isComposite:
+            warnings.warn(
+                "The isComposite argument is deprecated and may be removed in a future version",
+                DeprecationWarning,
+            )
+
+        if None in self.coordinates:
+            return  # already optimized
+
+        deltaOpt = iup_delta_optimize(
+            self.coordinates, origCoords, endPts, tolerance=tolerance
+        )
+        if None in deltaOpt:
+            # 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,
+    *,
+    optimizeSize=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, optimizeSize=optimizeSize
+        )
+
+        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)