fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/tables/otConverters.py

@@ -0,0 +1,2068 @@
+from fontTools.misc.fixedTools import (
+    fixedToFloat as fi2fl,
+    floatToFixed as fl2fi,
+    floatToFixedToStr as fl2str,
+    strToFixedToFloat as str2fl,
+    ensureVersionIsLong as fi2ve,
+    versionToFixed as ve2fi,
+)
+from fontTools.ttLib.tables.TupleVariation import TupleVariation
+from fontTools.misc.roundTools import nearestMultipleShortestRepr, otRound
+from fontTools.misc.textTools import bytesjoin, tobytes, tostr, pad, safeEval
+from fontTools.misc.lazyTools import LazyList
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, getSearchRange
+from .otBase import (
+    CountReference,
+    FormatSwitchingBaseTable,
+    OTTableReader,
+    OTTableWriter,
+    ValueRecordFactory,
+)
+from .otTables import (
+    lookupTypes,
+    VarCompositeGlyph,
+    AATStateTable,
+    AATState,
+    AATAction,
+    ContextualMorphAction,
+    LigatureMorphAction,
+    InsertionMorphAction,
+    MorxSubtable,
+    ExtendMode as _ExtendMode,
+    CompositeMode as _CompositeMode,
+    NO_VARIATION_INDEX,
+)
+from itertools import zip_longest, accumulate
+from functools import partial
+from types import SimpleNamespace
+import re
+import struct
+from typing import Optional
+import logging
+
+
+log = logging.getLogger(__name__)
+istuple = lambda t: isinstance(t, tuple)
+
+
+def buildConverters(tableSpec, tableNamespace):
+    """Given a table spec from otData.py, build a converter object for each
+    field of the table. This is called for each table in otData.py, and
+    the results are assigned to the corresponding class in otTables.py."""
+    converters = []
+    convertersByName = {}
+    for tp, name, repeat, aux, descr in tableSpec:
+        tableName = name
+        if name.startswith("ValueFormat"):
+            assert tp == "uint16"
+            converterClass = ValueFormat
+        elif name.endswith("Count") or name in ("StructLength", "MorphType"):
+            converterClass = {
+                "uint8": ComputedUInt8,
+                "uint16": ComputedUShort,
+                "uint32": ComputedULong,
+            }[tp]
+        elif name == "SubTable":
+            converterClass = SubTable
+        elif name == "ExtSubTable":
+            converterClass = ExtSubTable
+        elif name == "SubStruct":
+            converterClass = SubStruct
+        elif name == "FeatureParams":
+            converterClass = FeatureParams
+        elif name in ("CIDGlyphMapping", "GlyphCIDMapping"):
+            converterClass = StructWithLength
+        else:
+            if not tp in converterMapping and "(" not in tp:
+                tableName = tp
+                converterClass = Struct
+            else:
+                converterClass = eval(tp, tableNamespace, converterMapping)
+
+        conv = converterClass(name, repeat, aux, description=descr)
+
+        if conv.tableClass:
+            # A "template" such as OffsetTo(AType) knows the table class already
+            tableClass = conv.tableClass
+        elif tp in ("MortChain", "MortSubtable", "MorxChain"):
+            tableClass = tableNamespace.get(tp)
+        else:
+            tableClass = tableNamespace.get(tableName)
+
+        if not conv.tableClass:
+            conv.tableClass = tableClass
+
+        if name in ["SubTable", "ExtSubTable", "SubStruct"]:
+            conv.lookupTypes = tableNamespace["lookupTypes"]
+            # also create reverse mapping
+            for t in conv.lookupTypes.values():
+                for cls in t.values():
+                    convertersByName[cls.__name__] = Table(name, repeat, aux, cls)
+        if name == "FeatureParams":
+            conv.featureParamTypes = tableNamespace["featureParamTypes"]
+            conv.defaultFeatureParams = tableNamespace["FeatureParams"]
+            for cls in conv.featureParamTypes.values():
+                convertersByName[cls.__name__] = Table(name, repeat, aux, cls)
+        converters.append(conv)
+        assert name not in convertersByName, name
+        convertersByName[name] = conv
+    return converters, convertersByName
+
+
+class BaseConverter(object):
+    """Base class for converter objects. Apart from the constructor, this
+    is an abstract class."""
+
+    def __init__(self, name, repeat, aux, tableClass=None, *, description=""):
+        self.name = name
+        self.repeat = repeat
+        self.aux = aux
+        if self.aux and not self.repeat:
+            self.aux = compile(self.aux, "<string>", "eval")
+        self.tableClass = tableClass
+        self.isCount = name.endswith("Count") or name in [
+            "DesignAxisRecordSize",
+            "ValueRecordSize",
+        ]
+        self.isLookupType = name.endswith("LookupType") or name == "MorphType"
+        self.isPropagated = name in [
+            "ClassCount",
+            "Class2Count",
+            "FeatureTag",
+            "SettingsCount",
+            "VarRegionCount",
+            "MappingCount",
+            "RegionAxisCount",
+            "DesignAxisCount",
+            "DesignAxisRecordSize",
+            "AxisValueCount",
+            "ValueRecordSize",
+            "AxisCount",
+            "BaseGlyphRecordCount",
+            "LayerRecordCount",
+            "AxisIndicesList",
+        ]
+        self.description = description
+
+    def readArray(self, reader, font, tableDict, count):
+        """Read an array of values from the reader."""
+        lazy = font.lazy and count > 8
+        if lazy:
+            recordSize = self.getRecordSize(reader)
+            if recordSize is NotImplemented:
+                lazy = False
+        if not lazy:
+            l = []
+            for i in range(count):
+                l.append(self.read(reader, font, tableDict))
+            return l
+        else:
+
+            def get_read_item():
+                reader_copy = reader.copy()
+                pos = reader.pos
+
+                def read_item(i):
+                    reader_copy.seek(pos + i * recordSize)
+                    return self.read(reader_copy, font, {})
+
+                return read_item
+
+            read_item = get_read_item()
+            l = LazyList(read_item for i in range(count))
+            reader.advance(count * recordSize)
+
+            return l
+
+    def getRecordSize(self, reader):
+        if hasattr(self, "staticSize"):
+            return self.staticSize
+        return NotImplemented
+
+    def read(self, reader, font, tableDict):
+        """Read a value from the reader."""
+        raise NotImplementedError(self)
+
+    def writeArray(self, writer, font, tableDict, values):
+        try:
+            for i, value in enumerate(values):
+                self.write(writer, font, tableDict, value, i)
+        except Exception as e:
+            e.args = e.args + (i,)
+            raise
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        """Write a value to the writer."""
+        raise NotImplementedError(self)
+
+    def xmlRead(self, attrs, content, font):
+        """Read a value from XML."""
+        raise NotImplementedError(self)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        """Write a value to XML."""
+        raise NotImplementedError(self)
+
+    varIndexBasePlusOffsetRE = re.compile(r"VarIndexBase\s*\+\s*(\d+)")
+
+    def getVarIndexOffset(self) -> Optional[int]:
+        """If description has `VarIndexBase + {offset}`, return the offset else None."""
+        m = self.varIndexBasePlusOffsetRE.search(self.description)
+        if not m:
+            return None
+        return int(m.group(1))
+
+
+class SimpleValue(BaseConverter):
+    @staticmethod
+    def toString(value):
+        return value
+
+    @staticmethod
+    def fromString(value):
+        return value
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", self.toString(value))])
+        xmlWriter.newline()
+
+    def xmlRead(self, attrs, content, font):
+        return self.fromString(attrs["value"])
+
+
+class OptionalValue(SimpleValue):
+    DEFAULT = None
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        if value != self.DEFAULT:
+            attrs.append(("value", self.toString(value)))
+        xmlWriter.simpletag(name, attrs)
+        xmlWriter.newline()
+
+    def xmlRead(self, attrs, content, font):
+        if "value" in attrs:
+            return self.fromString(attrs["value"])
+        return self.DEFAULT
+
+
+class IntValue(SimpleValue):
+    @staticmethod
+    def fromString(value):
+        return int(value, 0)
+
+
+class Long(IntValue):
+    staticSize = 4
+
+    def read(self, reader, font, tableDict):
+        return reader.readLong()
+
+    def readArray(self, reader, font, tableDict, count):
+        return reader.readLongArray(count)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeLong(value)
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeLongArray(values)
+
+
+class ULong(IntValue):
+    staticSize = 4
+
+    def read(self, reader, font, tableDict):
+        return reader.readULong()
+
+    def readArray(self, reader, font, tableDict, count):
+        return reader.readULongArray(count)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeULong(value)
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeULongArray(values)
+
+
+class Flags32(ULong):
+    @staticmethod
+    def toString(value):
+        return "0x%08X" % value
+
+
+class VarIndex(OptionalValue, ULong):
+    DEFAULT = NO_VARIATION_INDEX
+
+
+class Short(IntValue):
+    staticSize = 2
+
+    def read(self, reader, font, tableDict):
+        return reader.readShort()
+
+    def readArray(self, reader, font, tableDict, count):
+        return reader.readShortArray(count)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeShort(value)
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeShortArray(values)
+
+
+class UShort(IntValue):
+    staticSize = 2
+
+    def read(self, reader, font, tableDict):
+        return reader.readUShort()
+
+    def readArray(self, reader, font, tableDict, count):
+        return reader.readUShortArray(count)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeUShort(value)
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeUShortArray(values)
+
+
+class Int8(IntValue):
+    staticSize = 1
+
+    def read(self, reader, font, tableDict):
+        return reader.readInt8()
+
+    def readArray(self, reader, font, tableDict, count):
+        return reader.readInt8Array(count)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeInt8(value)
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeInt8Array(values)
+
+
+class UInt8(IntValue):
+    staticSize = 1
+
+    def read(self, reader, font, tableDict):
+        return reader.readUInt8()
+
+    def readArray(self, reader, font, tableDict, count):
+        return reader.readUInt8Array(count)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeUInt8(value)
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeUInt8Array(values)
+
+
+class UInt24(IntValue):
+    staticSize = 3
+
+    def read(self, reader, font, tableDict):
+        return reader.readUInt24()
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeUInt24(value)
+
+
+class ComputedInt(IntValue):
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        if value is not None:
+            xmlWriter.comment("%s=%s" % (name, value))
+            xmlWriter.newline()
+
+
+class ComputedUInt8(ComputedInt, UInt8):
+    pass
+
+
+class ComputedUShort(ComputedInt, UShort):
+    pass
+
+
+class ComputedULong(ComputedInt, ULong):
+    pass
+
+
+class Tag(SimpleValue):
+    staticSize = 4
+
+    def read(self, reader, font, tableDict):
+        return reader.readTag()
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeTag(value)
+
+
+class GlyphID(SimpleValue):
+    staticSize = 2
+    typecode = "H"
+
+    def readArray(self, reader, font, tableDict, count):
+        return font.getGlyphNameMany(
+            reader.readArray(self.typecode, self.staticSize, count)
+        )
+
+    def read(self, reader, font, tableDict):
+        return font.getGlyphName(reader.readValue(self.typecode, self.staticSize))
+
+    def writeArray(self, writer, font, tableDict, values):
+        writer.writeArray(self.typecode, font.getGlyphIDMany(values))
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeValue(self.typecode, font.getGlyphID(value))
+
+
+class GlyphID32(GlyphID):
+    staticSize = 4
+    typecode = "L"
+
+
+class NameID(UShort):
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", value)])
+        if font and value:
+            nameTable = font.get("name")
+            if nameTable:
+                name = nameTable.getDebugName(value)
+                xmlWriter.write("  ")
+                if name:
+                    xmlWriter.comment(name)
+                else:
+                    xmlWriter.comment("missing from name table")
+                    log.warning("name id %d missing from name table" % value)
+        xmlWriter.newline()
+
+
+class STATFlags(UShort):
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", value)])
+        flags = []
+        if value & 0x01:
+            flags.append("OlderSiblingFontAttribute")
+        if value & 0x02:
+            flags.append("ElidableAxisValueName")
+        if flags:
+            xmlWriter.write("  ")
+            xmlWriter.comment(" ".join(flags))
+        xmlWriter.newline()
+
+
+class FloatValue(SimpleValue):
+    @staticmethod
+    def fromString(value):
+        return float(value)
+
+
+class DeciPoints(FloatValue):
+    staticSize = 2
+
+    def read(self, reader, font, tableDict):
+        return reader.readUShort() / 10
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.writeUShort(round(value * 10))
+
+
+class BaseFixedValue(FloatValue):
+    staticSize = NotImplemented
+    precisionBits = NotImplemented
+    readerMethod = NotImplemented
+    writerMethod = NotImplemented
+
+    def read(self, reader, font, tableDict):
+        return self.fromInt(getattr(reader, self.readerMethod)())
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        getattr(writer, self.writerMethod)(self.toInt(value))
+
+    @classmethod
+    def fromInt(cls, value):
+        return fi2fl(value, cls.precisionBits)
+
+    @classmethod
+    def toInt(cls, value):
+        return fl2fi(value, cls.precisionBits)
+
+    @classmethod
+    def fromString(cls, value):
+        return str2fl(value, cls.precisionBits)
+
+    @classmethod
+    def toString(cls, value):
+        return fl2str(value, cls.precisionBits)
+
+
+class Fixed(BaseFixedValue):
+    staticSize = 4
+    precisionBits = 16
+    readerMethod = "readLong"
+    writerMethod = "writeLong"
+
+
+class F2Dot14(BaseFixedValue):
+    staticSize = 2
+    precisionBits = 14
+    readerMethod = "readShort"
+    writerMethod = "writeShort"
+
+
+class Angle(F2Dot14):
+    # angles are specified in degrees, and encoded as F2Dot14 fractions of half
+    # circle: e.g. 1.0 => 180, -0.5 => -90, -2.0 => -360, etc.
+    bias = 0.0
+    factor = 1.0 / (1 << 14) * 180  # 0.010986328125
+
+    @classmethod
+    def fromInt(cls, value):
+        return (super().fromInt(value) + cls.bias) * 180
+
+    @classmethod
+    def toInt(cls, value):
+        return super().toInt((value / 180) - cls.bias)
+
+    @classmethod
+    def fromString(cls, value):
+        # quantize to nearest multiples of minimum fixed-precision angle
+        return otRound(float(value) / cls.factor) * cls.factor
+
+    @classmethod
+    def toString(cls, value):
+        return nearestMultipleShortestRepr(value, cls.factor)
+
+
+class BiasedAngle(Angle):
+    # A bias of 1.0 is used in the representation of start and end angles
+    # of COLRv1 PaintSweepGradients to allow for encoding +360deg
+    bias = 1.0
+
+
+class Version(SimpleValue):
+    staticSize = 4
+
+    def read(self, reader, font, tableDict):
+        value = reader.readLong()
+        return value
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        value = fi2ve(value)
+        writer.writeLong(value)
+
+    @staticmethod
+    def fromString(value):
+        return ve2fi(value)
+
+    @staticmethod
+    def toString(value):
+        return "0x%08x" % value
+
+    @staticmethod
+    def fromFloat(v):
+        return fl2fi(v, 16)
+
+
+class Char64(SimpleValue):
+    """An ASCII string with up to 64 characters.
+
+    Unused character positions are filled with 0x00 bytes.
+    Used in Apple AAT fonts in the `gcid` table.
+    """
+
+    staticSize = 64
+
+    def read(self, reader, font, tableDict):
+        data = reader.readData(self.staticSize)
+        zeroPos = data.find(b"\0")
+        if zeroPos >= 0:
+            data = data[:zeroPos]
+        s = tostr(data, encoding="ascii", errors="replace")
+        if s != tostr(data, encoding="ascii", errors="ignore"):
+            log.warning('replaced non-ASCII characters in "%s"' % s)
+        return s
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        data = tobytes(value, encoding="ascii", errors="replace")
+        if data != tobytes(value, encoding="ascii", errors="ignore"):
+            log.warning('replacing non-ASCII characters in "%s"' % value)
+        if len(data) > self.staticSize:
+            log.warning(
+                'truncating overlong "%s" to %d bytes' % (value, self.staticSize)
+            )
+        data = (data + b"\0" * self.staticSize)[: self.staticSize]
+        writer.writeData(data)
+
+
+class Struct(BaseConverter):
+    def getRecordSize(self, reader):
+        return self.tableClass and self.tableClass.getRecordSize(reader)
+
+    def read(self, reader, font, tableDict):
+        table = self.tableClass()
+        table.decompile(reader, font)
+        return table
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        value.compile(writer, font)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        if value is None:
+            if attrs:
+                # If there are attributes (probably index), then
+                # don't drop this even if it's NULL.  It will mess
+                # up the array indices of the containing element.
+                xmlWriter.simpletag(name, attrs + [("empty", 1)])
+                xmlWriter.newline()
+            else:
+                pass  # NULL table, ignore
+        else:
+            value.toXML(xmlWriter, font, attrs, name=name)
+
+    def xmlRead(self, attrs, content, font):
+        if "empty" in attrs and safeEval(attrs["empty"]):
+            return None
+        table = self.tableClass()
+        Format = attrs.get("Format")
+        if Format is not None:
+            table.Format = int(Format)
+
+        noPostRead = not hasattr(table, "postRead")
+        if noPostRead:
+            # TODO Cache table.hasPropagated.
+            cleanPropagation = False
+            for conv in table.getConverters():
+                if conv.isPropagated:
+                    cleanPropagation = True
+                    if not hasattr(font, "_propagator"):
+                        font._propagator = {}
+                    propagator = font._propagator
+                    assert conv.name not in propagator, (conv.name, propagator)
+                    setattr(table, conv.name, None)
+                    propagator[conv.name] = CountReference(table.__dict__, conv.name)
+
+        for element in content:
+            if isinstance(element, tuple):
+                name, attrs, content = element
+                table.fromXML(name, attrs, content, font)
+            else:
+                pass
+
+        table.populateDefaults(propagator=getattr(font, "_propagator", None))
+
+        if noPostRead:
+            if cleanPropagation:
+                for conv in table.getConverters():
+                    if conv.isPropagated:
+                        propagator = font._propagator
+                        del propagator[conv.name]
+                        if not propagator:
+                            del font._propagator
+
+        return table
+
+    def __repr__(self):
+        return "Struct of " + repr(self.tableClass)
+
+
+class StructWithLength(Struct):
+    def read(self, reader, font, tableDict):
+        pos = reader.pos
+        table = self.tableClass()
+        table.decompile(reader, font)
+        reader.seek(pos + table.StructLength)
+        return table
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        for convIndex, conv in enumerate(value.getConverters()):
+            if conv.name == "StructLength":
+                break
+        lengthIndex = len(writer.items) + convIndex
+        if isinstance(value, FormatSwitchingBaseTable):
+            lengthIndex += 1  # implicit Format field
+        deadbeef = {1: 0xDE, 2: 0xDEAD, 4: 0xDEADBEEF}[conv.staticSize]
+
+        before = writer.getDataLength()
+        value.StructLength = deadbeef
+        value.compile(writer, font)
+        length = writer.getDataLength() - before
+        lengthWriter = writer.getSubWriter()
+        conv.write(lengthWriter, font, tableDict, length)
+        assert writer.items[lengthIndex] == b"\xde\xad\xbe\xef"[: conv.staticSize]
+        writer.items[lengthIndex] = lengthWriter.getAllData()
+
+
+class Table(Struct):
+    staticSize = 2
+
+    def readOffset(self, reader):
+        return reader.readUShort()
+
+    def writeNullOffset(self, writer):
+        writer.writeUShort(0)
+
+    def read(self, reader, font, tableDict):
+        offset = self.readOffset(reader)
+        if offset == 0:
+            return None
+        table = self.tableClass()
+        reader = reader.getSubReader(offset)
+        if font.lazy:
+            table.reader = reader
+            table.font = font
+        else:
+            table.decompile(reader, font)
+        return table
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        if value is None:
+            self.writeNullOffset(writer)
+        else:
+            subWriter = writer.getSubWriter()
+            subWriter.name = self.name
+            if repeatIndex is not None:
+                subWriter.repeatIndex = repeatIndex
+            writer.writeSubTable(subWriter, offsetSize=self.staticSize)
+            value.compile(subWriter, font)
+
+
+class LTable(Table):
+    staticSize = 4
+
+    def readOffset(self, reader):
+        return reader.readULong()
+
+    def writeNullOffset(self, writer):
+        writer.writeULong(0)
+
+
+# Table pointed to by a 24-bit, 3-byte long offset
+class Table24(Table):
+    staticSize = 3
+
+    def readOffset(self, reader):
+        return reader.readUInt24()
+
+    def writeNullOffset(self, writer):
+        writer.writeUInt24(0)
+
+
+# TODO Clean / merge the SubTable and SubStruct
+
+
+class SubStruct(Struct):
+    def getConverter(self, tableType, lookupType):
+        tableClass = self.lookupTypes[tableType][lookupType]
+        return self.__class__(self.name, self.repeat, self.aux, tableClass)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        super(SubStruct, self).xmlWrite(xmlWriter, font, value, None, attrs)
+
+
+class SubTable(Table):
+    def getConverter(self, tableType, lookupType):
+        tableClass = self.lookupTypes[tableType][lookupType]
+        return self.__class__(self.name, self.repeat, self.aux, tableClass)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        super(SubTable, self).xmlWrite(xmlWriter, font, value, None, attrs)
+
+
+class ExtSubTable(LTable, SubTable):
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer.Extension = True  # actually, mere presence of the field flags it as an Ext Subtable writer.
+        Table.write(self, writer, font, tableDict, value, repeatIndex)
+
+
+class FeatureParams(Table):
+    def getConverter(self, featureTag):
+        tableClass = self.featureParamTypes.get(featureTag, self.defaultFeatureParams)
+        return self.__class__(self.name, self.repeat, self.aux, tableClass)
+
+
+class ValueFormat(IntValue):
+    staticSize = 2
+
+    def __init__(self, name, repeat, aux, tableClass=None, *, description=""):
+        BaseConverter.__init__(
+            self, name, repeat, aux, tableClass, description=description
+        )
+        self.which = "ValueFormat" + ("2" if name[-1] == "2" else "1")
+
+    def read(self, reader, font, tableDict):
+        format = reader.readUShort()
+        reader[self.which] = ValueRecordFactory(format)
+        return format
+
+    def write(self, writer, font, tableDict, format, repeatIndex=None):
+        writer.writeUShort(format)
+        writer[self.which] = ValueRecordFactory(format)
+
+
+class ValueRecord(ValueFormat):
+    def getRecordSize(self, reader):
+        return 2 * len(reader[self.which])
+
+    def read(self, reader, font, tableDict):
+        return reader[self.which].readValueRecord(reader, font)
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        writer[self.which].writeValueRecord(writer, font, value)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        if value is None:
+            pass  # NULL table, ignore
+        else:
+            value.toXML(xmlWriter, font, self.name, attrs)
+
+    def xmlRead(self, attrs, content, font):
+        from .otBase import ValueRecord
+
+        value = ValueRecord()
+        value.fromXML(None, attrs, content, font)
+        return value
+
+
+class AATLookup(BaseConverter):
+    BIN_SEARCH_HEADER_SIZE = 10
+
+    def __init__(self, name, repeat, aux, tableClass, *, description=""):
+        BaseConverter.__init__(
+            self, name, repeat, aux, tableClass, description=description
+        )
+        if issubclass(self.tableClass, SimpleValue):
+            self.converter = self.tableClass(name="Value", repeat=None, aux=None)
+        else:
+            self.converter = Table(
+                name="Value", repeat=None, aux=None, tableClass=self.tableClass
+            )
+
+    def read(self, reader, font, tableDict):
+        format = reader.readUShort()
+        if format == 0:
+            return self.readFormat0(reader, font)
+        elif format == 2:
+            return self.readFormat2(reader, font)
+        elif format == 4:
+            return self.readFormat4(reader, font)
+        elif format == 6:
+            return self.readFormat6(reader, font)
+        elif format == 8:
+            return self.readFormat8(reader, font)
+        else:
+            assert False, "unsupported lookup format: %d" % format
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        values = list(
+            sorted([(font.getGlyphID(glyph), val) for glyph, val in value.items()])
+        )
+        # TODO: Also implement format 4.
+        formats = list(
+            sorted(
+                filter(
+                    None,
+                    [
+                        self.buildFormat0(writer, font, values),
+                        self.buildFormat2(writer, font, values),
+                        self.buildFormat6(writer, font, values),
+                        self.buildFormat8(writer, font, values),
+                    ],
+                )
+            )
+        )
+        # We use the format ID as secondary sort key to make the output
+        # deterministic when multiple formats have same encoded size.
+        dataSize, lookupFormat, writeMethod = formats[0]
+        pos = writer.getDataLength()
+        writeMethod()
+        actualSize = writer.getDataLength() - pos
+        assert (
+            actualSize == dataSize
+        ), "AATLookup format %d claimed to write %d bytes, but wrote %d" % (
+            lookupFormat,
+            dataSize,
+            actualSize,
+        )
+
+    @staticmethod
+    def writeBinSearchHeader(writer, numUnits, unitSize):
+        writer.writeUShort(unitSize)
+        writer.writeUShort(numUnits)
+        searchRange, entrySelector, rangeShift = getSearchRange(
+            n=numUnits, itemSize=unitSize
+        )
+        writer.writeUShort(searchRange)
+        writer.writeUShort(entrySelector)
+        writer.writeUShort(rangeShift)
+
+    def buildFormat0(self, writer, font, values):
+        numGlyphs = len(font.getGlyphOrder())
+        if len(values) != numGlyphs:
+            return None
+        valueSize = self.converter.staticSize
+        return (
+            2 + numGlyphs * valueSize,
+            0,
+            lambda: self.writeFormat0(writer, font, values),
+        )
+
+    def writeFormat0(self, writer, font, values):
+        writer.writeUShort(0)
+        for glyphID_, value in values:
+            self.converter.write(
+                writer, font, tableDict=None, value=value, repeatIndex=None
+            )
+
+    def buildFormat2(self, writer, font, values):
+        segStart, segValue = values[0]
+        segEnd = segStart
+        segments = []
+        for glyphID, curValue in values[1:]:
+            if glyphID != segEnd + 1 or curValue != segValue:
+                segments.append((segStart, segEnd, segValue))
+                segStart = segEnd = glyphID
+                segValue = curValue
+            else:
+                segEnd = glyphID
+        segments.append((segStart, segEnd, segValue))
+        valueSize = self.converter.staticSize
+        numUnits, unitSize = len(segments) + 1, valueSize + 4
+        return (
+            2 + self.BIN_SEARCH_HEADER_SIZE + numUnits * unitSize,
+            2,
+            lambda: self.writeFormat2(writer, font, segments),
+        )
+
+    def writeFormat2(self, writer, font, segments):
+        writer.writeUShort(2)
+        valueSize = self.converter.staticSize
+        numUnits, unitSize = len(segments), valueSize + 4
+        self.writeBinSearchHeader(writer, numUnits, unitSize)
+        for firstGlyph, lastGlyph, value in segments:
+            writer.writeUShort(lastGlyph)
+            writer.writeUShort(firstGlyph)
+            self.converter.write(
+                writer, font, tableDict=None, value=value, repeatIndex=None
+            )
+        writer.writeUShort(0xFFFF)
+        writer.writeUShort(0xFFFF)
+        writer.writeData(b"\x00" * valueSize)
+
+    def buildFormat6(self, writer, font, values):
+        valueSize = self.converter.staticSize
+        numUnits, unitSize = len(values), valueSize + 2
+        return (
+            2 + self.BIN_SEARCH_HEADER_SIZE + (numUnits + 1) * unitSize,
+            6,
+            lambda: self.writeFormat6(writer, font, values),
+        )
+
+    def writeFormat6(self, writer, font, values):
+        writer.writeUShort(6)
+        valueSize = self.converter.staticSize
+        numUnits, unitSize = len(values), valueSize + 2
+        self.writeBinSearchHeader(writer, numUnits, unitSize)
+        for glyphID, value in values:
+            writer.writeUShort(glyphID)
+            self.converter.write(
+                writer, font, tableDict=None, value=value, repeatIndex=None
+            )
+        writer.writeUShort(0xFFFF)
+        writer.writeData(b"\x00" * valueSize)
+
+    def buildFormat8(self, writer, font, values):
+        minGlyphID, maxGlyphID = values[0][0], values[-1][0]
+        if len(values) != maxGlyphID - minGlyphID + 1:
+            return None
+        valueSize = self.converter.staticSize
+        return (
+            6 + len(values) * valueSize,
+            8,
+            lambda: self.writeFormat8(writer, font, values),
+        )
+
+    def writeFormat8(self, writer, font, values):
+        firstGlyphID = values[0][0]
+        writer.writeUShort(8)
+        writer.writeUShort(firstGlyphID)
+        writer.writeUShort(len(values))
+        for _, value in values:
+            self.converter.write(
+                writer, font, tableDict=None, value=value, repeatIndex=None
+            )
+
+    def readFormat0(self, reader, font):
+        numGlyphs = len(font.getGlyphOrder())
+        data = self.converter.readArray(reader, font, tableDict=None, count=numGlyphs)
+        return {font.getGlyphName(k): value for k, value in enumerate(data)}
+
+    def readFormat2(self, reader, font):
+        mapping = {}
+        pos = reader.pos - 2  # start of table is at UShort for format
+        unitSize, numUnits = reader.readUShort(), reader.readUShort()
+        assert unitSize >= 4 + self.converter.staticSize, unitSize
+        for i in range(numUnits):
+            reader.seek(pos + i * unitSize + 12)
+            last = reader.readUShort()
+            first = reader.readUShort()
+            value = self.converter.read(reader, font, tableDict=None)
+            if last != 0xFFFF:
+                for k in range(first, last + 1):
+                    mapping[font.getGlyphName(k)] = value
+        return mapping
+
+    def readFormat4(self, reader, font):
+        mapping = {}
+        pos = reader.pos - 2  # start of table is at UShort for format
+        unitSize = reader.readUShort()
+        assert unitSize >= 6, unitSize
+        for i in range(reader.readUShort()):
+            reader.seek(pos + i * unitSize + 12)
+            last = reader.readUShort()
+            first = reader.readUShort()
+            offset = reader.readUShort()
+            if last != 0xFFFF:
+                dataReader = reader.getSubReader(0)  # relative to current position
+                dataReader.seek(pos + offset)  # relative to start of table
+                data = self.converter.readArray(
+                    dataReader, font, tableDict=None, count=last - first + 1
+                )
+                for k, v in enumerate(data):
+                    mapping[font.getGlyphName(first + k)] = v
+        return mapping
+
+    def readFormat6(self, reader, font):
+        mapping = {}
+        pos = reader.pos - 2  # start of table is at UShort for format
+        unitSize = reader.readUShort()
+        assert unitSize >= 2 + self.converter.staticSize, unitSize
+        for i in range(reader.readUShort()):
+            reader.seek(pos + i * unitSize + 12)
+            glyphID = reader.readUShort()
+            value = self.converter.read(reader, font, tableDict=None)
+            if glyphID != 0xFFFF:
+                mapping[font.getGlyphName(glyphID)] = value
+        return mapping
+
+    def readFormat8(self, reader, font):
+        first = reader.readUShort()
+        count = reader.readUShort()
+        data = self.converter.readArray(reader, font, tableDict=None, count=count)
+        return {font.getGlyphName(first + k): value for (k, value) in enumerate(data)}
+
+    def xmlRead(self, attrs, content, font):
+        value = {}
+        for element in content:
+            if isinstance(element, tuple):
+                name, a, eltContent = element
+                if name == "Lookup":
+                    value[a["glyph"]] = self.converter.xmlRead(a, eltContent, font)
+        return value
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.begintag(name, attrs)
+        xmlWriter.newline()
+        for glyph, value in sorted(value.items()):
+            self.converter.xmlWrite(
+                xmlWriter, font, value=value, name="Lookup", attrs=[("glyph", glyph)]
+            )
+        xmlWriter.endtag(name)
+        xmlWriter.newline()
+
+
+# The AAT 'ankr' table has an unusual structure: An offset to an AATLookup
+# followed by an offset to a glyph data table. Other than usual, the
+# offsets in the AATLookup are not relative to the beginning of
+# the beginning of the 'ankr' table, but relative to the glyph data table.
+# So, to find the anchor data for a glyph, one needs to add the offset
+# to the data table to the offset found in the AATLookup, and then use
+# the sum of these two offsets to find the actual data.
+class AATLookupWithDataOffset(BaseConverter):
+    def read(self, reader, font, tableDict):
+        lookupOffset = reader.readULong()
+        dataOffset = reader.readULong()
+        lookupReader = reader.getSubReader(lookupOffset)
+        lookup = AATLookup("DataOffsets", None, None, UShort)
+        offsets = lookup.read(lookupReader, font, tableDict)
+        result = {}
+        for glyph, offset in offsets.items():
+            dataReader = reader.getSubReader(offset + dataOffset)
+            item = self.tableClass()
+            item.decompile(dataReader, font)
+            result[glyph] = item
+        return result
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        # We do not work with OTTableWriter sub-writers because
+        # the offsets in our AATLookup are relative to our data
+        # table, for which we need to provide an offset value itself.
+        # It might have been possible to somehow make a kludge for
+        # performing this indirect offset computation directly inside
+        # OTTableWriter. But this would have made the internal logic
+        # of OTTableWriter even more complex than it already is,
+        # so we decided to roll our own offset computation for the
+        # contents of the AATLookup and associated data table.
+        offsetByGlyph, offsetByData, dataLen = {}, {}, 0
+        compiledData = []
+        for glyph in sorted(value, key=font.getGlyphID):
+            subWriter = OTTableWriter()
+            value[glyph].compile(subWriter, font)
+            data = subWriter.getAllData()
+            offset = offsetByData.get(data, None)
+            if offset == None:
+                offset = dataLen
+                dataLen = dataLen + len(data)
+                offsetByData[data] = offset
+                compiledData.append(data)
+            offsetByGlyph[glyph] = offset
+        # For calculating the offsets to our AATLookup and data table,
+        # we can use the regular OTTableWriter infrastructure.
+        lookupWriter = writer.getSubWriter()
+        lookup = AATLookup("DataOffsets", None, None, UShort)
+        lookup.write(lookupWriter, font, tableDict, offsetByGlyph, None)
+
+        dataWriter = writer.getSubWriter()
+        writer.writeSubTable(lookupWriter, offsetSize=4)
+        writer.writeSubTable(dataWriter, offsetSize=4)
+        for d in compiledData:
+            dataWriter.writeData(d)
+
+    def xmlRead(self, attrs, content, font):
+        lookup = AATLookup("DataOffsets", None, None, self.tableClass)
+        return lookup.xmlRead(attrs, content, font)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        lookup = AATLookup("DataOffsets", None, None, self.tableClass)
+        lookup.xmlWrite(xmlWriter, font, value, name, attrs)
+
+
+class MorxSubtableConverter(BaseConverter):
+    _PROCESSING_ORDERS = {
+        # bits 30 and 28 of morx.CoverageFlags; see morx spec
+        (False, False): "LayoutOrder",
+        (True, False): "ReversedLayoutOrder",
+        (False, True): "LogicalOrder",
+        (True, True): "ReversedLogicalOrder",
+    }
+
+    _PROCESSING_ORDERS_REVERSED = {val: key for key, val in _PROCESSING_ORDERS.items()}
+
+    def __init__(self, name, repeat, aux, tableClass=None, *, description=""):
+        BaseConverter.__init__(
+            self, name, repeat, aux, tableClass, description=description
+        )
+
+    def _setTextDirectionFromCoverageFlags(self, flags, subtable):
+        if (flags & 0x20) != 0:
+            subtable.TextDirection = "Any"
+        elif (flags & 0x80) != 0:
+            subtable.TextDirection = "Vertical"
+        else:
+            subtable.TextDirection = "Horizontal"
+
+    def read(self, reader, font, tableDict):
+        pos = reader.pos
+        m = MorxSubtable()
+        m.StructLength = reader.readULong()
+        flags = reader.readUInt8()
+        orderKey = ((flags & 0x40) != 0, (flags & 0x10) != 0)
+        m.ProcessingOrder = self._PROCESSING_ORDERS[orderKey]
+        self._setTextDirectionFromCoverageFlags(flags, m)
+        m.Reserved = reader.readUShort()
+        m.Reserved |= (flags & 0xF) << 16
+        m.MorphType = reader.readUInt8()
+        m.SubFeatureFlags = reader.readULong()
+        tableClass = lookupTypes["morx"].get(m.MorphType)
+        if tableClass is None:
+            assert False, "unsupported 'morx' lookup type %s" % m.MorphType
+        # To decode AAT ligatures, we need to know the subtable size.
+        # The easiest way to pass this along is to create a new reader
+        # that works on just the subtable as its data.
+        headerLength = reader.pos - pos
+        data = reader.data[reader.pos : reader.pos + m.StructLength - headerLength]
+        assert len(data) == m.StructLength - headerLength
+        subReader = OTTableReader(data=data, tableTag=reader.tableTag)
+        m.SubStruct = tableClass()
+        m.SubStruct.decompile(subReader, font)
+        reader.seek(pos + m.StructLength)
+        return m
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.begintag(name, attrs)
+        xmlWriter.newline()
+        xmlWriter.comment("StructLength=%d" % value.StructLength)
+        xmlWriter.newline()
+        xmlWriter.simpletag("TextDirection", value=value.TextDirection)
+        xmlWriter.newline()
+        xmlWriter.simpletag("ProcessingOrder", value=value.ProcessingOrder)
+        xmlWriter.newline()
+        if value.Reserved != 0:
+            xmlWriter.simpletag("Reserved", value="0x%04x" % value.Reserved)
+            xmlWriter.newline()
+        xmlWriter.comment("MorphType=%d" % value.MorphType)
+        xmlWriter.newline()
+        xmlWriter.simpletag("SubFeatureFlags", value="0x%08x" % value.SubFeatureFlags)
+        xmlWriter.newline()
+        value.SubStruct.toXML(xmlWriter, font)
+        xmlWriter.endtag(name)
+        xmlWriter.newline()
+
+    def xmlRead(self, attrs, content, font):
+        m = MorxSubtable()
+        covFlags = 0
+        m.Reserved = 0
+        for eltName, eltAttrs, eltContent in filter(istuple, content):
+            if eltName == "CoverageFlags":
+                # Only in XML from old versions of fonttools.
+                covFlags = safeEval(eltAttrs["value"])
+                orderKey = ((covFlags & 0x40) != 0, (covFlags & 0x10) != 0)
+                m.ProcessingOrder = self._PROCESSING_ORDERS[orderKey]
+                self._setTextDirectionFromCoverageFlags(covFlags, m)
+            elif eltName == "ProcessingOrder":
+                m.ProcessingOrder = eltAttrs["value"]
+                assert m.ProcessingOrder in self._PROCESSING_ORDERS_REVERSED, (
+                    "unknown ProcessingOrder: %s" % m.ProcessingOrder
+                )
+            elif eltName == "TextDirection":
+                m.TextDirection = eltAttrs["value"]
+                assert m.TextDirection in {"Horizontal", "Vertical", "Any"}, (
+                    "unknown TextDirection %s" % m.TextDirection
+                )
+            elif eltName == "Reserved":
+                m.Reserved = safeEval(eltAttrs["value"])
+            elif eltName == "SubFeatureFlags":
+                m.SubFeatureFlags = safeEval(eltAttrs["value"])
+            elif eltName.endswith("Morph"):
+                m.fromXML(eltName, eltAttrs, eltContent, font)
+            else:
+                assert False, eltName
+        m.Reserved = (covFlags & 0xF) << 16 | m.Reserved
+        return m
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        covFlags = (value.Reserved & 0x000F0000) >> 16
+        reverseOrder, logicalOrder = self._PROCESSING_ORDERS_REVERSED[
+            value.ProcessingOrder
+        ]
+        covFlags |= 0x80 if value.TextDirection == "Vertical" else 0
+        covFlags |= 0x40 if reverseOrder else 0
+        covFlags |= 0x20 if value.TextDirection == "Any" else 0
+        covFlags |= 0x10 if logicalOrder else 0
+        value.CoverageFlags = covFlags
+        lengthIndex = len(writer.items)
+        before = writer.getDataLength()
+        value.StructLength = 0xDEADBEEF
+        # The high nibble of value.Reserved is actuallly encoded
+        # into coverageFlags, so we need to clear it here.
+        origReserved = value.Reserved  # including high nibble
+        value.Reserved = value.Reserved & 0xFFFF  # without high nibble
+        value.compile(writer, font)
+        value.Reserved = origReserved  # restore original value
+        assert writer.items[lengthIndex] == b"\xde\xad\xbe\xef"
+        length = writer.getDataLength() - before
+        writer.items[lengthIndex] = struct.pack(">L", length)
+
+
+# https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html#ExtendedStateHeader
+# TODO: Untangle the implementation of the various lookup-specific formats.
+class STXHeader(BaseConverter):
+    def __init__(self, name, repeat, aux, tableClass, *, description=""):
+        BaseConverter.__init__(
+            self, name, repeat, aux, tableClass, description=description
+        )
+        assert issubclass(self.tableClass, AATAction)
+        self.classLookup = AATLookup("GlyphClasses", None, None, UShort)
+        if issubclass(self.tableClass, ContextualMorphAction):
+            self.perGlyphLookup = AATLookup("PerGlyphLookup", None, None, GlyphID)
+        else:
+            self.perGlyphLookup = None
+
+    def read(self, reader, font, tableDict):
+        table = AATStateTable()
+        pos = reader.pos
+        classTableReader = reader.getSubReader(0)
+        stateArrayReader = reader.getSubReader(0)
+        entryTableReader = reader.getSubReader(0)
+        actionReader = None
+        ligaturesReader = None
+        table.GlyphClassCount = reader.readULong()
+        classTableReader.seek(pos + reader.readULong())
+        stateArrayReader.seek(pos + reader.readULong())
+        entryTableReader.seek(pos + reader.readULong())
+        if self.perGlyphLookup is not None:
+            perGlyphTableReader = reader.getSubReader(0)
+            perGlyphTableReader.seek(pos + reader.readULong())
+        if issubclass(self.tableClass, LigatureMorphAction):
+            actionReader = reader.getSubReader(0)
+            actionReader.seek(pos + reader.readULong())
+            ligComponentReader = reader.getSubReader(0)
+            ligComponentReader.seek(pos + reader.readULong())
+            ligaturesReader = reader.getSubReader(0)
+            ligaturesReader.seek(pos + reader.readULong())
+            numLigComponents = (ligaturesReader.pos - ligComponentReader.pos) // 2
+            assert numLigComponents >= 0
+            table.LigComponents = ligComponentReader.readUShortArray(numLigComponents)
+            table.Ligatures = self._readLigatures(ligaturesReader, font)
+        elif issubclass(self.tableClass, InsertionMorphAction):
+            actionReader = reader.getSubReader(0)
+            actionReader.seek(pos + reader.readULong())
+        table.GlyphClasses = self.classLookup.read(classTableReader, font, tableDict)
+        numStates = int(
+            (entryTableReader.pos - stateArrayReader.pos) / (table.GlyphClassCount * 2)
+        )
+        for stateIndex in range(numStates):
+            state = AATState()
+            table.States.append(state)
+            for glyphClass in range(table.GlyphClassCount):
+                entryIndex = stateArrayReader.readUShort()
+                state.Transitions[glyphClass] = self._readTransition(
+                    entryTableReader, entryIndex, font, actionReader
+                )
+        if self.perGlyphLookup is not None:
+            table.PerGlyphLookups = self._readPerGlyphLookups(
+                table, perGlyphTableReader, font
+            )
+        return table
+
+    def _readTransition(self, reader, entryIndex, font, actionReader):
+        transition = self.tableClass()
+        entryReader = reader.getSubReader(
+            reader.pos + entryIndex * transition.staticSize
+        )
+        transition.decompile(entryReader, font, actionReader)
+        return transition
+
+    def _readLigatures(self, reader, font):
+        limit = len(reader.data)
+        numLigatureGlyphs = (limit - reader.pos) // 2
+        return font.getGlyphNameMany(reader.readUShortArray(numLigatureGlyphs))
+
+    def _countPerGlyphLookups(self, table):
+        # Somewhat annoyingly, the morx table does not encode
+        # the size of the per-glyph table. So we need to find
+        # the maximum value that MorphActions use as index
+        # into this table.
+        numLookups = 0
+        for state in table.States:
+            for t in state.Transitions.values():
+                if isinstance(t, ContextualMorphAction):
+                    if t.MarkIndex != 0xFFFF:
+                        numLookups = max(numLookups, t.MarkIndex + 1)
+                    if t.CurrentIndex != 0xFFFF:
+                        numLookups = max(numLookups, t.CurrentIndex + 1)
+        return numLookups
+
+    def _readPerGlyphLookups(self, table, reader, font):
+        pos = reader.pos
+        lookups = []
+        for _ in range(self._countPerGlyphLookups(table)):
+            lookupReader = reader.getSubReader(0)
+            lookupReader.seek(pos + reader.readULong())
+            lookups.append(self.perGlyphLookup.read(lookupReader, font, {}))
+        return lookups
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        glyphClassWriter = OTTableWriter()
+        self.classLookup.write(
+            glyphClassWriter, font, tableDict, value.GlyphClasses, repeatIndex=None
+        )
+        glyphClassData = pad(glyphClassWriter.getAllData(), 2)
+        glyphClassCount = max(value.GlyphClasses.values()) + 1
+        glyphClassTableOffset = 16  # size of STXHeader
+        if self.perGlyphLookup is not None:
+            glyphClassTableOffset += 4
+
+        glyphClassTableOffset += self.tableClass.actionHeaderSize
+        actionData, actionIndex = self.tableClass.compileActions(font, value.States)
+        stateArrayData, entryTableData = self._compileStates(
+            font, value.States, glyphClassCount, actionIndex
+        )
+        stateArrayOffset = glyphClassTableOffset + len(glyphClassData)
+        entryTableOffset = stateArrayOffset + len(stateArrayData)
+        perGlyphOffset = entryTableOffset + len(entryTableData)
+        perGlyphData = pad(self._compilePerGlyphLookups(value, font), 4)
+        if actionData is not None:
+            actionOffset = entryTableOffset + len(entryTableData)
+        else:
+            actionOffset = None
+
+        ligaturesOffset, ligComponentsOffset = None, None
+        ligComponentsData = self._compileLigComponents(value, font)
+        ligaturesData = self._compileLigatures(value, font)
+        if ligComponentsData is not None:
+            assert len(perGlyphData) == 0
+            ligComponentsOffset = actionOffset + len(actionData)
+            ligaturesOffset = ligComponentsOffset + len(ligComponentsData)
+
+        writer.writeULong(glyphClassCount)
+        writer.writeULong(glyphClassTableOffset)
+        writer.writeULong(stateArrayOffset)
+        writer.writeULong(entryTableOffset)
+        if self.perGlyphLookup is not None:
+            writer.writeULong(perGlyphOffset)
+        if actionOffset is not None:
+            writer.writeULong(actionOffset)
+        if ligComponentsOffset is not None:
+            writer.writeULong(ligComponentsOffset)
+            writer.writeULong(ligaturesOffset)
+        writer.writeData(glyphClassData)
+        writer.writeData(stateArrayData)
+        writer.writeData(entryTableData)
+        writer.writeData(perGlyphData)
+        if actionData is not None:
+            writer.writeData(actionData)
+        if ligComponentsData is not None:
+            writer.writeData(ligComponentsData)
+        if ligaturesData is not None:
+            writer.writeData(ligaturesData)
+
+    def _compileStates(self, font, states, glyphClassCount, actionIndex):
+        stateArrayWriter = OTTableWriter()
+        entries, entryIDs = [], {}
+        for state in states:
+            for glyphClass in range(glyphClassCount):
+                transition = state.Transitions[glyphClass]
+                entryWriter = OTTableWriter()
+                transition.compile(entryWriter, font, actionIndex)
+                entryData = entryWriter.getAllData()
+                assert (
+                    len(entryData) == transition.staticSize
+                ), "%s has staticSize %d, " "but actually wrote %d bytes" % (
+                    repr(transition),
+                    transition.staticSize,
+                    len(entryData),
+                )
+                entryIndex = entryIDs.get(entryData)
+                if entryIndex is None:
+                    entryIndex = len(entries)
+                    entryIDs[entryData] = entryIndex
+                    entries.append(entryData)
+                stateArrayWriter.writeUShort(entryIndex)
+        stateArrayData = pad(stateArrayWriter.getAllData(), 4)
+        entryTableData = pad(bytesjoin(entries), 4)
+        return stateArrayData, entryTableData
+
+    def _compilePerGlyphLookups(self, table, font):
+        if self.perGlyphLookup is None:
+            return b""
+        numLookups = self._countPerGlyphLookups(table)
+        assert len(table.PerGlyphLookups) == numLookups, (
+            "len(AATStateTable.PerGlyphLookups) is %d, "
+            "but the actions inside the table refer to %d"
+            % (len(table.PerGlyphLookups), numLookups)
+        )
+        writer = OTTableWriter()
+        for lookup in table.PerGlyphLookups:
+            lookupWriter = writer.getSubWriter()
+            self.perGlyphLookup.write(lookupWriter, font, {}, lookup, None)
+            writer.writeSubTable(lookupWriter, offsetSize=4)
+        return writer.getAllData()
+
+    def _compileLigComponents(self, table, font):
+        if not hasattr(table, "LigComponents"):
+            return None
+        writer = OTTableWriter()
+        for component in table.LigComponents:
+            writer.writeUShort(component)
+        return writer.getAllData()
+
+    def _compileLigatures(self, table, font):
+        if not hasattr(table, "Ligatures"):
+            return None
+        writer = OTTableWriter()
+        for glyphName in table.Ligatures:
+            writer.writeUShort(font.getGlyphID(glyphName))
+        return writer.getAllData()
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.begintag(name, attrs)
+        xmlWriter.newline()
+        xmlWriter.comment("GlyphClassCount=%s" % value.GlyphClassCount)
+        xmlWriter.newline()
+        for g, klass in sorted(value.GlyphClasses.items()):
+            xmlWriter.simpletag("GlyphClass", glyph=g, value=klass)
+            xmlWriter.newline()
+        for stateIndex, state in enumerate(value.States):
+            xmlWriter.begintag("State", index=stateIndex)
+            xmlWriter.newline()
+            for glyphClass, trans in sorted(state.Transitions.items()):
+                trans.toXML(
+                    xmlWriter,
+                    font=font,
+                    attrs={"onGlyphClass": glyphClass},
+                    name="Transition",
+                )
+            xmlWriter.endtag("State")
+            xmlWriter.newline()
+        for i, lookup in enumerate(value.PerGlyphLookups):
+            xmlWriter.begintag("PerGlyphLookup", index=i)
+            xmlWriter.newline()
+            for glyph, val in sorted(lookup.items()):
+                xmlWriter.simpletag("Lookup", glyph=glyph, value=val)
+                xmlWriter.newline()
+            xmlWriter.endtag("PerGlyphLookup")
+            xmlWriter.newline()
+        if hasattr(value, "LigComponents"):
+            xmlWriter.begintag("LigComponents")
+            xmlWriter.newline()
+            for i, val in enumerate(getattr(value, "LigComponents")):
+                xmlWriter.simpletag("LigComponent", index=i, value=val)
+                xmlWriter.newline()
+            xmlWriter.endtag("LigComponents")
+            xmlWriter.newline()
+        self._xmlWriteLigatures(xmlWriter, font, value, name, attrs)
+        xmlWriter.endtag(name)
+        xmlWriter.newline()
+
+    def _xmlWriteLigatures(self, xmlWriter, font, value, name, attrs):
+        if not hasattr(value, "Ligatures"):
+            return
+        xmlWriter.begintag("Ligatures")
+        xmlWriter.newline()
+        for i, g in enumerate(getattr(value, "Ligatures")):
+            xmlWriter.simpletag("Ligature", index=i, glyph=g)
+            xmlWriter.newline()
+        xmlWriter.endtag("Ligatures")
+        xmlWriter.newline()
+
+    def xmlRead(self, attrs, content, font):
+        table = AATStateTable()
+        for eltName, eltAttrs, eltContent in filter(istuple, content):
+            if eltName == "GlyphClass":
+                glyph = eltAttrs["glyph"]
+                value = eltAttrs["value"]
+                table.GlyphClasses[glyph] = safeEval(value)
+            elif eltName == "State":
+                state = self._xmlReadState(eltAttrs, eltContent, font)
+                table.States.append(state)
+            elif eltName == "PerGlyphLookup":
+                lookup = self.perGlyphLookup.xmlRead(eltAttrs, eltContent, font)
+                table.PerGlyphLookups.append(lookup)
+            elif eltName == "LigComponents":
+                table.LigComponents = self._xmlReadLigComponents(
+                    eltAttrs, eltContent, font
+                )
+            elif eltName == "Ligatures":
+                table.Ligatures = self._xmlReadLigatures(eltAttrs, eltContent, font)
+        table.GlyphClassCount = max(table.GlyphClasses.values()) + 1
+        return table
+
+    def _xmlReadState(self, attrs, content, font):
+        state = AATState()
+        for eltName, eltAttrs, eltContent in filter(istuple, content):
+            if eltName == "Transition":
+                glyphClass = safeEval(eltAttrs["onGlyphClass"])
+                transition = self.tableClass()
+                transition.fromXML(eltName, eltAttrs, eltContent, font)
+                state.Transitions[glyphClass] = transition
+        return state
+
+    def _xmlReadLigComponents(self, attrs, content, font):
+        ligComponents = []
+        for eltName, eltAttrs, _eltContent in filter(istuple, content):
+            if eltName == "LigComponent":
+                ligComponents.append(safeEval(eltAttrs["value"]))
+        return ligComponents
+
+    def _xmlReadLigatures(self, attrs, content, font):
+        ligs = []
+        for eltName, eltAttrs, _eltContent in filter(istuple, content):
+            if eltName == "Ligature":
+                ligs.append(eltAttrs["glyph"])
+        return ligs
+
+
+class CIDGlyphMap(BaseConverter):
+    def read(self, reader, font, tableDict):
+        numCIDs = reader.readUShort()
+        result = {}
+        for cid, glyphID in enumerate(reader.readUShortArray(numCIDs)):
+            if glyphID != 0xFFFF:
+                result[cid] = font.getGlyphName(glyphID)
+        return result
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        items = {cid: font.getGlyphID(glyph) for cid, glyph in value.items()}
+        count = max(items) + 1 if items else 0
+        writer.writeUShort(count)
+        for cid in range(count):
+            writer.writeUShort(items.get(cid, 0xFFFF))
+
+    def xmlRead(self, attrs, content, font):
+        result = {}
+        for eName, eAttrs, _eContent in filter(istuple, content):
+            if eName == "CID":
+                result[safeEval(eAttrs["cid"])] = eAttrs["glyph"].strip()
+        return result
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.begintag(name, attrs)
+        xmlWriter.newline()
+        for cid, glyph in sorted(value.items()):
+            if glyph is not None and glyph != 0xFFFF:
+                xmlWriter.simpletag("CID", cid=cid, glyph=glyph)
+                xmlWriter.newline()
+        xmlWriter.endtag(name)
+        xmlWriter.newline()
+
+
+class GlyphCIDMap(BaseConverter):
+    def read(self, reader, font, tableDict):
+        glyphOrder = font.getGlyphOrder()
+        count = reader.readUShort()
+        cids = reader.readUShortArray(count)
+        if count > len(glyphOrder):
+            log.warning(
+                "GlyphCIDMap has %d elements, "
+                "but the font has only %d glyphs; "
+                "ignoring the rest" % (count, len(glyphOrder))
+            )
+        result = {}
+        for glyphID in range(min(len(cids), len(glyphOrder))):
+            cid = cids[glyphID]
+            if cid != 0xFFFF:
+                result[glyphOrder[glyphID]] = cid
+        return result
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        items = {
+            font.getGlyphID(g): cid
+            for g, cid in value.items()
+            if cid is not None and cid != 0xFFFF
+        }
+        count = max(items) + 1 if items else 0
+        writer.writeUShort(count)
+        for glyphID in range(count):
+            writer.writeUShort(items.get(glyphID, 0xFFFF))
+
+    def xmlRead(self, attrs, content, font):
+        result = {}
+        for eName, eAttrs, _eContent in filter(istuple, content):
+            if eName == "CID":
+                result[eAttrs["glyph"]] = safeEval(eAttrs["value"])
+        return result
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.begintag(name, attrs)
+        xmlWriter.newline()
+        for glyph, cid in sorted(value.items()):
+            if cid is not None and cid != 0xFFFF:
+                xmlWriter.simpletag("CID", glyph=glyph, value=cid)
+                xmlWriter.newline()
+        xmlWriter.endtag(name)
+        xmlWriter.newline()
+
+
+class DeltaValue(BaseConverter):
+    def read(self, reader, font, tableDict):
+        StartSize = tableDict["StartSize"]
+        EndSize = tableDict["EndSize"]
+        DeltaFormat = tableDict["DeltaFormat"]
+        assert DeltaFormat in (1, 2, 3), "illegal DeltaFormat"
+        nItems = EndSize - StartSize + 1
+        nBits = 1 << DeltaFormat
+        minusOffset = 1 << nBits
+        mask = (1 << nBits) - 1
+        signMask = 1 << (nBits - 1)
+
+        DeltaValue = []
+        tmp, shift = 0, 0
+        for i in range(nItems):
+            if shift == 0:
+                tmp, shift = reader.readUShort(), 16
+            shift = shift - nBits
+            value = (tmp >> shift) & mask
+            if value & signMask:
+                value = value - minusOffset
+            DeltaValue.append(value)
+        return DeltaValue
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        StartSize = tableDict["StartSize"]
+        EndSize = tableDict["EndSize"]
+        DeltaFormat = tableDict["DeltaFormat"]
+        DeltaValue = value
+        assert DeltaFormat in (1, 2, 3), "illegal DeltaFormat"
+        nItems = EndSize - StartSize + 1
+        nBits = 1 << DeltaFormat
+        assert len(DeltaValue) == nItems
+        mask = (1 << nBits) - 1
+
+        tmp, shift = 0, 16
+        for value in DeltaValue:
+            shift = shift - nBits
+            tmp = tmp | ((value & mask) << shift)
+            if shift == 0:
+                writer.writeUShort(tmp)
+                tmp, shift = 0, 16
+        if shift != 16:
+            writer.writeUShort(tmp)
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", value)])
+        xmlWriter.newline()
+
+    def xmlRead(self, attrs, content, font):
+        return safeEval(attrs["value"])
+
+
+class VarIdxMapValue(BaseConverter):
+    def read(self, reader, font, tableDict):
+        fmt = tableDict["EntryFormat"]
+        nItems = tableDict["MappingCount"]
+
+        innerBits = 1 + (fmt & 0x000F)
+        innerMask = (1 << innerBits) - 1
+        outerMask = 0xFFFFFFFF - innerMask
+        outerShift = 16 - innerBits
+
+        entrySize = 1 + ((fmt & 0x0030) >> 4)
+        readArray = {
+            1: reader.readUInt8Array,
+            2: reader.readUShortArray,
+            3: reader.readUInt24Array,
+            4: reader.readULongArray,
+        }[entrySize]
+
+        return [
+            (((raw & outerMask) << outerShift) | (raw & innerMask))
+            for raw in readArray(nItems)
+        ]
+
+    def write(self, writer, font, tableDict, value, repeatIndex=None):
+        fmt = tableDict["EntryFormat"]
+        mapping = value
+        writer["MappingCount"].setValue(len(mapping))
+
+        innerBits = 1 + (fmt & 0x000F)
+        innerMask = (1 << innerBits) - 1
+        outerShift = 16 - innerBits
+
+        entrySize = 1 + ((fmt & 0x0030) >> 4)
+        writeArray = {
+            1: writer.writeUInt8Array,
+            2: writer.writeUShortArray,
+            3: writer.writeUInt24Array,
+            4: writer.writeULongArray,
+        }[entrySize]
+
+        writeArray(
+            [
+                (((idx & 0xFFFF0000) >> outerShift) | (idx & innerMask))
+                for idx in mapping
+            ]
+        )
+
+
+class VarDataValue(BaseConverter):
+    def read(self, reader, font, tableDict):
+        values = []
+
+        regionCount = tableDict["VarRegionCount"]
+        wordCount = tableDict["NumShorts"]
+
+        # https://github.com/fonttools/fonttools/issues/2279
+        longWords = bool(wordCount & 0x8000)
+        wordCount = wordCount & 0x7FFF
+
+        if longWords:
+            readBigArray, readSmallArray = reader.readLongArray, reader.readShortArray
+        else:
+            readBigArray, readSmallArray = reader.readShortArray, reader.readInt8Array
+
+        n1, n2 = min(regionCount, wordCount), max(regionCount, wordCount)
+        values.extend(readBigArray(n1))
+        values.extend(readSmallArray(n2 - n1))
+        if n2 > regionCount:  # Padding
+            del values[regionCount:]
+
+        return values
+
+    def write(self, writer, font, tableDict, values, repeatIndex=None):
+        regionCount = tableDict["VarRegionCount"]
+        wordCount = tableDict["NumShorts"]
+
+        # https://github.com/fonttools/fonttools/issues/2279
+        longWords = bool(wordCount & 0x8000)
+        wordCount = wordCount & 0x7FFF
+
+        (writeBigArray, writeSmallArray) = {
+            False: (writer.writeShortArray, writer.writeInt8Array),
+            True: (writer.writeLongArray, writer.writeShortArray),
+        }[longWords]
+
+        n1, n2 = min(regionCount, wordCount), max(regionCount, wordCount)
+        writeBigArray(values[:n1])
+        writeSmallArray(values[n1:regionCount])
+        if n2 > regionCount:  # Padding
+            writer.writeSmallArray([0] * (n2 - regionCount))
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", value)])
+        xmlWriter.newline()
+
+    def xmlRead(self, attrs, content, font):
+        return safeEval(attrs["value"])
+
+
+class TupleValues:
+    def read(self, data, font):
+        return TupleVariation.decompileDeltas_(None, data)[0]
+
+    def write(self, writer, font, tableDict, values, repeatIndex=None):
+        optimizeSpeed = font.cfg[OPTIMIZE_FONT_SPEED]
+        return bytes(
+            TupleVariation.compileDeltaValues_(values, optimizeSize=not optimizeSpeed)
+        )
+
+    def xmlRead(self, attrs, content, font):
+        return safeEval(attrs["value"])
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", value)])
+        xmlWriter.newline()
+
+
+class CFF2Index(BaseConverter):
+    def __init__(
+        self,
+        name,
+        repeat,
+        aux,
+        tableClass=None,
+        *,
+        itemClass=None,
+        itemConverterClass=None,
+        description="",
+    ):
+        BaseConverter.__init__(
+            self, name, repeat, aux, tableClass, description=description
+        )
+        self._itemClass = itemClass
+        self._converter = (
+            itemConverterClass() if itemConverterClass is not None else None
+        )
+
+    def read(self, reader, font, tableDict):
+        count = reader.readULong()
+        if count == 0:
+            return []
+        offSize = reader.readUInt8()
+
+        def getReadArray(reader, offSize):
+            return {
+                1: reader.readUInt8Array,
+                2: reader.readUShortArray,
+                3: reader.readUInt24Array,
+                4: reader.readULongArray,
+            }[offSize]
+
+        readArray = getReadArray(reader, offSize)
+
+        lazy = font.lazy is not False and count > 8
+        if not lazy:
+            offsets = readArray(count + 1)
+            items = []
+            lastOffset = offsets.pop(0)
+            reader.readData(lastOffset - 1)  # In case first offset is not 1
+
+            for offset in offsets:
+                assert lastOffset <= offset
+                item = reader.readData(offset - lastOffset)
+
+                if self._itemClass is not None:
+                    obj = self._itemClass()
+                    obj.decompile(item, font, reader.localState)
+                    item = obj
+                elif self._converter is not None:
+                    item = self._converter.read(item, font)
+
+                items.append(item)
+                lastOffset = offset
+            return items
+        else:
+
+            def get_read_item():
+                reader_copy = reader.copy()
+                offset_pos = reader.pos
+                data_pos = offset_pos + (count + 1) * offSize - 1
+                readArray = getReadArray(reader_copy, offSize)
+
+                def read_item(i):
+                    reader_copy.seek(offset_pos + i * offSize)
+                    offsets = readArray(2)
+                    reader_copy.seek(data_pos + offsets[0])
+                    item = reader_copy.readData(offsets[1] - offsets[0])
+
+                    if self._itemClass is not None:
+                        obj = self._itemClass()
+                        obj.decompile(item, font, reader_copy.localState)
+                        item = obj
+                    elif self._converter is not None:
+                        item = self._converter.read(item, font)
+                    return item
+
+                return read_item
+
+            read_item = get_read_item()
+            l = LazyList([read_item] * count)
+
+            # TODO: Advance reader
+
+            return l
+
+    def write(self, writer, font, tableDict, values, repeatIndex=None):
+        items = values
+
+        writer.writeULong(len(items))
+        if not len(items):
+            return
+
+        if self._itemClass is not None:
+            items = [item.compile(font) for item in items]
+        elif self._converter is not None:
+            items = [
+                self._converter.write(writer, font, tableDict, item, i)
+                for i, item in enumerate(items)
+            ]
+
+        offsets = [len(item) for item in items]
+        offsets = list(accumulate(offsets, initial=1))
+
+        lastOffset = offsets[-1]
+        offSize = (
+            1
+            if lastOffset < 0x100
+            else 2 if lastOffset < 0x10000 else 3 if lastOffset < 0x1000000 else 4
+        )
+        writer.writeUInt8(offSize)
+
+        writeArray = {
+            1: writer.writeUInt8Array,
+            2: writer.writeUShortArray,
+            3: writer.writeUInt24Array,
+            4: writer.writeULongArray,
+        }[offSize]
+
+        writeArray(offsets)
+        for item in items:
+            writer.writeData(item)
+
+    def xmlRead(self, attrs, content, font):
+        if self._itemClass is not None:
+            obj = self._itemClass()
+            obj.fromXML(None, attrs, content, font)
+            return obj
+        elif self._converter is not None:
+            return self._converter.xmlRead(attrs, content, font)
+        else:
+            raise NotImplementedError()
+
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        if self._itemClass is not None:
+            for i, item in enumerate(value):
+                item.toXML(xmlWriter, font, [("index", i)], name)
+        elif self._converter is not None:
+            for i, item in enumerate(value):
+                self._converter.xmlWrite(
+                    xmlWriter, font, item, name, attrs + [("index", i)]
+                )
+        else:
+            raise NotImplementedError()
+
+
+class LookupFlag(UShort):
+    def xmlWrite(self, xmlWriter, font, value, name, attrs):
+        xmlWriter.simpletag(name, attrs + [("value", value)])
+        flags = []
+        if value & 0x01:
+            flags.append("rightToLeft")
+        if value & 0x02:
+            flags.append("ignoreBaseGlyphs")
+        if value & 0x04:
+            flags.append("ignoreLigatures")
+        if value & 0x08:
+            flags.append("ignoreMarks")
+        if value & 0x10:
+            flags.append("useMarkFilteringSet")
+        if value & 0xFF00:
+            flags.append("markAttachmentType[%i]" % (value >> 8))
+        if flags:
+            xmlWriter.comment(" ".join(flags))
+        xmlWriter.newline()
+
+
+class _UInt8Enum(UInt8):
+    enumClass = NotImplemented
+
+    def read(self, reader, font, tableDict):
+        return self.enumClass(super().read(reader, font, tableDict))
+
+    @classmethod
+    def fromString(cls, value):
+        return getattr(cls.enumClass, value.upper())
+
+    @classmethod
+    def toString(cls, value):
+        return cls.enumClass(value).name.lower()
+
+
+class ExtendMode(_UInt8Enum):
+    enumClass = _ExtendMode
+
+
+class CompositeMode(_UInt8Enum):
+    enumClass = _CompositeMode
+
+
+converterMapping = {
+    # type		class
+    "int8": Int8,
+    "int16": Short,
+    "int32": Long,
+    "uint8": UInt8,
+    "uint16": UShort,
+    "uint24": UInt24,
+    "uint32": ULong,
+    "char64": Char64,
+    "Flags32": Flags32,
+    "VarIndex": VarIndex,
+    "Version": Version,
+    "Tag": Tag,
+    "GlyphID": GlyphID,
+    "GlyphID32": GlyphID32,
+    "NameID": NameID,
+    "DeciPoints": DeciPoints,
+    "Fixed": Fixed,
+    "F2Dot14": F2Dot14,
+    "Angle": Angle,
+    "BiasedAngle": BiasedAngle,
+    "struct": Struct,
+    "Offset": Table,
+    "LOffset": LTable,
+    "Offset24": Table24,
+    "ValueRecord": ValueRecord,
+    "DeltaValue": DeltaValue,
+    "VarIdxMapValue": VarIdxMapValue,
+    "VarDataValue": VarDataValue,
+    "LookupFlag": LookupFlag,
+    "ExtendMode": ExtendMode,
+    "CompositeMode": CompositeMode,
+    "STATFlags": STATFlags,
+    "TupleList": partial(CFF2Index, itemConverterClass=TupleValues),
+    "VarCompositeGlyphList": partial(CFF2Index, itemClass=VarCompositeGlyph),
+    # AAT
+    "CIDGlyphMap": CIDGlyphMap,
+    "GlyphCIDMap": GlyphCIDMap,
+    "MortChain": StructWithLength,
+    "MortSubtable": StructWithLength,
+    "MorxChain": StructWithLength,
+    "MorxSubtable": MorxSubtableConverter,
+    # "Template" types
+    "AATLookup": lambda C: partial(AATLookup, tableClass=C),
+    "AATLookupWithDataOffset": lambda C: partial(AATLookupWithDataOffset, tableClass=C),
+    "STXHeader": lambda C: partial(STXHeader, tableClass=C),
+    "OffsetTo": lambda C: partial(Table, tableClass=C),
+    "LOffsetTo": lambda C: partial(LTable, tableClass=C),
+    "LOffset24To": lambda C: partial(Table24, tableClass=C),
+}