Add files using upload-large-folder tool

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/site-packages/fontTools/ttLib/tables/G_M_A_P_.py

@@ -0,0 +1,148 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import tobytes, tostr, safeEval
+from . import DefaultTable
+
+GMAPFormat = """
+		>	# big endian
+		tableVersionMajor:	H
+		tableVersionMinor: 	H
+		flags:	H
+		recordsCount:		H
+		recordsOffset:		H
+		fontNameLength:		H
+"""
+# psFontName is a byte string which follows the record above. This is zero padded
+# to the beginning of the records array. The recordsOffsst is 32 bit aligned.
+
+GMAPRecordFormat1 = """
+		>	# big endian
+		UV:			L
+		cid:		H
+		gid:		H
+		ggid:		H
+		name:		32s
+"""
+
+
+class GMAPRecord(object):
+    def __init__(self, uv=0, cid=0, gid=0, ggid=0, name=""):
+        self.UV = uv
+        self.cid = cid
+        self.gid = gid
+        self.ggid = ggid
+        self.name = name
+
+    def toXML(self, writer, ttFont):
+        writer.begintag("GMAPRecord")
+        writer.newline()
+        writer.simpletag("UV", value=self.UV)
+        writer.newline()
+        writer.simpletag("cid", value=self.cid)
+        writer.newline()
+        writer.simpletag("gid", value=self.gid)
+        writer.newline()
+        writer.simpletag("glyphletGid", value=self.gid)
+        writer.newline()
+        writer.simpletag("GlyphletName", value=self.name)
+        writer.newline()
+        writer.endtag("GMAPRecord")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        value = attrs["value"]
+        if name == "GlyphletName":
+            self.name = value
+        else:
+            setattr(self, name, safeEval(value))
+
+    def compile(self, ttFont):
+        if self.UV is None:
+            self.UV = 0
+        nameLen = len(self.name)
+        if nameLen < 32:
+            self.name = self.name + "\0" * (32 - nameLen)
+        data = sstruct.pack(GMAPRecordFormat1, self)
+        return data
+
+    def __repr__(self):
+        return (
+            "GMAPRecord[ UV: "
+            + str(self.UV)
+            + ", cid: "
+            + str(self.cid)
+            + ", gid: "
+            + str(self.gid)
+            + ", ggid: "
+            + str(self.ggid)
+            + ", Glyphlet Name: "
+            + str(self.name)
+            + " ]"
+        )
+
+
+class table_G_M_A_P_(DefaultTable.DefaultTable):
+    """Glyphlets GMAP table
+
+    The ``GMAP`` table is used by Adobe's SING Glyphlets.
+
+    See also https://web.archive.org/web/20080627183635/http://www.adobe.com/devnet/opentype/gdk/topic.html
+    """
+
+    dependencies = []
+
+    def decompile(self, data, ttFont):
+        dummy, newData = sstruct.unpack2(GMAPFormat, data, self)
+        self.psFontName = tostr(newData[: self.fontNameLength])
+        assert (
+            self.recordsOffset % 4
+        ) == 0, "GMAP error: recordsOffset is not 32 bit aligned."
+        newData = data[self.recordsOffset :]
+        self.gmapRecords = []
+        for i in range(self.recordsCount):
+            gmapRecord, newData = sstruct.unpack2(
+                GMAPRecordFormat1, newData, GMAPRecord()
+            )
+            gmapRecord.name = gmapRecord.name.strip("\0")
+            self.gmapRecords.append(gmapRecord)
+
+    def compile(self, ttFont):
+        self.recordsCount = len(self.gmapRecords)
+        self.fontNameLength = len(self.psFontName)
+        self.recordsOffset = 4 * (((self.fontNameLength + 12) + 3) // 4)
+        data = sstruct.pack(GMAPFormat, self)
+        data = data + tobytes(self.psFontName)
+        data = data + b"\0" * (self.recordsOffset - len(data))
+        for record in self.gmapRecords:
+            data = data + record.compile(ttFont)
+        return data
+
+    def toXML(self, writer, ttFont):
+        writer.comment("Most of this table will be recalculated by the compiler")
+        writer.newline()
+        formatstring, names, fixes = sstruct.getformat(GMAPFormat)
+        for name in names:
+            value = getattr(self, name)
+            writer.simpletag(name, value=value)
+            writer.newline()
+        writer.simpletag("PSFontName", value=self.psFontName)
+        writer.newline()
+        for gmapRecord in self.gmapRecords:
+            gmapRecord.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "GMAPRecord":
+            if not hasattr(self, "gmapRecords"):
+                self.gmapRecords = []
+            gmapRecord = GMAPRecord()
+            self.gmapRecords.append(gmapRecord)
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                name, attrs, content = element
+                gmapRecord.fromXML(name, attrs, content, ttFont)
+        else:
+            value = attrs["value"]
+            if name == "PSFontName":
+                self.psFontName = value
+            else:
+                setattr(self, name, safeEval(value))

external/alphageometry/.venv-ag/Lib/site-packages/fontTools/ttLib/tables/G_P_K_G_.py

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

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/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)

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/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"])

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/site-packages/fontTools/ttLib/tables/M_E_T_A_.py

@@ -0,0 +1,352 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import byteord, safeEval
+from . import DefaultTable
+import pdb
+import struct
+
+
+METAHeaderFormat = """
+		>	# big endian
+		tableVersionMajor:			H
+		tableVersionMinor:			H
+		metaEntriesVersionMajor:	H
+		metaEntriesVersionMinor:	H
+		unicodeVersion:				L
+		metaFlags:					H
+		nMetaRecs:					H
+"""
+# This record is followed by nMetaRecs of METAGlyphRecordFormat.
+# This in turn is followd by as many METAStringRecordFormat entries
+# as specified by the METAGlyphRecordFormat entries
+# this is followed by the strings specifried in the  METAStringRecordFormat
+METAGlyphRecordFormat = """
+		>	# big endian
+		glyphID:			H
+		nMetaEntry:			H
+"""
+# This record is followd by a variable data length field:
+# 	USHORT or ULONG	hdrOffset
+# Offset from start of META table to the beginning
+# of this glyphs array of ns Metadata string entries.
+# Size determined by metaFlags field
+# METAGlyphRecordFormat entries must be sorted by glyph ID
+
+METAStringRecordFormat = """
+		>	# big endian
+		labelID:			H
+		stringLen:			H
+"""
+# This record is followd by a variable data length field:
+# 	USHORT or ULONG	stringOffset
+# METAStringRecordFormat entries must be sorted in order of labelID
+# There may be more than one entry with the same labelID
+# There may be more than one strign with the same content.
+
+# Strings shall be Unicode UTF-8 encoded, and null-terminated.
+
+METALabelDict = {
+    0: "MojikumiX4051",  # An integer in the range 1-20
+    1: "UNIUnifiedBaseChars",
+    2: "BaseFontName",
+    3: "Language",
+    4: "CreationDate",
+    5: "FoundryName",
+    6: "FoundryCopyright",
+    7: "OwnerURI",
+    8: "WritingScript",
+    10: "StrokeCount",
+    11: "IndexingRadical",
+}
+
+
+def getLabelString(labelID):
+    try:
+        label = METALabelDict[labelID]
+    except KeyError:
+        label = "Unknown label"
+    return str(label)
+
+
+class table_M_E_T_A_(DefaultTable.DefaultTable):
+    """Glyphlets META table
+
+    The ``META`` table is used by Adobe's SING Glyphlets.
+
+    See also https://web.archive.org/web/20080627183635/http://www.adobe.com/devnet/opentype/gdk/topic.html
+    """
+
+    dependencies = []
+
+    def decompile(self, data, ttFont):
+        dummy, newData = sstruct.unpack2(METAHeaderFormat, data, self)
+        self.glyphRecords = []
+        for i in range(self.nMetaRecs):
+            glyphRecord, newData = sstruct.unpack2(
+                METAGlyphRecordFormat, newData, GlyphRecord()
+            )
+            if self.metaFlags == 0:
+                [glyphRecord.offset] = struct.unpack(">H", newData[:2])
+                newData = newData[2:]
+            elif self.metaFlags == 1:
+                [glyphRecord.offset] = struct.unpack(">H", newData[:4])
+                newData = newData[4:]
+            else:
+                assert 0, (
+                    "The metaFlags field in the META table header has a value other than 0 or 1 :"
+                    + str(self.metaFlags)
+                )
+            glyphRecord.stringRecs = []
+            newData = data[glyphRecord.offset :]
+            for j in range(glyphRecord.nMetaEntry):
+                stringRec, newData = sstruct.unpack2(
+                    METAStringRecordFormat, newData, StringRecord()
+                )
+                if self.metaFlags == 0:
+                    [stringRec.offset] = struct.unpack(">H", newData[:2])
+                    newData = newData[2:]
+                else:
+                    [stringRec.offset] = struct.unpack(">H", newData[:4])
+                    newData = newData[4:]
+                stringRec.string = data[
+                    stringRec.offset : stringRec.offset + stringRec.stringLen
+                ]
+                glyphRecord.stringRecs.append(stringRec)
+            self.glyphRecords.append(glyphRecord)
+
+    def compile(self, ttFont):
+        offsetOK = 0
+        self.nMetaRecs = len(self.glyphRecords)
+        count = 0
+        while offsetOK != 1:
+            count = count + 1
+            if count > 4:
+                pdb.set_trace()
+            metaData = sstruct.pack(METAHeaderFormat, self)
+            stringRecsOffset = len(metaData) + self.nMetaRecs * (
+                6 + 2 * (self.metaFlags & 1)
+            )
+            stringRecSize = 6 + 2 * (self.metaFlags & 1)
+            for glyphRec in self.glyphRecords:
+                glyphRec.offset = stringRecsOffset
+                if (glyphRec.offset > 65535) and ((self.metaFlags & 1) == 0):
+                    self.metaFlags = self.metaFlags + 1
+                    offsetOK = -1
+                    break
+                metaData = metaData + glyphRec.compile(self)
+                stringRecsOffset = stringRecsOffset + (
+                    glyphRec.nMetaEntry * stringRecSize
+                )
+                # this will be the String Record offset for the next GlyphRecord.
+            if offsetOK == -1:
+                offsetOK = 0
+                continue
+
+            # metaData now contains the header and all of the GlyphRecords. Its length should bw
+            # the offset to the first StringRecord.
+            stringOffset = stringRecsOffset
+            for glyphRec in self.glyphRecords:
+                assert glyphRec.offset == len(
+                    metaData
+                ), "Glyph record offset did not compile correctly! for rec:" + str(
+                    glyphRec
+                )
+                for stringRec in glyphRec.stringRecs:
+                    stringRec.offset = stringOffset
+                    if (stringRec.offset > 65535) and ((self.metaFlags & 1) == 0):
+                        self.metaFlags = self.metaFlags + 1
+                        offsetOK = -1
+                        break
+                    metaData = metaData + stringRec.compile(self)
+                    stringOffset = stringOffset + stringRec.stringLen
+            if offsetOK == -1:
+                offsetOK = 0
+                continue
+
+            if ((self.metaFlags & 1) == 1) and (stringOffset < 65536):
+                self.metaFlags = self.metaFlags - 1
+                continue
+            else:
+                offsetOK = 1
+
+            # metaData now contains the header and all of the GlyphRecords and all of the String Records.
+            # Its length should be the offset to the first string datum.
+            for glyphRec in self.glyphRecords:
+                for stringRec in glyphRec.stringRecs:
+                    assert stringRec.offset == len(
+                        metaData
+                    ), "String offset did not compile correctly! for string:" + str(
+                        stringRec.string
+                    )
+                    metaData = metaData + stringRec.string
+
+        return metaData
+
+    def toXML(self, writer, ttFont):
+        writer.comment(
+            "Lengths and number of entries in this table will be recalculated by the compiler"
+        )
+        writer.newline()
+        formatstring, names, fixes = sstruct.getformat(METAHeaderFormat)
+        for name in names:
+            value = getattr(self, name)
+            writer.simpletag(name, value=value)
+            writer.newline()
+        for glyphRec in self.glyphRecords:
+            glyphRec.toXML(writer, ttFont)
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "GlyphRecord":
+            if not hasattr(self, "glyphRecords"):
+                self.glyphRecords = []
+            glyphRec = GlyphRecord()
+            self.glyphRecords.append(glyphRec)
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                name, attrs, content = element
+                glyphRec.fromXML(name, attrs, content, ttFont)
+            glyphRec.offset = -1
+            glyphRec.nMetaEntry = len(glyphRec.stringRecs)
+        else:
+            setattr(self, name, safeEval(attrs["value"]))
+
+
+class GlyphRecord(object):
+    def __init__(self):
+        self.glyphID = -1
+        self.nMetaEntry = -1
+        self.offset = -1
+        self.stringRecs = []
+
+    def toXML(self, writer, ttFont):
+        writer.begintag("GlyphRecord")
+        writer.newline()
+        writer.simpletag("glyphID", value=self.glyphID)
+        writer.newline()
+        writer.simpletag("nMetaEntry", value=self.nMetaEntry)
+        writer.newline()
+        for stringRec in self.stringRecs:
+            stringRec.toXML(writer, ttFont)
+        writer.endtag("GlyphRecord")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        if name == "StringRecord":
+            stringRec = StringRecord()
+            self.stringRecs.append(stringRec)
+            for element in content:
+                if isinstance(element, str):
+                    continue
+                stringRec.fromXML(name, attrs, content, ttFont)
+            stringRec.stringLen = len(stringRec.string)
+        else:
+            setattr(self, name, safeEval(attrs["value"]))
+
+    def compile(self, parentTable):
+        data = sstruct.pack(METAGlyphRecordFormat, self)
+        if parentTable.metaFlags == 0:
+            datum = struct.pack(">H", self.offset)
+        elif parentTable.metaFlags == 1:
+            datum = struct.pack(">L", self.offset)
+        data = data + datum
+        return data
+
+    def __repr__(self):
+        return (
+            "GlyphRecord[ glyphID: "
+            + str(self.glyphID)
+            + ", nMetaEntry: "
+            + str(self.nMetaEntry)
+            + ", offset: "
+            + str(self.offset)
+            + " ]"
+        )
+
+
+# XXX The following two functions are really broken around UTF-8 vs Unicode
+
+
+def mapXMLToUTF8(string):
+    uString = str()
+    strLen = len(string)
+    i = 0
+    while i < strLen:
+        prefixLen = 0
+        if string[i : i + 3] == "&#x":
+            prefixLen = 3
+        elif string[i : i + 7] == "&amp;#x":
+            prefixLen = 7
+        if prefixLen:
+            i = i + prefixLen
+            j = i
+            while string[i] != ";":
+                i = i + 1
+            valStr = string[j:i]
+
+            uString = uString + chr(eval("0x" + valStr))
+        else:
+            uString = uString + chr(byteord(string[i]))
+        i = i + 1
+
+    return uString.encode("utf_8")
+
+
+def mapUTF8toXML(string):
+    uString = string.decode("utf_8")
+    string = ""
+    for uChar in uString:
+        i = ord(uChar)
+        if (i < 0x80) and (i > 0x1F):
+            string = string + uChar
+        else:
+            string = string + "&#x" + hex(i)[2:] + ";"
+    return string
+
+
+class StringRecord(object):
+    def toXML(self, writer, ttFont):
+        writer.begintag("StringRecord")
+        writer.newline()
+        writer.simpletag("labelID", value=self.labelID)
+        writer.comment(getLabelString(self.labelID))
+        writer.newline()
+        writer.newline()
+        writer.simpletag("string", value=mapUTF8toXML(self.string))
+        writer.newline()
+        writer.endtag("StringRecord")
+        writer.newline()
+
+    def fromXML(self, name, attrs, content, ttFont):
+        for element in content:
+            if isinstance(element, str):
+                continue
+            name, attrs, content = element
+            value = attrs["value"]
+            if name == "string":
+                self.string = mapXMLToUTF8(value)
+            else:
+                setattr(self, name, safeEval(value))
+
+    def compile(self, parentTable):
+        data = sstruct.pack(METAStringRecordFormat, self)
+        if parentTable.metaFlags == 0:
+            datum = struct.pack(">H", self.offset)
+        elif parentTable.metaFlags == 1:
+            datum = struct.pack(">L", self.offset)
+        data = data + datum
+        return data
+
+    def __repr__(self):
+        return (
+            "StringRecord [ labelID: "
+            + str(self.labelID)
+            + " aka "
+            + getLabelString(self.labelID)
+            + ", offset: "
+            + str(self.offset)
+            + ", length: "
+            + str(self.stringLen)
+            + ", string: "
+            + self.string
+            + " ]"
+        )

external/alphageometry/.venv-ag/Lib/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

external/alphageometry/.venv-ag/Lib/site-packages/fontTools/ttLib/tables/otBase.py

@@ -0,0 +1,1464 @@
+from fontTools.config import OPTIONS
+from fontTools.misc.textTools import Tag, bytesjoin
+from .DefaultTable import DefaultTable
+from enum import IntEnum
+import sys
+import array
+import struct
+import logging
+from functools import lru_cache
+from typing import Iterator, NamedTuple, Optional, Tuple
+
+log = logging.getLogger(__name__)
+
+have_uharfbuzz = False
+try:
+    import uharfbuzz as hb
+
+    # repack method added in uharfbuzz >= 0.23; if uharfbuzz *can* be
+    # imported but repack method is missing, behave as if uharfbuzz
+    # is not available (fallback to the slower Python implementation)
+    have_uharfbuzz = callable(getattr(hb, "repack", None))
+except ImportError:
+    pass
+
+USE_HARFBUZZ_REPACKER = OPTIONS[f"{__name__}:USE_HARFBUZZ_REPACKER"]
+
+
+class OverflowErrorRecord(object):
+    def __init__(self, overflowTuple):
+        self.tableType = overflowTuple[0]
+        self.LookupListIndex = overflowTuple[1]
+        self.SubTableIndex = overflowTuple[2]
+        self.itemName = overflowTuple[3]
+        self.itemIndex = overflowTuple[4]
+
+    def __repr__(self):
+        return str(
+            (
+                self.tableType,
+                "LookupIndex:",
+                self.LookupListIndex,
+                "SubTableIndex:",
+                self.SubTableIndex,
+                "ItemName:",
+                self.itemName,
+                "ItemIndex:",
+                self.itemIndex,
+            )
+        )
+
+
+class OTLOffsetOverflowError(Exception):
+    def __init__(self, overflowErrorRecord):
+        self.value = overflowErrorRecord
+
+    def __str__(self):
+        return repr(self.value)
+
+
+class RepackerState(IntEnum):
+    # Repacking control flow is implemnted using a state machine. The state machine table:
+    #
+    # State       | Packing Success | Packing Failed | Exception Raised |
+    # ------------+-----------------+----------------+------------------+
+    # PURE_FT     | Return result   | PURE_FT        | Return failure   |
+    # HB_FT       | Return result   | HB_FT          | FT_FALLBACK      |
+    # FT_FALLBACK | HB_FT           | FT_FALLBACK    | Return failure   |
+
+    # Pack only with fontTools, don't allow sharing between extensions.
+    PURE_FT = 1
+
+    # Attempt to pack with harfbuzz (allowing sharing between extensions)
+    # use fontTools to attempt overflow resolution.
+    HB_FT = 2
+
+    # Fallback if HB/FT packing gets stuck. Pack only with fontTools, don't allow sharing between
+    # extensions.
+    FT_FALLBACK = 3
+
+
+class BaseTTXConverter(DefaultTable):
+    """Generic base class for TTX table converters. It functions as an
+    adapter between the TTX (ttLib actually) table model and the model
+    we use for OpenType tables, which is necessarily subtly different.
+    """
+
+    def decompile(self, data, font):
+        """Create an object from the binary data. Called automatically on access."""
+        from . import otTables
+
+        reader = OTTableReader(data, tableTag=self.tableTag)
+        tableClass = getattr(otTables, self.tableTag)
+        self.table = tableClass()
+        self.table.decompile(reader, font)
+
+    def compile(self, font):
+        """Compiles the table into binary. Called automatically on save."""
+
+        # General outline:
+        # Create a top-level OTTableWriter for the GPOS/GSUB table.
+        # 	Call the compile method for the the table
+        # 		for each 'converter' record in the table converter list
+        # 			call converter's write method for each item in the value.
+        # 				- For simple items, the write method adds a string to the
+        # 				writer's self.items list.
+        # 				- For Struct/Table/Subtable items, it add first adds new writer to the
+        # 				to the writer's self.items, then calls the item's compile method.
+        # 				This creates a tree of writers, rooted at the GUSB/GPOS writer, with
+        # 				each writer representing a table, and the writer.items list containing
+        # 				the child data strings and writers.
+        # 	call the getAllData method
+        # 		call _doneWriting, which removes duplicates
+        # 		call _gatherTables. This traverses the tables, adding unique occurences to a flat list of tables
+        # 		Traverse the flat list of tables, calling getDataLength on each to update their position
+        # 		Traverse the flat list of tables again, calling getData each get the data in the table, now that
+        # 		pos's and offset are known.
+
+        # 		If a lookup subtable overflows an offset, we have to start all over.
+        overflowRecord = None
+        # this is 3-state option: default (None) means automatically use hb.repack or
+        # silently fall back if it fails; True, use it and raise error if not possible
+        # or it errors out; False, don't use it, even if you can.
+        use_hb_repack = font.cfg[USE_HARFBUZZ_REPACKER]
+        if self.tableTag in ("GSUB", "GPOS"):
+            if use_hb_repack is False:
+                log.debug(
+                    "hb.repack disabled, compiling '%s' with pure-python serializer",
+                    self.tableTag,
+                )
+            elif not have_uharfbuzz:
+                if use_hb_repack is True:
+                    raise ImportError("No module named 'uharfbuzz'")
+                else:
+                    assert use_hb_repack is None
+                    log.debug(
+                        "uharfbuzz not found, compiling '%s' with pure-python serializer",
+                        self.tableTag,
+                    )
+
+        if (
+            use_hb_repack in (None, True)
+            and have_uharfbuzz
+            and self.tableTag in ("GSUB", "GPOS")
+        ):
+            state = RepackerState.HB_FT
+        else:
+            state = RepackerState.PURE_FT
+
+        hb_first_error_logged = False
+        lastOverflowRecord = None
+        while True:
+            try:
+                writer = OTTableWriter(tableTag=self.tableTag)
+                self.table.compile(writer, font)
+                if state == RepackerState.HB_FT:
+                    return self.tryPackingHarfbuzz(writer, hb_first_error_logged)
+                elif state == RepackerState.PURE_FT:
+                    return self.tryPackingFontTools(writer)
+                elif state == RepackerState.FT_FALLBACK:
+                    # Run packing with FontTools only, but don't return the result as it will
+                    # not be optimally packed. Once a successful packing has been found, state is
+                    # changed back to harfbuzz packing to produce the final, optimal, packing.
+                    self.tryPackingFontTools(writer)
+                    log.debug(
+                        "Re-enabling sharing between extensions and switching back to "
+                        "harfbuzz+fontTools packing."
+                    )
+                    state = RepackerState.HB_FT
+
+            except OTLOffsetOverflowError as e:
+                hb_first_error_logged = True
+                ok = self.tryResolveOverflow(font, e, lastOverflowRecord)
+                lastOverflowRecord = e.value
+
+                if ok:
+                    continue
+
+                if state is RepackerState.HB_FT:
+                    log.debug(
+                        "Harfbuzz packing out of resolutions, disabling sharing between extensions and "
+                        "switching to fontTools only packing."
+                    )
+                    state = RepackerState.FT_FALLBACK
+                else:
+                    raise
+
+    def tryPackingHarfbuzz(self, writer, hb_first_error_logged):
+        try:
+            log.debug("serializing '%s' with hb.repack", self.tableTag)
+            return writer.getAllDataUsingHarfbuzz(self.tableTag)
+        except (ValueError, MemoryError, hb.RepackerError) as e:
+            # Only log hb repacker errors the first time they occur in
+            # the offset-overflow resolution loop, they are just noisy.
+            # Maybe we can revisit this if/when uharfbuzz actually gives
+            # us more info as to why hb.repack failed...
+            if not hb_first_error_logged:
+                error_msg = f"{type(e).__name__}"
+                if str(e) != "":
+                    error_msg += f": {e}"
+                log.warning(
+                    "hb.repack failed to serialize '%s', attempting fonttools resolutions "
+                    "; the error message was: %s",
+                    self.tableTag,
+                    error_msg,
+                )
+                hb_first_error_logged = True
+            return writer.getAllData(remove_duplicate=False)
+
+    def tryPackingFontTools(self, writer):
+        return writer.getAllData()
+
+    def tryResolveOverflow(self, font, e, lastOverflowRecord):
+        ok = 0
+        if lastOverflowRecord == e.value:
+            # Oh well...
+            return ok
+
+        overflowRecord = e.value
+        log.info("Attempting to fix OTLOffsetOverflowError %s", e)
+
+        if overflowRecord.itemName is None:
+            from .otTables import fixLookupOverFlows
+
+            ok = fixLookupOverFlows(font, overflowRecord)
+        else:
+            from .otTables import fixSubTableOverFlows
+
+            ok = fixSubTableOverFlows(font, overflowRecord)
+
+        if ok:
+            return ok
+
+        # Try upgrading lookup to Extension and hope
+        # that cross-lookup sharing not happening would
+        # fix overflow...
+        from .otTables import fixLookupOverFlows
+
+        return fixLookupOverFlows(font, overflowRecord)
+
+    def toXML(self, writer, font):
+        self.table.toXML2(writer, font)
+
+    def fromXML(self, name, attrs, content, font):
+        from . import otTables
+
+        if not hasattr(self, "table"):
+            tableClass = getattr(otTables, self.tableTag)
+            self.table = tableClass()
+        self.table.fromXML(name, attrs, content, font)
+        self.table.populateDefaults()
+
+    def ensureDecompiled(self, recurse=True):
+        self.table.ensureDecompiled(recurse=recurse)
+
+
+# https://github.com/fonttools/fonttools/pull/2285#issuecomment-834652928
+assert len(struct.pack("i", 0)) == 4
+assert array.array("i").itemsize == 4, "Oops, file a bug against fonttools."
+
+
+class OTTableReader(object):
+    """Helper class to retrieve data from an OpenType table."""
+
+    __slots__ = ("data", "offset", "pos", "localState", "tableTag")
+
+    def __init__(self, data, localState=None, offset=0, tableTag=None):
+        self.data = data
+        self.offset = offset
+        self.pos = offset
+        self.localState = localState
+        self.tableTag = tableTag
+
+    def advance(self, count):
+        self.pos += count
+
+    def seek(self, pos):
+        self.pos = pos
+
+    def copy(self):
+        other = self.__class__(self.data, self.localState, self.offset, self.tableTag)
+        other.pos = self.pos
+        return other
+
+    def getSubReader(self, offset):
+        offset = self.offset + offset
+        return self.__class__(self.data, self.localState, offset, self.tableTag)
+
+    def readValue(self, typecode, staticSize):
+        pos = self.pos
+        newpos = pos + staticSize
+        (value,) = struct.unpack(f">{typecode}", self.data[pos:newpos])
+        self.pos = newpos
+        return value
+
+    def readArray(self, typecode, staticSize, count):
+        pos = self.pos
+        newpos = pos + count * staticSize
+        value = array.array(typecode, self.data[pos:newpos])
+        if sys.byteorder != "big":
+            value.byteswap()
+        self.pos = newpos
+        return value.tolist()
+
+    def readInt8(self):
+        return self.readValue("b", staticSize=1)
+
+    def readInt8Array(self, count):
+        return self.readArray("b", staticSize=1, count=count)
+
+    def readShort(self):
+        return self.readValue("h", staticSize=2)
+
+    def readShortArray(self, count):
+        return self.readArray("h", staticSize=2, count=count)
+
+    def readLong(self):
+        return self.readValue("i", staticSize=4)
+
+    def readLongArray(self, count):
+        return self.readArray("i", staticSize=4, count=count)
+
+    def readUInt8(self):
+        return self.readValue("B", staticSize=1)
+
+    def readUInt8Array(self, count):
+        return self.readArray("B", staticSize=1, count=count)
+
+    def readUShort(self):
+        return self.readValue("H", staticSize=2)
+
+    def readUShortArray(self, count):
+        return self.readArray("H", staticSize=2, count=count)
+
+    def readULong(self):
+        return self.readValue("I", staticSize=4)
+
+    def readULongArray(self, count):
+        return self.readArray("I", staticSize=4, count=count)
+
+    def readUInt24(self):
+        pos = self.pos
+        newpos = pos + 3
+        (value,) = struct.unpack(">l", b"\0" + self.data[pos:newpos])
+        self.pos = newpos
+        return value
+
+    def readUInt24Array(self, count):
+        return [self.readUInt24() for _ in range(count)]
+
+    def readTag(self):
+        pos = self.pos
+        newpos = pos + 4
+        value = Tag(self.data[pos:newpos])
+        assert len(value) == 4, value
+        self.pos = newpos
+        return value
+
+    def readData(self, count):
+        pos = self.pos
+        newpos = pos + count
+        value = self.data[pos:newpos]
+        self.pos = newpos
+        return value
+
+    def __setitem__(self, name, value):
+        state = self.localState.copy() if self.localState else dict()
+        state[name] = value
+        self.localState = state
+
+    def __getitem__(self, name):
+        return self.localState and self.localState[name]
+
+    def __contains__(self, name):
+        return self.localState and name in self.localState
+
+
+class OffsetToWriter(object):
+    def __init__(self, subWriter, offsetSize):
+        self.subWriter = subWriter
+        self.offsetSize = offsetSize
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            return NotImplemented
+        return self.subWriter == other.subWriter and self.offsetSize == other.offsetSize
+
+    def __hash__(self):
+        # only works after self._doneWriting() has been called
+        return hash((self.subWriter, self.offsetSize))
+
+
+class OTTableWriter(object):
+    """Helper class to gather and assemble data for OpenType tables."""
+
+    def __init__(self, localState=None, tableTag=None):
+        self.items = []
+        self.pos = None
+        self.localState = localState
+        self.tableTag = tableTag
+        self.parent = None
+        self.name = "<none>"
+
+    def __setitem__(self, name, value):
+        state = self.localState.copy() if self.localState else dict()
+        state[name] = value
+        self.localState = state
+
+    def __getitem__(self, name):
+        return self.localState[name]
+
+    def __delitem__(self, name):
+        del self.localState[name]
+
+    # assembler interface
+
+    def getDataLength(self):
+        """Return the length of this table in bytes, without subtables."""
+        l = 0
+        for item in self.items:
+            if hasattr(item, "getCountData"):
+                l += item.size
+            elif hasattr(item, "subWriter"):
+                l += item.offsetSize
+            else:
+                l = l + len(item)
+        return l
+
+    def getData(self):
+        """Assemble the data for this writer/table, without subtables."""
+        items = list(self.items)  # make a shallow copy
+        pos = self.pos
+        numItems = len(items)
+        for i in range(numItems):
+            item = items[i]
+
+            if hasattr(item, "subWriter"):
+                if item.offsetSize == 4:
+                    items[i] = packULong(item.subWriter.pos - pos)
+                elif item.offsetSize == 2:
+                    try:
+                        items[i] = packUShort(item.subWriter.pos - pos)
+                    except struct.error:
+                        # provide data to fix overflow problem.
+                        overflowErrorRecord = self.getOverflowErrorRecord(
+                            item.subWriter
+                        )
+
+                        raise OTLOffsetOverflowError(overflowErrorRecord)
+                elif item.offsetSize == 3:
+                    items[i] = packUInt24(item.subWriter.pos - pos)
+                else:
+                    raise ValueError(item.offsetSize)
+
+        return bytesjoin(items)
+
+    def getDataForHarfbuzz(self):
+        """Assemble the data for this writer/table with all offset field set to 0"""
+        items = list(self.items)
+        packFuncs = {2: packUShort, 3: packUInt24, 4: packULong}
+        for i, item in enumerate(items):
+            if hasattr(item, "subWriter"):
+                # Offset value is not needed in harfbuzz repacker, so setting offset to 0 to avoid overflow here
+                if item.offsetSize in packFuncs:
+                    items[i] = packFuncs[item.offsetSize](0)
+                else:
+                    raise ValueError(item.offsetSize)
+
+        return bytesjoin(items)
+
+    def __hash__(self):
+        # only works after self._doneWriting() has been called
+        return hash(self.items)
+
+    def __ne__(self, other):
+        result = self.__eq__(other)
+        return result if result is NotImplemented else not result
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            return NotImplemented
+        return self.items == other.items
+
+    def _doneWriting(self, internedTables, shareExtension=False):
+        # Convert CountData references to data string items
+        # collapse duplicate table references to a unique entry
+        # "tables" are OTTableWriter objects.
+
+        # For Extension Lookup types, we can
+        # eliminate duplicates only within the tree under the Extension Lookup,
+        # as offsets may exceed 64K even between Extension LookupTable subtables.
+        isExtension = hasattr(self, "Extension")
+
+        # Certain versions of Uniscribe reject the font if the GSUB/GPOS top-level
+        # arrays (ScriptList, FeatureList, LookupList) point to the same, possibly
+        # empty, array.  So, we don't share those.
+        # See: https://github.com/fonttools/fonttools/issues/518
+        dontShare = hasattr(self, "DontShare")
+
+        if isExtension and not shareExtension:
+            internedTables = {}
+
+        items = self.items
+        for i, item in enumerate(items):
+            if hasattr(item, "getCountData"):
+                items[i] = item.getCountData()
+            elif hasattr(item, "subWriter"):
+                item.subWriter._doneWriting(
+                    internedTables, shareExtension=shareExtension
+                )
+                # At this point, all subwriters are hashable based on their items.
+                # (See hash and comparison magic methods above.) So the ``setdefault``
+                # call here will return the first writer object we've seen with
+                # equal content, or store it in the dictionary if it's not been
+                # seen yet. We therefore replace the subwriter object with an equivalent
+                # object, which deduplicates the tree.
+                if not dontShare:
+                    items[i].subWriter = internedTables.setdefault(
+                        item.subWriter, item.subWriter
+                    )
+        self.items = tuple(items)
+
+    def _gatherTables(self, tables, extTables, done):
+        # Convert table references in self.items tree to a flat
+        # list of tables in depth-first traversal order.
+        # "tables" are OTTableWriter objects.
+        # We do the traversal in reverse order at each level, in order to
+        # resolve duplicate references to be the last reference in the list of tables.
+        # For extension lookups, duplicate references can be merged only within the
+        # writer tree under the  extension lookup.
+
+        done[id(self)] = True
+
+        numItems = len(self.items)
+        iRange = list(range(numItems))
+        iRange.reverse()
+
+        isExtension = hasattr(self, "Extension")
+
+        selfTables = tables
+
+        if isExtension:
+            assert (
+                extTables is not None
+            ), "Program or XML editing error. Extension subtables cannot contain extensions subtables"
+            tables, extTables, done = extTables, None, {}
+
+        # add Coverage table if it is sorted last.
+        sortCoverageLast = False
+        if hasattr(self, "sortCoverageLast"):
+            # Find coverage table
+            for i in range(numItems):
+                item = self.items[i]
+                if (
+                    hasattr(item, "subWriter")
+                    and getattr(item.subWriter, "name", None) == "Coverage"
+                ):
+                    sortCoverageLast = True
+                    break
+            if id(item.subWriter) not in done:
+                item.subWriter._gatherTables(tables, extTables, done)
+            else:
+                # We're a new parent of item
+                pass
+
+        for i in iRange:
+            item = self.items[i]
+            if not hasattr(item, "subWriter"):
+                continue
+
+            if (
+                sortCoverageLast
+                and (i == 1)
+                and getattr(item.subWriter, "name", None) == "Coverage"
+            ):
+                # we've already 'gathered' it above
+                continue
+
+            if id(item.subWriter) not in done:
+                item.subWriter._gatherTables(tables, extTables, done)
+            else:
+                # Item is already written out by other parent
+                pass
+
+        selfTables.append(self)
+
+    def _gatherGraphForHarfbuzz(self, tables, obj_list, done, objidx, virtual_edges):
+        real_links = []
+        virtual_links = []
+        item_idx = objidx
+
+        # Merge virtual_links from parent
+        for idx in virtual_edges:
+            virtual_links.append((0, 0, idx))
+
+        sortCoverageLast = False
+        coverage_idx = 0
+        if hasattr(self, "sortCoverageLast"):
+            # Find coverage table
+            for i, item in enumerate(self.items):
+                if getattr(item, "name", None) == "Coverage":
+                    sortCoverageLast = True
+                    if id(item) not in done:
+                        coverage_idx = item_idx = item._gatherGraphForHarfbuzz(
+                            tables, obj_list, done, item_idx, virtual_edges
+                        )
+                    else:
+                        coverage_idx = done[id(item)]
+                    virtual_edges.append(coverage_idx)
+                    break
+
+        child_idx = 0
+        offset_pos = 0
+        for i, item in enumerate(self.items):
+            if hasattr(item, "subWriter"):
+                pos = offset_pos
+            elif hasattr(item, "getCountData"):
+                offset_pos += item.size
+                continue
+            else:
+                offset_pos = offset_pos + len(item)
+                continue
+
+            if id(item.subWriter) not in done:
+                child_idx = item_idx = item.subWriter._gatherGraphForHarfbuzz(
+                    tables, obj_list, done, item_idx, virtual_edges
+                )
+            else:
+                child_idx = done[id(item.subWriter)]
+
+            real_edge = (pos, item.offsetSize, child_idx)
+            real_links.append(real_edge)
+            offset_pos += item.offsetSize
+
+        tables.append(self)
+        obj_list.append((real_links, virtual_links))
+        item_idx += 1
+        done[id(self)] = item_idx
+        if sortCoverageLast:
+            virtual_edges.pop()
+
+        return item_idx
+
+    def getAllDataUsingHarfbuzz(self, tableTag):
+        """The Whole table is represented as a Graph.
+        Assemble graph data and call Harfbuzz repacker to pack the table.
+        Harfbuzz repacker is faster and retain as much sub-table sharing as possible, see also:
+        https://github.com/harfbuzz/harfbuzz/blob/main/docs/repacker.md
+        The input format for hb.repack() method is explained here:
+        https://github.com/harfbuzz/uharfbuzz/blob/main/src/uharfbuzz/_harfbuzz.pyx#L1149
+        """
+        internedTables = {}
+        self._doneWriting(internedTables, shareExtension=True)
+        tables = []
+        obj_list = []
+        done = {}
+        objidx = 0
+        virtual_edges = []
+        self._gatherGraphForHarfbuzz(tables, obj_list, done, objidx, virtual_edges)
+        # Gather all data in two passes: the absolute positions of all
+        # subtable are needed before the actual data can be assembled.
+        pos = 0
+        for table in tables:
+            table.pos = pos
+            pos = pos + table.getDataLength()
+
+        data = []
+        for table in tables:
+            tableData = table.getDataForHarfbuzz()
+            data.append(tableData)
+
+        if hasattr(hb, "repack_with_tag"):
+            return hb.repack_with_tag(str(tableTag), data, obj_list)
+        else:
+            return hb.repack(data, obj_list)
+
+    def getAllData(self, remove_duplicate=True):
+        """Assemble all data, including all subtables."""
+        if remove_duplicate:
+            internedTables = {}
+            self._doneWriting(internedTables)
+        tables = []
+        extTables = []
+        done = {}
+        self._gatherTables(tables, extTables, done)
+        tables.reverse()
+        extTables.reverse()
+        # Gather all data in two passes: the absolute positions of all
+        # subtable are needed before the actual data can be assembled.
+        pos = 0
+        for table in tables:
+            table.pos = pos
+            pos = pos + table.getDataLength()
+
+        for table in extTables:
+            table.pos = pos
+            pos = pos + table.getDataLength()
+
+        data = []
+        for table in tables:
+            tableData = table.getData()
+            data.append(tableData)
+
+        for table in extTables:
+            tableData = table.getData()
+            data.append(tableData)
+
+        return bytesjoin(data)
+
+    # interface for gathering data, as used by table.compile()
+
+    def getSubWriter(self):
+        subwriter = self.__class__(self.localState, self.tableTag)
+        subwriter.parent = (
+            self  # because some subtables have idential values, we discard
+        )
+        # the duplicates under the getAllData method. Hence some
+        # subtable writers can have more than one parent writer.
+        # But we just care about first one right now.
+        return subwriter
+
+    def writeValue(self, typecode, value):
+        self.items.append(struct.pack(f">{typecode}", value))
+
+    def writeArray(self, typecode, values):
+        a = array.array(typecode, values)
+        if sys.byteorder != "big":
+            a.byteswap()
+        self.items.append(a.tobytes())
+
+    def writeInt8(self, value):
+        assert -128 <= value < 128, value
+        self.items.append(struct.pack(">b", value))
+
+    def writeInt8Array(self, values):
+        self.writeArray("b", values)
+
+    def writeShort(self, value):
+        assert -32768 <= value < 32768, value
+        self.items.append(struct.pack(">h", value))
+
+    def writeShortArray(self, values):
+        self.writeArray("h", values)
+
+    def writeLong(self, value):
+        self.items.append(struct.pack(">i", value))
+
+    def writeLongArray(self, values):
+        self.writeArray("i", values)
+
+    def writeUInt8(self, value):
+        assert 0 <= value < 256, value
+        self.items.append(struct.pack(">B", value))
+
+    def writeUInt8Array(self, values):
+        self.writeArray("B", values)
+
+    def writeUShort(self, value):
+        assert 0 <= value < 0x10000, value
+        self.items.append(struct.pack(">H", value))
+
+    def writeUShortArray(self, values):
+        self.writeArray("H", values)
+
+    def writeULong(self, value):
+        self.items.append(struct.pack(">I", value))
+
+    def writeULongArray(self, values):
+        self.writeArray("I", values)
+
+    def writeUInt24(self, value):
+        assert 0 <= value < 0x1000000, value
+        b = struct.pack(">L", value)
+        self.items.append(b[1:])
+
+    def writeUInt24Array(self, values):
+        for value in values:
+            self.writeUInt24(value)
+
+    def writeTag(self, tag):
+        tag = Tag(tag).tobytes()
+        assert len(tag) == 4, tag
+        self.items.append(tag)
+
+    def writeSubTable(self, subWriter, offsetSize):
+        self.items.append(OffsetToWriter(subWriter, offsetSize))
+
+    def writeCountReference(self, table, name, size=2, value=None):
+        ref = CountReference(table, name, size=size, value=value)
+        self.items.append(ref)
+        return ref
+
+    def writeStruct(self, format, values):
+        data = struct.pack(*(format,) + values)
+        self.items.append(data)
+
+    def writeData(self, data):
+        self.items.append(data)
+
+    def getOverflowErrorRecord(self, item):
+        LookupListIndex = SubTableIndex = itemName = itemIndex = None
+        if self.name == "LookupList":
+            LookupListIndex = item.repeatIndex
+        elif self.name == "Lookup":
+            LookupListIndex = self.repeatIndex
+            SubTableIndex = item.repeatIndex
+        else:
+            itemName = getattr(item, "name", "<none>")
+            if hasattr(item, "repeatIndex"):
+                itemIndex = item.repeatIndex
+            if self.name == "SubTable":
+                LookupListIndex = self.parent.repeatIndex
+                SubTableIndex = self.repeatIndex
+            elif self.name == "ExtSubTable":
+                LookupListIndex = self.parent.parent.repeatIndex
+                SubTableIndex = self.parent.repeatIndex
+            else:  # who knows how far below the SubTable level we are! Climb back up to the nearest subtable.
+                itemName = ".".join([self.name, itemName])
+                p1 = self.parent
+                while p1 and p1.name not in ["ExtSubTable", "SubTable"]:
+                    itemName = ".".join([p1.name, itemName])
+                    p1 = p1.parent
+                if p1:
+                    if p1.name == "ExtSubTable":
+                        LookupListIndex = p1.parent.parent.repeatIndex
+                        SubTableIndex = p1.parent.repeatIndex
+                    else:
+                        LookupListIndex = p1.parent.repeatIndex
+                        SubTableIndex = p1.repeatIndex
+
+        return OverflowErrorRecord(
+            (self.tableTag, LookupListIndex, SubTableIndex, itemName, itemIndex)
+        )
+
+
+class CountReference(object):
+    """A reference to a Count value, not a count of references."""
+
+    def __init__(self, table, name, size=None, value=None):
+        self.table = table
+        self.name = name
+        self.size = size
+        if value is not None:
+            self.setValue(value)
+
+    def setValue(self, value):
+        table = self.table
+        name = self.name
+        if table[name] is None:
+            table[name] = value
+        else:
+            assert table[name] == value, (name, table[name], value)
+
+    def getValue(self):
+        return self.table[self.name]
+
+    def getCountData(self):
+        v = self.table[self.name]
+        if v is None:
+            v = 0
+        return {1: packUInt8, 2: packUShort, 4: packULong}[self.size](v)
+
+
+def packUInt8(value):
+    return struct.pack(">B", value)
+
+
+def packUShort(value):
+    return struct.pack(">H", value)
+
+
+def packULong(value):
+    assert 0 <= value < 0x100000000, value
+    return struct.pack(">I", value)
+
+
+def packUInt24(value):
+    assert 0 <= value < 0x1000000, value
+    return struct.pack(">I", value)[1:]
+
+
+class BaseTable(object):
+    """Generic base class for all OpenType (sub)tables."""
+
+    def __getattr__(self, attr):
+        reader = self.__dict__.get("reader")
+        if reader:
+            del self.reader
+            font = self.font
+            del self.font
+            self.decompile(reader, font)
+            return getattr(self, attr)
+
+        raise AttributeError(attr)
+
+    def ensureDecompiled(self, recurse=False):
+        reader = self.__dict__.get("reader")
+        if reader:
+            del self.reader
+            font = self.font
+            del self.font
+            self.decompile(reader, font)
+        if recurse:
+            for subtable in self.iterSubTables():
+                subtable.value.ensureDecompiled(recurse)
+
+    def __getstate__(self):
+        # before copying/pickling 'lazy' objects, make a shallow copy of OTTableReader
+        # https://github.com/fonttools/fonttools/issues/2965
+        if "reader" in self.__dict__:
+            state = self.__dict__.copy()
+            state["reader"] = self.__dict__["reader"].copy()
+            return state
+        return self.__dict__
+
+    @classmethod
+    def getRecordSize(cls, reader):
+        totalSize = 0
+        for conv in cls.converters:
+            size = conv.getRecordSize(reader)
+            if size is NotImplemented:
+                return NotImplemented
+            countValue = 1
+            if conv.repeat:
+                if conv.repeat in reader:
+                    countValue = reader[conv.repeat] + conv.aux
+                else:
+                    return NotImplemented
+            totalSize += size * countValue
+        return totalSize
+
+    def getConverters(self):
+        return self.converters
+
+    def getConverterByName(self, name):
+        return self.convertersByName[name]
+
+    def populateDefaults(self, propagator=None):
+        for conv in self.getConverters():
+            if conv.repeat:
+                if not hasattr(self, conv.name):
+                    setattr(self, conv.name, [])
+                countValue = len(getattr(self, conv.name)) - conv.aux
+                try:
+                    count_conv = self.getConverterByName(conv.repeat)
+                    setattr(self, conv.repeat, countValue)
+                except KeyError:
+                    # conv.repeat is a propagated count
+                    if propagator and conv.repeat in propagator:
+                        propagator[conv.repeat].setValue(countValue)
+            else:
+                if conv.aux and not eval(conv.aux, None, self.__dict__):
+                    continue
+                if hasattr(self, conv.name):
+                    continue  # Warn if it should NOT be present?!
+                if hasattr(conv, "writeNullOffset"):
+                    setattr(self, conv.name, None)  # Warn?
+                # elif not conv.isCount:
+                # 	# Warn?
+                # 	pass
+                if hasattr(conv, "DEFAULT"):
+                    # OptionalValue converters (e.g. VarIndex)
+                    setattr(self, conv.name, conv.DEFAULT)
+
+    def decompile(self, reader, font):
+        self.readFormat(reader)
+        table = {}
+        self.__rawTable = table  # for debugging
+        for conv in self.getConverters():
+            if conv.name == "SubTable":
+                conv = conv.getConverter(reader.tableTag, table["LookupType"])
+            if conv.name == "ExtSubTable":
+                conv = conv.getConverter(reader.tableTag, table["ExtensionLookupType"])
+            if conv.name == "FeatureParams":
+                conv = conv.getConverter(reader["FeatureTag"])
+            if conv.name == "SubStruct":
+                conv = conv.getConverter(reader.tableTag, table["MorphType"])
+            try:
+                if conv.repeat:
+                    if isinstance(conv.repeat, int):
+                        countValue = conv.repeat
+                    elif conv.repeat in table:
+                        countValue = table[conv.repeat]
+                    else:
+                        # conv.repeat is a propagated count
+                        countValue = reader[conv.repeat]
+                    countValue += conv.aux
+                    table[conv.name] = conv.readArray(reader, font, table, countValue)
+                else:
+                    if conv.aux and not eval(conv.aux, None, table):
+                        continue
+                    table[conv.name] = conv.read(reader, font, table)
+                    if conv.isPropagated:
+                        reader[conv.name] = table[conv.name]
+            except Exception as e:
+                name = conv.name
+                e.args = e.args + (name,)
+                raise
+
+        if hasattr(self, "postRead"):
+            self.postRead(table, font)
+        else:
+            self.__dict__.update(table)
+
+        del self.__rawTable  # succeeded, get rid of debugging info
+
+    def compile(self, writer, font):
+        self.ensureDecompiled()
+        # TODO Following hack to be removed by rewriting how FormatSwitching tables
+        # are handled.
+        # https://github.com/fonttools/fonttools/pull/2238#issuecomment-805192631
+        if hasattr(self, "preWrite"):
+            deleteFormat = not hasattr(self, "Format")
+            table = self.preWrite(font)
+            deleteFormat = deleteFormat and hasattr(self, "Format")
+        else:
+            deleteFormat = False
+            table = self.__dict__.copy()
+
+        # some count references may have been initialized in a custom preWrite; we set
+        # these in the writer's state beforehand (instead of sequentially) so they will
+        # be propagated to all nested subtables even if the count appears in the current
+        # table only *after* the offset to the subtable that it is counting.
+        for conv in self.getConverters():
+            if conv.isCount and conv.isPropagated:
+                value = table.get(conv.name)
+                if isinstance(value, CountReference):
+                    writer[conv.name] = value
+
+        if hasattr(self, "sortCoverageLast"):
+            writer.sortCoverageLast = 1
+
+        if hasattr(self, "DontShare"):
+            writer.DontShare = True
+
+        if hasattr(self.__class__, "LookupType"):
+            writer["LookupType"].setValue(self.__class__.LookupType)
+
+        self.writeFormat(writer)
+        for conv in self.getConverters():
+            value = table.get(
+                conv.name
+            )  # TODO Handle defaults instead of defaulting to None!
+            if conv.repeat:
+                if value is None:
+                    value = []
+                countValue = len(value) - conv.aux
+                if isinstance(conv.repeat, int):
+                    assert len(value) == conv.repeat, "expected %d values, got %d" % (
+                        conv.repeat,
+                        len(value),
+                    )
+                elif conv.repeat in table:
+                    CountReference(table, conv.repeat, value=countValue)
+                else:
+                    # conv.repeat is a propagated count
+                    writer[conv.repeat].setValue(countValue)
+                try:
+                    conv.writeArray(writer, font, table, value)
+                except Exception as e:
+                    e.args = e.args + (conv.name + "[]",)
+                    raise
+            elif conv.isCount:
+                # Special-case Count values.
+                # Assumption: a Count field will *always* precede
+                # the actual array(s).
+                # We need a default value, as it may be set later by a nested
+                # table. We will later store it here.
+                # We add a reference: by the time the data is assembled
+                # the Count value will be filled in.
+                # We ignore the current count value since it will be recomputed,
+                # unless it's a CountReference that was already initialized in a custom preWrite.
+                if isinstance(value, CountReference):
+                    ref = value
+                    ref.size = conv.staticSize
+                    writer.writeData(ref)
+                    table[conv.name] = ref.getValue()
+                else:
+                    ref = writer.writeCountReference(table, conv.name, conv.staticSize)
+                    table[conv.name] = None
+                if conv.isPropagated:
+                    writer[conv.name] = ref
+            elif conv.isLookupType:
+                # We make sure that subtables have the same lookup type,
+                # and that the type is the same as the one set on the
+                # Lookup object, if any is set.
+                if conv.name not in table:
+                    table[conv.name] = None
+                ref = writer.writeCountReference(
+                    table, conv.name, conv.staticSize, table[conv.name]
+                )
+                writer["LookupType"] = ref
+            else:
+                if conv.aux and not eval(conv.aux, None, table):
+                    continue
+                try:
+                    conv.write(writer, font, table, value)
+                except Exception as e:
+                    name = value.__class__.__name__ if value is not None else conv.name
+                    e.args = e.args + (name,)
+                    raise
+                if conv.isPropagated:
+                    writer[conv.name] = value
+
+        if deleteFormat:
+            del self.Format
+
+    def readFormat(self, reader):
+        pass
+
+    def writeFormat(self, writer):
+        pass
+
+    def toXML(self, xmlWriter, font, attrs=None, name=None):
+        tableName = name if name else self.__class__.__name__
+        if attrs is None:
+            attrs = []
+        if hasattr(self, "Format"):
+            attrs = attrs + [("Format", self.Format)]
+        xmlWriter.begintag(tableName, attrs)
+        xmlWriter.newline()
+        self.toXML2(xmlWriter, font)
+        xmlWriter.endtag(tableName)
+        xmlWriter.newline()
+
+    def toXML2(self, xmlWriter, font):
+        # Simpler variant of toXML, *only* for the top level tables (like GPOS, GSUB).
+        # This is because in TTX our parent writes our main tag, and in otBase.py we
+        # do it ourselves. I think I'm getting schizophrenic...
+        for conv in self.getConverters():
+            if conv.repeat:
+                value = getattr(self, conv.name, [])
+                for i, item in enumerate(value):
+                    conv.xmlWrite(xmlWriter, font, item, conv.name, [("index", i)])
+            else:
+                if conv.aux and not eval(conv.aux, None, vars(self)):
+                    continue
+                value = getattr(
+                    self, conv.name, None
+                )  # TODO Handle defaults instead of defaulting to None!
+                conv.xmlWrite(xmlWriter, font, value, conv.name, [])
+
+    def fromXML(self, name, attrs, content, font):
+        try:
+            conv = self.getConverterByName(name)
+        except KeyError:
+            raise  # XXX on KeyError, raise nice error
+        value = conv.xmlRead(attrs, content, font)
+        # Some manually-written tables have a conv.repeat of ""
+        # to represent lists. Hence comparing to None here to
+        # allow those lists to be read correctly from XML.
+        if conv.repeat is not None:
+            seq = getattr(self, conv.name, None)
+            if seq is None:
+                seq = []
+                setattr(self, conv.name, seq)
+            seq.append(value)
+        else:
+            setattr(self, conv.name, value)
+
+    def __ne__(self, other):
+        result = self.__eq__(other)
+        return result if result is NotImplemented else not result
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            return NotImplemented
+
+        self.ensureDecompiled()
+        other.ensureDecompiled()
+
+        return self.__dict__ == other.__dict__
+
+    class SubTableEntry(NamedTuple):
+        """See BaseTable.iterSubTables()"""
+
+        name: str
+        value: "BaseTable"
+        index: Optional[int] = None  # index into given array, None for single values
+
+    def iterSubTables(self) -> Iterator[SubTableEntry]:
+        """Yield (name, value, index) namedtuples for all subtables of current table.
+
+        A sub-table is an instance of BaseTable (or subclass thereof) that is a child
+        of self, the current parent table.
+        The tuples also contain the attribute name (str) of the of parent table to get
+        a subtable, and optionally, for lists of subtables (i.e. attributes associated
+        with a converter that has a 'repeat'), an index into the list containing the
+        given subtable value.
+        This method can be useful to traverse trees of otTables.
+        """
+        for conv in self.getConverters():
+            name = conv.name
+            value = getattr(self, name, None)
+            if value is None:
+                continue
+            if isinstance(value, BaseTable):
+                yield self.SubTableEntry(name, value)
+            elif isinstance(value, list):
+                yield from (
+                    self.SubTableEntry(name, v, index=i)
+                    for i, v in enumerate(value)
+                    if isinstance(v, BaseTable)
+                )
+
+    # instance (not @class)method for consistency with FormatSwitchingBaseTable
+    def getVariableAttrs(self):
+        return getVariableAttrs(self.__class__)
+
+
+class FormatSwitchingBaseTable(BaseTable):
+    """Minor specialization of BaseTable, for tables that have multiple
+    formats, eg. CoverageFormat1 vs. CoverageFormat2."""
+
+    @classmethod
+    def getRecordSize(cls, reader):
+        return NotImplemented
+
+    def getConverters(self):
+        try:
+            fmt = self.Format
+        except AttributeError:
+            # some FormatSwitchingBaseTables (e.g. Coverage) no longer have 'Format'
+            # attribute after fully decompiled, only gain one in preWrite before being
+            # recompiled. In the decompiled state, these hand-coded classes defined in
+            # otTables.py lose their format-specific nature and gain more high-level
+            # attributes that are not tied to converters.
+            return []
+        return self.converters.get(self.Format, [])
+
+    def getConverterByName(self, name):
+        return self.convertersByName[self.Format][name]
+
+    def readFormat(self, reader):
+        self.Format = reader.readUShort()
+
+    def writeFormat(self, writer):
+        writer.writeUShort(self.Format)
+
+    def toXML(self, xmlWriter, font, attrs=None, name=None):
+        BaseTable.toXML(self, xmlWriter, font, attrs, name)
+
+    def getVariableAttrs(self):
+        return getVariableAttrs(self.__class__, self.Format)
+
+
+class UInt8FormatSwitchingBaseTable(FormatSwitchingBaseTable):
+    def readFormat(self, reader):
+        self.Format = reader.readUInt8()
+
+    def writeFormat(self, writer):
+        writer.writeUInt8(self.Format)
+
+
+formatSwitchingBaseTables = {
+    "uint16": FormatSwitchingBaseTable,
+    "uint8": UInt8FormatSwitchingBaseTable,
+}
+
+
+def getFormatSwitchingBaseTableClass(formatType):
+    try:
+        return formatSwitchingBaseTables[formatType]
+    except KeyError:
+        raise TypeError(f"Unsupported format type: {formatType!r}")
+
+
+# memoize since these are parsed from otData.py, thus stay constant
+@lru_cache()
+def getVariableAttrs(cls: BaseTable, fmt: Optional[int] = None) -> Tuple[str]:
+    """Return sequence of variable table field names (can be empty).
+
+    Attributes are deemed "variable" when their otData.py's description contain
+    'VarIndexBase + {offset}', e.g. COLRv1 PaintVar* tables.
+    """
+    if not issubclass(cls, BaseTable):
+        raise TypeError(cls)
+    if issubclass(cls, FormatSwitchingBaseTable):
+        if fmt is None:
+            raise TypeError(f"'fmt' is required for format-switching {cls.__name__}")
+        converters = cls.convertersByName[fmt]
+    else:
+        converters = cls.convertersByName
+    # assume if no 'VarIndexBase' field is present, table has no variable fields
+    if "VarIndexBase" not in converters:
+        return ()
+    varAttrs = {}
+    for name, conv in converters.items():
+        offset = conv.getVarIndexOffset()
+        if offset is not None:
+            varAttrs[name] = offset
+    return tuple(sorted(varAttrs, key=varAttrs.__getitem__))
+
+
+#
+# Support for ValueRecords
+#
+# This data type is so different from all other OpenType data types that
+# it requires quite a bit of code for itself. It even has special support
+# in OTTableReader and OTTableWriter...
+#
+
+valueRecordFormat = [
+    # 	Mask	 Name		isDevice signed
+    (0x0001, "XPlacement", 0, 1),
+    (0x0002, "YPlacement", 0, 1),
+    (0x0004, "XAdvance", 0, 1),
+    (0x0008, "YAdvance", 0, 1),
+    (0x0010, "XPlaDevice", 1, 0),
+    (0x0020, "YPlaDevice", 1, 0),
+    (0x0040, "XAdvDevice", 1, 0),
+    (0x0080, "YAdvDevice", 1, 0),
+    # 	reserved:
+    (0x0100, "Reserved1", 0, 0),
+    (0x0200, "Reserved2", 0, 0),
+    (0x0400, "Reserved3", 0, 0),
+    (0x0800, "Reserved4", 0, 0),
+    (0x1000, "Reserved5", 0, 0),
+    (0x2000, "Reserved6", 0, 0),
+    (0x4000, "Reserved7", 0, 0),
+    (0x8000, "Reserved8", 0, 0),
+]
+
+
+def _buildDict():
+    d = {}
+    for mask, name, isDevice, signed in valueRecordFormat:
+        d[name] = mask, isDevice, signed
+    return d
+
+
+valueRecordFormatDict = _buildDict()
+
+
+class ValueRecordFactory(object):
+    """Given a format code, this object convert ValueRecords."""
+
+    def __init__(self, valueFormat):
+        format = []
+        for mask, name, isDevice, signed in valueRecordFormat:
+            if valueFormat & mask:
+                format.append((name, isDevice, signed))
+        self.format = format
+
+    def __len__(self):
+        return len(self.format)
+
+    def readValueRecord(self, reader, font):
+        format = self.format
+        if not format:
+            return None
+        valueRecord = ValueRecord()
+        for name, isDevice, signed in format:
+            if signed:
+                value = reader.readShort()
+            else:
+                value = reader.readUShort()
+            if isDevice:
+                if value:
+                    from . import otTables
+
+                    subReader = reader.getSubReader(value)
+                    value = getattr(otTables, name)()
+                    value.decompile(subReader, font)
+                else:
+                    value = None
+            setattr(valueRecord, name, value)
+        return valueRecord
+
+    def writeValueRecord(self, writer, font, valueRecord):
+        for name, isDevice, signed in self.format:
+            value = getattr(valueRecord, name, 0)
+            if isDevice:
+                if value:
+                    subWriter = writer.getSubWriter()
+                    writer.writeSubTable(subWriter, offsetSize=2)
+                    value.compile(subWriter, font)
+                else:
+                    writer.writeUShort(0)
+            elif signed:
+                writer.writeShort(value)
+            else:
+                writer.writeUShort(value)
+
+
+class ValueRecord(object):
+    # see ValueRecordFactory
+
+    def __init__(self, valueFormat=None, src=None):
+        if valueFormat is not None:
+            for mask, name, isDevice, signed in valueRecordFormat:
+                if valueFormat & mask:
+                    setattr(self, name, None if isDevice else 0)
+            if src is not None:
+                for key, val in src.__dict__.items():
+                    if not hasattr(self, key):
+                        continue
+                    setattr(self, key, val)
+        elif src is not None:
+            self.__dict__ = src.__dict__.copy()
+
+    def getFormat(self):
+        format = 0
+        for name in self.__dict__.keys():
+            format = format | valueRecordFormatDict[name][0]
+        return format
+
+    def getEffectiveFormat(self):
+        format = 0
+        for name, value in self.__dict__.items():
+            if value:
+                format = format | valueRecordFormatDict[name][0]
+        return format
+
+    def toXML(self, xmlWriter, font, valueName, attrs=None):
+        if attrs is None:
+            simpleItems = []
+        else:
+            simpleItems = list(attrs)
+        for mask, name, isDevice, format in valueRecordFormat[:4]:  # "simple" values
+            if hasattr(self, name):
+                simpleItems.append((name, getattr(self, name)))
+        deviceItems = []
+        for mask, name, isDevice, format in valueRecordFormat[4:8]:  # device records
+            if hasattr(self, name):
+                device = getattr(self, name)
+                if device is not None:
+                    deviceItems.append((name, device))
+        if deviceItems:
+            xmlWriter.begintag(valueName, simpleItems)
+            xmlWriter.newline()
+            for name, deviceRecord in deviceItems:
+                if deviceRecord is not None:
+                    deviceRecord.toXML(xmlWriter, font, name=name)
+            xmlWriter.endtag(valueName)
+            xmlWriter.newline()
+        else:
+            xmlWriter.simpletag(valueName, simpleItems)
+            xmlWriter.newline()
+
+    def fromXML(self, name, attrs, content, font):
+        from . import otTables
+
+        for k, v in attrs.items():
+            setattr(self, k, int(v))
+        for element in content:
+            if not isinstance(element, tuple):
+                continue
+            name, attrs, content = element
+            value = getattr(otTables, name)()
+            for elem2 in content:
+                if not isinstance(elem2, tuple):
+                    continue
+                name2, attrs2, content2 = elem2
+                value.fromXML(name2, attrs2, content2, font)
+            setattr(self, name, value)
+
+    def __ne__(self, other):
+        result = self.__eq__(other)
+        return result if result is NotImplemented else not result
+
+    def __eq__(self, other):
+        if type(self) != type(other):
+            return NotImplemented
+        return self.__dict__ == other.__dict__

external/alphageometry/.venv-ag/Lib/site-packages/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),
+}

external/alphageometry/.venv-ag/Lib/site-packages/fontTools/ttLib/tables/otTraverse.py

@@ -0,0 +1,163 @@
+"""Methods for traversing trees of otData-driven OpenType tables."""
+
+from collections import deque
+from typing import Callable, Deque, Iterable, List, Optional, Tuple
+from .otBase import BaseTable
+
+
+__all__ = [
+    "bfs_base_table",
+    "dfs_base_table",
+    "SubTablePath",
+]
+
+
+class SubTablePath(Tuple[BaseTable.SubTableEntry, ...]):
+    def __str__(self) -> str:
+        path_parts = []
+        for entry in self:
+            path_part = entry.name
+            if entry.index is not None:
+                path_part += f"[{entry.index}]"
+            path_parts.append(path_part)
+        return ".".join(path_parts)
+
+
+# Given f(current frontier, new entries) add new entries to frontier
+AddToFrontierFn = Callable[[Deque[SubTablePath], List[SubTablePath]], None]
+
+
+def dfs_base_table(
+    root: BaseTable,
+    root_accessor: Optional[str] = None,
+    skip_root: bool = False,
+    predicate: Optional[Callable[[SubTablePath], bool]] = None,
+    iter_subtables_fn: Optional[
+        Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]
+    ] = None,
+) -> Iterable[SubTablePath]:
+    """Depth-first search tree of BaseTables.
+
+    Args:
+        root (BaseTable): the root of the tree.
+        root_accessor (Optional[str]): attribute name for the root table, if any (mostly
+            useful for debugging).
+        skip_root (Optional[bool]): if True, the root itself is not visited, only its
+            children.
+        predicate (Optional[Callable[[SubTablePath], bool]]): function to filter out
+            paths. If True, the path is yielded and its subtables are added to the
+            queue. If False, the path is skipped and its subtables are not traversed.
+        iter_subtables_fn (Optional[Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]]):
+            function to iterate over subtables of a table. If None, the default
+            BaseTable.iterSubTables() is used.
+
+    Yields:
+        SubTablePath: tuples of BaseTable.SubTableEntry(name, table, index) namedtuples
+        for each of the nodes in the tree. The last entry in a path is the current
+        subtable, whereas preceding ones refer to its parent tables all the way up to
+        the root.
+    """
+    yield from _traverse_ot_data(
+        root,
+        root_accessor,
+        skip_root,
+        predicate,
+        lambda frontier, new: frontier.extendleft(reversed(new)),
+        iter_subtables_fn,
+    )
+
+
+def bfs_base_table(
+    root: BaseTable,
+    root_accessor: Optional[str] = None,
+    skip_root: bool = False,
+    predicate: Optional[Callable[[SubTablePath], bool]] = None,
+    iter_subtables_fn: Optional[
+        Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]
+    ] = None,
+) -> Iterable[SubTablePath]:
+    """Breadth-first search tree of BaseTables.
+
+    Args:
+        root
+            the root of the tree.
+        root_accessor (Optional[str]): attribute name for the root table, if any (mostly
+            useful for debugging).
+        skip_root (Optional[bool]): if True, the root itself is not visited, only its
+            children.
+        predicate (Optional[Callable[[SubTablePath], bool]]): function to filter out
+            paths. If True, the path is yielded and its subtables are added to the
+            queue. If False, the path is skipped and its subtables are not traversed.
+        iter_subtables_fn (Optional[Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]]):
+            function to iterate over subtables of a table. If None, the default
+            BaseTable.iterSubTables() is used.
+
+    Yields:
+        SubTablePath: tuples of BaseTable.SubTableEntry(name, table, index) namedtuples
+        for each of the nodes in the tree. The last entry in a path is the current
+        subtable, whereas preceding ones refer to its parent tables all the way up to
+        the root.
+    """
+    yield from _traverse_ot_data(
+        root,
+        root_accessor,
+        skip_root,
+        predicate,
+        lambda frontier, new: frontier.extend(new),
+        iter_subtables_fn,
+    )
+
+
+def _traverse_ot_data(
+    root: BaseTable,
+    root_accessor: Optional[str],
+    skip_root: bool,
+    predicate: Optional[Callable[[SubTablePath], bool]],
+    add_to_frontier_fn: AddToFrontierFn,
+    iter_subtables_fn: Optional[
+        Callable[[BaseTable], Iterable[BaseTable.SubTableEntry]]
+    ] = None,
+) -> Iterable[SubTablePath]:
+    # no visited because general otData cannot cycle (forward-offset only)
+    if root_accessor is None:
+        root_accessor = type(root).__name__
+
+    if predicate is None:
+
+        def predicate(path):
+            return True
+
+    if iter_subtables_fn is None:
+
+        def iter_subtables_fn(table):
+            return table.iterSubTables()
+
+    frontier: Deque[SubTablePath] = deque()
+
+    root_entry = BaseTable.SubTableEntry(root_accessor, root)
+    if not skip_root:
+        frontier.append((root_entry,))
+    else:
+        add_to_frontier_fn(
+            frontier,
+            [
+                (root_entry, subtable_entry)
+                for subtable_entry in iter_subtables_fn(root)
+            ],
+        )
+
+    while frontier:
+        # path is (value, attr_name) tuples. attr_name is attr of parent to get value
+        path = frontier.popleft()
+        current = path[-1].value
+
+        if not predicate(path):
+            continue
+
+        yield SubTablePath(path)
+
+        new_entries = [
+            path + (subtable_entry,) for subtable_entry in iter_subtables_fn(current)
+        ]
+
+        add_to_frontier_fn(frontier, new_entries)

external/alphageometry/.venv-ag/Lib/site-packages/jax/_src/scipy/special.py

@@ -0,0 +1,2574 @@
+# Copyright 2018 The JAX Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from functools import partial
+import operator
+from typing import cast, Any
+
+import numpy as np
+
+import jax.numpy as jnp
+from jax import jit
+from jax import jvp
+from jax import vmap
+from jax import lax
+
+from jax._src import core
+from jax._src import custom_derivatives
+from jax._src import dtypes
+from jax._src.lax.lax import _const as _lax_const
+from jax._src.numpy.util import promote_args_inexact, promote_dtypes_inexact
+from jax._src.ops import special as ops_special
+from jax._src.third_party.scipy.betaln import betaln as _betaln_impl
+from jax._src.typing import Array, ArrayLike
+
+
+def gammaln(x: ArrayLike) -> Array:
+  r"""Natural log of the absolute value of the gamma function.
+
+  JAX implementation of :obj:`scipy.special.gammaln`.
+
+  .. math::
+
+     \mathrm{gammaln}(x) = \log(|\Gamma(x)|)
+
+  Where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    x: arraylike, real valued.
+
+  Returns:
+    array containing the values of the log-gamma function
+
+  See Also:
+    - :func:`jax.scipy.special.gammaln`: the natural log of the gamma function
+    - :func:`jax.scipy.special.gammasgn`: the sign of the gamma function
+
+  Notes:
+    ``gammaln`` does not support complex-valued inputs.
+  """
+  x, = promote_args_inexact("gammaln", x)
+  return lax.lgamma(x)
+
+
+def gammasgn(x: ArrayLike) -> Array:
+  r"""Sign of the gamma function.
+
+  JAX implementation of :obj:`scipy.special.gammasgn`.
+
+  .. math::
+
+    \mathrm{gammasgn}(x) = \begin{cases}
+      +1 & \Gamma(x) > 0 \\
+      -1 & \Gamma(x) < 0
+    \end{cases}
+
+  Where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function.
+  Because :math:`\Gamma(x)` is never zero, no condition is required for this case.
+
+  Args:
+    x: arraylike, real valued.
+
+  Returns:
+    array containing the sign of the gamma function
+
+  See Also:
+    - :func:`jax.scipy.special.gamma`: the gamma function
+    - :func:`jax.scipy.special.gammaln`: the natural log of the gamma function
+  """
+  x, = promote_args_inexact("gammasgn", x)
+  floor_x = lax.floor(x)
+  return jnp.where((x > 0) | (x == floor_x) | (floor_x % 2 == 0), 1.0, -1.0)
+
+
+def gamma(x: ArrayLike) -> Array:
+  r"""The gamma function.
+
+  JAX implementation of :obj:`scipy.special.gamma`.
+
+  The gamma function is defined for :math:`\Re(z)>0` as
+
+  .. math::
+
+     \mathrm{gamma}(z) = \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}\mathrm{d}t
+
+  and is extended by analytic continuation to arbitrary complex values `z`.
+  For positive integers `n`, the gamma function is related to the
+  :func:`~jax.scipy.special.factorial` function via the following identity:
+
+  .. math::
+
+     \Gamma(n) = (n - 1)!
+
+  Args:
+    x: arraylike, real valued.
+
+  Returns:
+    array containing the values of the gamma function
+
+  See Also:
+    - :func:`jax.scipy.special.factorial`: the factorial function.
+    - :func:`jax.scipy.special.gammaln`: the natural log of the gamma function
+    - :func:`jax.scipy.special.gammasgn`: the sign of the gamma function
+
+  Notes:
+    Unlike the scipy version, JAX's ``gamma`` does not support complex-valued inputs.
+  """
+  x, = promote_args_inexact("gamma", x)
+  return gammasgn(x) * lax.exp(lax.lgamma(x))
+
+
+def betaln(a: ArrayLike, b: ArrayLike) -> Array:
+  r"""Natural log of the absolute value of the beta function
+
+  JAX implementation of :obj:`scipy.special.betaln`.
+
+  .. math::
+
+     \mathrm{betaln}(a, b) = \log B(a, b)
+
+  where :math:`B` is the :func:`~jax.scipy.special.beta` function.
+
+  Args:
+    a: arraylike, real-valued.  Parameter *a* of the beta distribution.
+    b: arraylike, real-valued.  Parameter *b* of the beta distribution.
+
+  Returns:
+    array containing the values of the log-beta function
+
+  See Also:
+    :func:`jax.scipy.special.beta`
+  """
+  a, b = promote_args_inexact("betaln", a, b)
+  return _betaln_impl(a, b)
+
+
+def factorial(n: ArrayLike, exact: bool = False) -> Array:
+  r"""Factorial function
+
+  JAX implementation of :obj:`scipy.special.factorial`
+
+  .. math::
+
+     \mathrm{factorial}(n) = n! = \prod_{k=1}^n k
+
+  Args:
+    n: arraylike, values for which factorial will be computed elementwise
+    exact: bool, only ``exact=False`` is supported.
+
+  Returns:
+    array containing values of the factorial.
+
+  Notes:
+    This computes the float-valued factorial via the :func:`~jax.scipy.special.gamma`
+    function. JAX does not support exact factorials, because it is not particularly
+    useful: above ``n=20``, the exact result cannot be represented by 64-bit integers,
+    which are the largest integers available to JAX.
+
+  See Also:
+    :func:`jax.scipy.special.gamma`
+  """
+  if exact:
+    raise NotImplementedError("factorial with exact=True")
+  n, = promote_args_inexact("factorial", n)
+  return jnp.where(n < 0, 0, lax.exp(lax.lgamma(n + 1)))
+
+
+def beta(x: ArrayLike, y: ArrayLike) -> Array:
+  r"""The beta function
+
+  JAX implementation of :obj:`scipy.special.beta`.
+
+  .. math::
+
+     \mathrm{beta}(a, b) = B(a, b) = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a + b)}
+
+  where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    a: arraylike, real-valued. Parameter *a* of the beta distribution.
+    b: arraylike, real-valued. Parameter *b* of the beta distribution.
+
+  Returns:
+    array containing the values of the beta function.
+
+  See Also:
+    - :func:`jax.scipy.special.gamma`
+    - :func:`jax.scipy.special.betaln`
+  """
+  x, y = promote_args_inexact("beta", x, y)
+  sign = gammasgn(x) * gammasgn(y) * gammasgn(x + y)
+  return sign * lax.exp(betaln(x, y))
+
+
+def betainc(a: ArrayLike, b: ArrayLike, x: ArrayLike) -> Array:
+  r"""The regularized incomplete beta function.
+
+  JAX implementation of :obj:`scipy.special.betainc`.
+
+  .. math::
+
+     \mathrm{betainc}(a, b, x) = B(a, b)\int_0^x t^{a-1}(1-t^{b-1})\mathrm{d}t
+
+  where :math:`B(a, b)` is the :func:`~jax.scipy.special.beta` function.
+
+  Args:
+    a: arraylike, real-valued. Parameter *a* of the beta distribution.
+    b: arraylike, real-valued. Parameter *b* of the beta distribution.
+    x: arraylike, real-valued. Upper limit of the integration.
+
+  Returns:
+    array containing values of the betainc function
+
+  See Also:
+    - :func:`jax.scipy.special.beta`
+    - :func:`jax.scipy.special.betaln`
+  """
+  a, b, x = promote_args_inexact("betainc", a, b, x)
+  return lax.betainc(a, b, x)
+
+
+def digamma(x: ArrayLike) -> Array:
+  r"""The digamma function
+
+  JAX implementation of :obj:`scipy.special.digamma`.
+
+  .. math::
+
+     \mathrm{digamma}(z) = \psi(z) = \frac{\mathrm{d}}{\mathrm{d}z}\log \Gamma(z)
+
+  where :math:`\Gamma(z)` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing values of the digamma function.
+
+  Notes:
+    The JAX version of `digamma` accepts real-valued inputs.
+
+  See also:
+    - :func:`jax.scipy.special.gamma`
+    - :func:`jax.scipy.special.polygamma`
+  """
+  x, = promote_args_inexact("digamma", x)
+  return lax.digamma(x)
+
+
+def gammainc(a: ArrayLike, x: ArrayLike) -> Array:
+  r"""The regularized lower incomplete gamma function.
+
+  JAX implementation of :obj:`scipy.special.gammainc`.
+
+  .. math::
+
+     \mathrm{gammainc}(x; a) = \frac{1}{\Gamma(a)}\int_0^x t^{a-1}e^{-t}\mathrm{d}t
+
+  where :math:`\Gamma(a)` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    a: arraylike, real-valued. Positive shape parameter of the gamma distribution.
+    x: arraylike, real-valued. Non-negative upper limit of integration
+
+  Returns:
+    array containing values of the gammainc function.
+
+  See Also:
+    - :func:`jax.scipy.special.gamma`
+    - :func:`jax.scipy.special.gammaincc`
+  """
+  a, x = promote_args_inexact("gammainc", a, x)
+  return lax.igamma(a, x)
+
+
+def gammaincc(a: ArrayLike, x: ArrayLike) -> Array:
+  r"""The regularized upper incomplete gamma function.
+
+  JAX implementation of :obj:`scipy.special.gammaincc`.
+
+  .. math::
+
+     \mathrm{gammaincc}(x; a) = \frac{1}{\Gamma(a)}\int_x^\infty t^{a-1}e^{-t}\mathrm{d}t
+
+  where :math:`\Gamma(a)` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    a: arraylike, real-valued. Positive shape parameter of the gamma distribution.
+    x: arraylike, real-valued. Non-negative lower limit of integration
+
+  Returns:
+    array containing values of the gammaincc function.
+
+  See Also:
+    - :func:`jax.scipy.special.gamma`
+    - :func:`jax.scipy.special.gammainc`
+  """
+  a, x = promote_args_inexact("gammaincc", a, x)
+  return lax.igammac(a, x)
+
+
+def erf(x: ArrayLike) -> Array:
+  r"""The error function
+
+  JAX implementation of :obj:`scipy.special.erf`.
+
+  .. math::
+
+     \mathrm{erf}(x) = \frac{2}{\sqrt\pi} \int_{0}^x e^{-t^2} \mathrm{d}t
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing values of the error function.
+
+  Notes:
+     The JAX version only supports real-valued inputs.
+
+  See also:
+    - :func:`jax.scipy.special.erfc`
+    - :func:`jax.scipy.special.erfinv`
+  """
+  x, = promote_args_inexact("erf", x)
+  return lax.erf(x)
+
+
+def erfc(x: ArrayLike) -> Array:
+  r"""The complement of the error function
+
+  JAX implementation of :obj:`scipy.special.erfc`.
+
+  .. math::
+
+     \mathrm{erfc}(x) = \frac{2}{\sqrt\pi} \int_{x}^\infty e^{-t^2} \mathrm{d}t
+
+  This is the complement of the error function :func:`~jax.scipy.special.erf`,
+  ``erfc(x) = 1 - erf(x)``.
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing values of the complement of the error function.
+
+  Notes:
+     The JAX version only supports real-valued inputs.
+
+  See also:
+    - :func:`jax.scipy.special.erf`
+    - :func:`jax.scipy.special.erfinv`
+  """
+  x, = promote_args_inexact("erfc", x)
+  return lax.erfc(x)
+
+
+def erfinv(x: ArrayLike) -> Array:
+  """The inverse of the error function
+
+  JAX implementation of :obj:`scipy.special.erfinv`.
+
+  Returns the inverse of :func:`~jax.scipy.special.erf`.
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing values of the inverse error function.
+
+  Notes:
+     The JAX version only supports real-valued inputs.
+
+  See also:
+    - :func:`jax.scipy.special.erf`
+    - :func:`jax.scipy.special.erfc`
+  """
+  x, = promote_args_inexact("erfinv", x)
+  return lax.erf_inv(x)
+
+
+@custom_derivatives.custom_jvp
+def logit(x: ArrayLike) -> Array:
+  r"""The logit function
+
+  JAX implementation of :obj:`scipy.special.logit`.
+
+  .. math::
+
+     \mathrm{logit}(p) = \log\frac{p}{1 - p}
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing values of the logit function.
+  """
+  x, = promote_args_inexact("logit", x)
+  return lax.log(lax.div(x, lax.sub(_lax_const(x, 1), x)))
+logit.defjvps(
+    lambda g, ans, x: lax.div(g, lax.mul(x, lax.sub(_lax_const(x, 1), x))))
+
+
+def expit(x: ArrayLike) -> Array:
+  r"""The logistic sigmoid (expit) function
+
+  JAX implementation of :obj:`scipy.special.expit`.
+
+  .. math::
+
+     \mathrm{expit}(x) = \frac{1}{1 + e^{-x}}
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing values of the expit function.
+  """
+  x, = promote_args_inexact("expit", x)
+  return lax.logistic(x)
+
+
+logsumexp = ops_special.logsumexp
+
+
+@custom_derivatives.custom_jvp
+def xlogy(x: ArrayLike, y: ArrayLike) -> Array:
+  """Compute x*log(y), returning 0 for x=0.
+
+  JAX implementation of :obj:`scipy.special.xlogy`.
+
+  This is defined to return zero when :math:`(x, y) = (0, 0)`, with a custom
+  derivative rule so that automatic differentiation is well-defined at this point.
+
+  Args:
+    x: arraylike, real-valued.
+    y: arraylike, real-valued.
+
+  Returns:
+    array containing xlogy values.
+
+  See also:
+    :func:`jax.scipy.special.xlog1py`
+  """
+  # Note: xlogy(0, 0) should return 0 according to the function documentation.
+  x, y = promote_args_inexact("xlogy", x, y)
+  x_ok = x != 0.
+  return jnp.where(x_ok, lax.mul(x, lax.log(y)), jnp.zeros_like(x))
+
+def _xlogy_jvp(primals, tangents):
+  (x, y) = primals
+  (x_dot, y_dot) = tangents
+  result = xlogy(x, y)
+  return result, (x_dot * lax.log(y) + y_dot * x / y).astype(result.dtype)
+xlogy.defjvp(_xlogy_jvp)
+
+
+@custom_derivatives.custom_jvp
+def xlog1py(x: ArrayLike, y: ArrayLike) -> Array:
+  """Compute x*log(1 + y), returning 0 for x=0.
+
+  JAX implementation of :obj:`scipy.special.xlog1py`.
+
+  This is defined to return 0 when :math:`(x, y) = (0, -1)`, with a custom
+  derivative rule so that automatic differentiation is well-defined at this point.
+
+  Args:
+    x: arraylike, real-valued.
+    y: arraylike, real-valued.
+
+  Returns:
+    array containing xlog1py values.
+
+  See also:
+    :func:`jax.scipy.special.xlogy`
+  """
+  # Note: xlog1py(0, -1) should return 0 according to the function documentation.
+  x, y = promote_args_inexact("xlog1py", x, y)
+  x_ok = x != 0.
+  return jnp.where(x_ok, lax.mul(x, lax.log1p(y)), jnp.zeros_like(x))
+
+def _xlog1py_jvp(primals, tangents):
+  (x, y) = primals
+  (x_dot, y_dot) = tangents
+  result = xlog1py(x, y)
+  return result, (x_dot * lax.log1p(y) + y_dot * x / (1 + y)).astype(result.dtype)
+xlog1py.defjvp(_xlog1py_jvp)
+
+@custom_derivatives.custom_jvp
+def _xlogx(x):
+  """Compute x log(x) with well-defined derivatives."""
+  return xlogy(x, x)
+
+def _xlogx_jvp(primals, tangents):
+  x, = primals
+  x_dot, = tangents
+  return  _xlogx(x), x_dot * (lax.log(x) + 1)
+_xlogx.defjvp(_xlogx_jvp)
+
+
+def entr(x: ArrayLike) -> Array:
+  r"""The entropy function
+
+  JAX implementation of :obj:`scipy.special.entr`.
+
+  .. math::
+
+     \mathrm{entr}(x) = \begin{cases}
+       -x\log(x) & x > 0 \\
+       0 & x = 0\\
+       -\infty & x > 0
+     \end{cases}
+
+  Args:
+    x: arraylike, real-valued.
+
+  Returns:
+    array containing entropy values.
+
+  See also:
+    - :func:`jax.scipy.special.kl_div`
+    - :func:`jax.scipy.special.rel_entr`
+  """
+  x, = promote_args_inexact("entr", x)
+  return lax.select(lax.lt(x, _lax_const(x, 0)),
+                    lax.full_like(x, -np.inf),
+                    lax.neg(_xlogx(x)))
+
+
+def multigammaln(a: ArrayLike, d: ArrayLike) -> Array:
+  r"""The natural log of the multivariate gamma function.
+
+  JAX implementation of :func:`scipy.special.multigammaln`.
+
+  .. math::
+
+     \mathrm{multigammaln}(a, d) = \log\Gamma_d(a)
+
+  where
+
+  .. math::
+
+     \Gamma_d(a) = \pi^{d(d-1)/4}\prod_{i=1}^d\Gamma(a-(i-1)/2)
+
+  and :math:`\Gamma(x)` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    a: arraylike, real-valued.
+    d: int, the dimension of the integration space.
+
+  Returns:
+    array containing values of the log-multigamma function.
+
+  See also:
+    - :func:`jax.scipy.special.gamma`
+  """
+  d = core.concrete_or_error(int, d, "d argument of multigammaln")
+  a, d_ = promote_args_inexact("multigammaln", a, d)
+
+  constant = lax.mul(lax.mul(lax.mul(_lax_const(a, 0.25), d_),
+                             lax.sub(d_, _lax_const(a, 1))),
+                     lax.log(_lax_const(a, np.pi)))
+  b = lax.div(jnp.arange(d, dtype=d_.dtype), _lax_const(a, 2))
+  res = jnp.sum(gammaln(jnp.expand_dims(a, axis=-1) -
+                        jnp.expand_dims(b, axis=tuple(range(a.ndim)))),
+                axis=-1)
+  return res + constant
+
+
+def kl_div(
+    p: ArrayLike,
+    q: ArrayLike,
+) -> Array:
+  r"""The Kullback-Leibler divergence.
+
+  JAX implementation of :obj:`scipy.special.kl_div`.
+
+  .. math::
+
+     \mathrm{kl\_div}(p, q) = \begin{cases}
+       p\log(p/q)-p+q & p>0,q>0\\
+       q & p=0,q\ge 0\\
+       \infty & \mathrm{otherwise}
+    \end{cases}
+
+  Args:
+    p: arraylike, real-valued.
+    q: arraylike, real-valued.
+
+  Returns:
+    array of KL-divergence values
+
+  See also:
+    - :func:`jax.scipy.special.entr`
+    - :func:`jax.scipy.special.rel_entr`
+  """
+  p, q = promote_args_inexact("kl_div", p, q)
+  zero = _lax_const(p, 0.0)
+  both_gt_zero_mask = lax.bitwise_and(lax.gt(p, zero), lax.gt(q, zero))
+  one_zero_mask = lax.bitwise_and(lax.eq(p, zero), lax.ge(q, zero))
+
+  safe_p = jnp.where(both_gt_zero_mask, p, 1)
+  safe_q = jnp.where(both_gt_zero_mask, q, 1)
+
+  log_val = lax.sub(
+      lax.add(
+          lax.sub(_xlogx(safe_p), xlogy(safe_p, safe_q)),
+          safe_q,
+      ),
+      safe_p,
+  )
+  result = jnp.where(
+      both_gt_zero_mask, log_val, jnp.where(one_zero_mask, q, np.inf)
+  )
+  return result
+
+
+def rel_entr(
+    p: ArrayLike,
+    q: ArrayLike,
+) -> Array:
+  r"""The relative entropy function.
+
+  JAX implementation of :obj:`scipy.special.rel_entr`.
+
+  .. math::
+
+     \mathrm{rel\_entr}(p, q) = \begin{cases}
+       p\log(p/q) & p>0,q>0\\
+       0 & p=0,q\ge 0\\
+       \infty & \mathrm{otherwise}
+    \end{cases}
+
+  Args:
+    p: arraylike, real-valued.
+    q: arraylike, real-valued.
+
+  Returns:
+    array of relative entropy values.
+
+  See also:
+    - :func:`jax.scipy.special.entr`
+    - :func:`jax.scipy.special.kl_div`
+  """
+  p, q = promote_args_inexact("rel_entr", p, q)
+  zero = _lax_const(p, 0.0)
+  both_gt_zero_mask = lax.bitwise_and(lax.gt(p, zero), lax.gt(q, zero))
+  one_zero_mask = lax.bitwise_and(lax.eq(p, zero), lax.ge(q, zero))
+
+  safe_p = jnp.where(both_gt_zero_mask, p, 1)
+  safe_q = jnp.where(both_gt_zero_mask, q, 1)
+  log_val = lax.sub(_xlogx(safe_p), xlogy(safe_p, safe_q))
+  result = jnp.where(
+      both_gt_zero_mask, log_val, jnp.where(one_zero_mask, zero, jnp.inf)
+  )
+  return result
+
+# coefs of (2k)! / B_{2k} where B are bernoulli numbers
+# those numbers are obtained using https://www.wolframalpha.com
+_BERNOULLI_COEFS = [
+    12,
+    -720,
+    30240,
+    -1209600,
+    47900160,
+    -1307674368000 / 691,
+    74724249600,
+    -10670622842880000 / 3617,
+    5109094217170944000 / 43867,
+    -802857662698291200000 / 174611,
+    14101100039391805440000 / 77683,
+    -1693824136731743669452800000 / 236364091,
+    186134520519971831808000000 / 657931,
+    -37893265687455865519472640000000 / 3392780147,
+    759790291646040068357842010112000000 / 1723168255201,
+    -134196726836183700385281186201600000000 / 7709321041217,
+]
+
+
+@custom_derivatives.custom_jvp
+def zeta(x: ArrayLike, q: ArrayLike | None = None) -> Array:
+  r"""The Hurwitz zeta function.
+
+  JAX implementation of :func:`scipy.special.zeta`. JAX does not implement
+  the Riemann zeta function (i.e. ``q = None``).
+
+  .. math::
+
+     \zeta(x, q) = \sum_{n=0}^\infty \frac{1}{(n + q)^x}
+
+  Args:
+    x: arraylike, real-valued
+    q: arraylike, real-valued
+
+  Returns:
+    array of zeta function values
+  """
+  if q is None:
+    raise NotImplementedError(
+      "Riemann zeta function not implemented; pass q != None to compute the Hurwitz Zeta function.")
+  x, q = promote_args_inexact("zeta", x, q)
+  return lax.zeta(x, q)
+
+
+# There is no general closed-form derivative for the zeta function, so we compute
+# derivatives via a series expansion
+def _zeta_series_expansion(x: ArrayLike, q: ArrayLike | None = None) -> Array:
+  if q is None:
+    raise NotImplementedError(
+      "Riemann zeta function not implemented; pass q != None to compute the Hurwitz Zeta function.")
+  # Reference: Johansson, Fredrik.
+  # "Rigorous high-precision computation of the Hurwitz zeta function and its derivatives."
+  # Numerical Algorithms 69.2 (2015): 253-270.
+  # https://arxiv.org/abs/1309.2877 - formula (5)
+  # here we keep the same notation as in reference
+  s, a = promote_args_inexact("zeta", x, q)
+  dtype = lax.dtype(a).type
+  s_, a_ = jnp.expand_dims(s, -1), jnp.expand_dims(a, -1)
+  # precision ~ N, M
+  N = M = dtype(8) if lax.dtype(a) == jnp.float32 else dtype(16)
+  assert M <= len(_BERNOULLI_COEFS)
+  k = jnp.expand_dims(np.arange(N, dtype=N.dtype), tuple(range(a.ndim)))
+  S = jnp.sum((a_ + k) ** -s_, -1)
+  I = lax.div((a + N) ** (dtype(1) - s), s - dtype(1))
+  T0 = (a + N) ** -s
+  m = jnp.expand_dims(np.arange(2 * M, dtype=M.dtype), tuple(range(s.ndim)))
+  s_over_a = (s_ + m) / (a_ + N)
+  T1 = jnp.cumprod(s_over_a, -1)[..., ::2]
+  T1 = jnp.clip(T1, max=jnp.finfo(dtype).max)
+  coefs = np.expand_dims(np.array(_BERNOULLI_COEFS[:T1.shape[-1]], dtype=dtype),
+                         tuple(range(a.ndim)))
+  T1 = T1 / coefs
+  T = T0 * (dtype(0.5) + T1.sum(-1))
+  return S + I + T
+
+zeta.defjvp(partial(jvp, _zeta_series_expansion))
+
+
+def polygamma(n: ArrayLike, x: ArrayLike) -> Array:
+  r"""The polygamma function.
+
+  JAX implementation of :func:`scipy.special.polygamma`.
+
+  .. math::
+
+     \mathrm{polygamma}(n, x) = \psi^{(n)}(x) = \frac{\mathrm{d}^n}{\mathrm{d}x^n}\log \Gamma(x)
+
+  where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    n: arraylike, integer-valued. The order of the derivative.
+    x: arraylike, real-valued. The value at which to evaluate the function.
+
+  Returns:
+    array
+
+  See also:
+    - :func:`jax.scipy.special.gamma`
+    - :func:`jax.scipy.special.digamma`
+  """
+  assert jnp.issubdtype(lax.dtype(n), jnp.integer)
+  n_arr, x_arr = promote_args_inexact("polygamma", n, x)
+  return lax.polygamma(n_arr, x_arr)
+
+
+# Normal distributions
+
+# Functions "ndtr" and "ndtri" are derived from calculations made in:
+# https://root.cern.ch/doc/v608/SpecFuncCephesInv_8cxx_source.html
+# The "spence" function is also based on the Cephes library with
+# the corresponding spence.c file located in the tarball:
+# https://netlib.org/cephes/misc.tgz
+# In the following email exchange, the author gives his consent to redistribute
+# derived works under an Apache 2.0 license.
+#
+# From: Stephen Moshier <steve@moshier.net>
+# Date: Sat, Jun 9, 2018 at 2:36 PM
+# Subject: Re: Licensing cephes under Apache (BSD-like) license.
+# To: rif <rif@google.com>
+#
+#
+#
+# Hello Rif,
+#
+# Yes, Google may distribute Cephes files under the Apache 2 license.
+#
+# If clarification is needed, I do not favor BSD over other free licenses.
+# I would agree that Apache 2 seems to cover the concern you mentioned
+# about sublicensees.
+#
+# Best wishes for good luck with your projects!
+# Steve Moshier
+#
+#
+#
+# On Thu, 31 May 2018, rif wrote:
+#
+# > Hello Steve.
+# > My name is Rif. I work on machine learning software at Google.
+# >
+# > Your cephes software continues to be incredibly useful and widely used. I
+# > was wondering whether it would be permissible for us to use the Cephes code
+# > under the Apache 2.0 license, which is extremely similar in permissions to
+# > the BSD license (Wikipedia comparisons). This would be quite helpful to us
+# > in terms of avoiding multiple licenses on software.
+# >
+# > I'm sorry to bother you with this (I can imagine you're sick of hearing
+# > about this by now), but I want to be absolutely clear we're on the level and
+# > not misusing your important software. In former conversation with Eugene
+# > Brevdo (ebrevdo@google.com), you wrote "If your licensing is similar to BSD,
+# > the formal way that has been handled is simply to add a statement to the
+# > effect that you are incorporating the Cephes software by permission of the
+# > author." I wanted to confirm that (a) we could use the Apache license, (b)
+# > that we don't need to (and probably you don't want to) keep getting
+# > contacted about individual uses, because your intent is generally to allow
+# > this software to be reused under "BSD-like" license, and (c) you're OK
+# > letting incorporators decide whether a license is sufficiently BSD-like?
+# >
+# > Best,
+# >
+# > rif
+# >
+# >
+# >
+
+# log_ndtr uses different functions over the ranges
+# (-infty, lower](lower, upper](upper, infty)
+# Lower bound values were chosen by examining where the support of ndtr
+# appears to be zero, relative to scipy's (which is always 64bit). They were
+# then made more conservative just to be safe. (Conservative means use the
+# expansion more than we probably need to.)
+_LOGNDTR_FLOAT64_LOWER = np.array(-20, np.float64)
+_LOGNDTR_FLOAT32_LOWER = np.array(-10, np.float32)
+
+# Upper bound values were chosen by examining for which values of 'x'
+# Log[cdf(x)] is 0, after which point we need to use the approximation
+# Log[cdf(x)] = Log[1 - cdf(-x)] approx -cdf(-x). We chose a value slightly
+# conservative, meaning we use the approximation earlier than needed.
+_LOGNDTR_FLOAT64_UPPER = np.array(8, np.float64)
+_LOGNDTR_FLOAT32_UPPER = np.array(5, np.float32)
+
+
+def ndtr(x: ArrayLike) -> Array:
+  r"""Normal distribution function.
+
+  JAX implementation of :obj:`scipy.special.ndtr`.
+
+  Returns the area under the Gaussian probability density function, integrated
+  from minus infinity to x:
+
+  .. math::
+    \begin{align}
+    \mathrm{ndtr}(x) =&
+      \ \frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t^2} dt \\
+    =&\ \frac{1}{2} (1 + \mathrm{erf}(\frac{x}{\sqrt{2}})) \\
+    =&\ \frac{1}{2} \mathrm{erfc}(\frac{x}{\sqrt{2}})
+    \end{align}
+
+  Args:
+    x: An array of type `float32`, `float64`.
+
+  Returns:
+    An array with `dtype=x.dtype`.
+
+  Raises:
+    TypeError: if `x` is not floating-type.
+  """
+  x = jnp.asarray(x)
+  dtype = lax.dtype(x)
+  if dtype not in (jnp.float32, jnp.float64):
+    raise TypeError(
+        "x.dtype={} is not supported, see docstring for supported types."
+        .format(dtype))
+  return _ndtr(x)
+
+
+def _ndtr(x: ArrayLike) -> Array:
+  """Implements ndtr core logic."""
+  dtype = lax.dtype(x).type
+  half_sqrt_2 = dtype(0.5) * np.sqrt(2., dtype=dtype)
+  w = x * half_sqrt_2
+  z = lax.abs(w)
+  y = lax.select(lax.lt(z, half_sqrt_2),
+                      dtype(1.) + lax.erf(w),
+                      lax.select(lax.gt(w, dtype(0.)),
+                                      dtype(2.) - lax.erfc(z),
+                                      lax.erfc(z)))
+  return dtype(0.5) * y
+
+
+def ndtri(p: ArrayLike) -> Array:
+  r"""The inverse of the CDF of the Normal distribution function.
+
+  JAX implementation of :obj:`scipy.special.ndtri`.
+
+  Returns `x` such that the area under the PDF from :math:`-\infty` to `x` is equal
+  to `p`.
+
+  A piece-wise rational approximation is done for the function.
+  This is based on the implementation in netlib.
+
+  Args:
+    p: an array of type `float32`, `float64`.
+
+  Returns:
+    an array with `dtype=p.dtype`.
+
+  Raises:
+    TypeError: if `p` is not floating-type.
+  """
+  dtype = lax.dtype(p)
+  if dtype not in (jnp.float32, jnp.float64):
+    raise TypeError(
+        "x.dtype={} is not supported, see docstring for supported types."
+        .format(dtype))
+  return _ndtri(p)
+
+
+def _ndtri(p: ArrayLike) -> Array:
+  """Implements ndtri core logic."""
+
+  # Constants used in piece-wise rational approximations. Taken from the cephes
+  # library:
+  # https://root.cern.ch/doc/v608/SpecFuncCephesInv_8cxx_source.html
+  p0 = list(reversed([-5.99633501014107895267E1,
+                      9.80010754185999661536E1,
+                      -5.66762857469070293439E1,
+                      1.39312609387279679503E1,
+                      -1.23916583867381258016E0]))
+  q0 = list(reversed([1.0,
+                      1.95448858338141759834E0,
+                      4.67627912898881538453E0,
+                      8.63602421390890590575E1,
+                      -2.25462687854119370527E2,
+                      2.00260212380060660359E2,
+                      -8.20372256168333339912E1,
+                      1.59056225126211695515E1,
+                      -1.18331621121330003142E0]))
+  p1 = list(reversed([4.05544892305962419923E0,
+                      3.15251094599893866154E1,
+                      5.71628192246421288162E1,
+                      4.40805073893200834700E1,
+                      1.46849561928858024014E1,
+                      2.18663306850790267539E0,
+                      -1.40256079171354495875E-1,
+                      -3.50424626827848203418E-2,
+                      -8.57456785154685413611E-4]))
+  q1 = list(reversed([1.0,
+                      1.57799883256466749731E1,
+                      4.53907635128879210584E1,
+                      4.13172038254672030440E1,
+                      1.50425385692907503408E1,
+                      2.50464946208309415979E0,
+                      -1.42182922854787788574E-1,
+                      -3.80806407691578277194E-2,
+                      -9.33259480895457427372E-4]))
+  p2 = list(reversed([3.23774891776946035970E0,
+                      6.91522889068984211695E0,
+                      3.93881025292474443415E0,
+                      1.33303460815807542389E0,
+                      2.01485389549179081538E-1,
+                      1.23716634817820021358E-2,
+                      3.01581553508235416007E-4,
+                      2.65806974686737550832E-6,
+                      6.23974539184983293730E-9]))
+  q2 = list(reversed([1.0,
+                      6.02427039364742014255E0,
+                      3.67983563856160859403E0,
+                      1.37702099489081330271E0,
+                      2.16236993594496635890E-1,
+                      1.34204006088543189037E-2,
+                      3.28014464682127739104E-4,
+                      2.89247864745380683936E-6,
+                      6.79019408009981274425E-9]))
+
+  dtype = lax.dtype(p).type
+  shape = jnp.shape(p)
+
+  def _create_polynomial(var, coeffs):
+    """Compute n_th order polynomial via Horner's method."""
+    coeffs = np.array(coeffs, dtype)
+    if not coeffs.size:
+      return jnp.zeros_like(var)
+    return coeffs[0] + _create_polynomial(var, coeffs[1:]) * var
+
+
+  maybe_complement_p = jnp.where(p > dtype(-np.expm1(-2.)), dtype(1.) - p, p)
+  # Write in an arbitrary value in place of 0 for p since 0 will cause NaNs
+  # later on. The result from the computation when p == 0 is not used so any
+  # number that doesn't result in NaNs is fine.
+  sanitized_mcp = jnp.where(
+      maybe_complement_p == dtype(0.),
+      jnp.full(shape, dtype(0.5)),
+      maybe_complement_p)
+
+  # Compute x for p > exp(-2): x/sqrt(2pi) = w + w**3 P0(w**2)/Q0(w**2).
+  w = sanitized_mcp - dtype(0.5)
+  ww = lax.square(w)
+  x_for_big_p = w + w * ww * (_create_polynomial(ww, p0)
+                              / _create_polynomial(ww, q0))
+  x_for_big_p *= -dtype(np.sqrt(2. * np.pi))
+
+  # Compute x for p <= exp(-2): x = z - log(z)/z - (1/z) P(1/z) / Q(1/z),
+  # where z = sqrt(-2. * log(p)), and P/Q are chosen between two different
+  # arrays based on whether p < exp(-32).
+  z = lax.sqrt(dtype(-2.) * lax.log(sanitized_mcp))
+  first_term = z - lax.log(z) / z
+  second_term_small_p = (
+      _create_polynomial(dtype(1.) / z, p2) /
+      _create_polynomial(dtype(1.) / z, q2) / z)
+  second_term_otherwise = (
+      _create_polynomial(dtype(1.) / z, p1) /
+      _create_polynomial(dtype(1.) / z, q1) / z)
+  x_for_small_p = first_term - second_term_small_p
+  x_otherwise = first_term - second_term_otherwise
+
+  x = jnp.where(sanitized_mcp > dtype(np.exp(-2.)),
+                x_for_big_p,
+                jnp.where(z >= dtype(8.0), x_for_small_p, x_otherwise))
+
+  x = jnp.where(p > dtype(1. - np.exp(-2.)), x, -x)
+  infinity = jnp.full(shape, dtype(np.inf))
+  x_fix_boundaries = jnp.where(
+      p == dtype(0.0), -infinity, jnp.where(p == dtype(1.0), infinity, x))
+  return x_fix_boundaries
+
+
+@partial(custom_derivatives.custom_jvp, nondiff_argnums=(1,))
+def log_ndtr(x: ArrayLike, series_order: int = 3) -> Array:
+  r"""Log Normal distribution function.
+
+  JAX implementation of :obj:`scipy.special.log_ndtr`.
+
+  For details of the Normal distribution function see `ndtr`.
+
+  This function calculates :math:`\log(\mathrm{ndtr}(x))` by either calling
+  :math:`\log(\mathrm{ndtr}(x))` or using an asymptotic series. Specifically:
+
+  - For `x > upper_segment`, use the approximation `-ndtr(-x)` based on
+    :math:`\log(1-x) \approx -x, x \ll 1`.
+  - For `lower_segment < x <= upper_segment`, use the existing `ndtr` technique
+    and take a log.
+  - For `x <= lower_segment`, we use the series approximation of `erf` to compute
+    the log CDF directly.
+
+  The `lower_segment` is set based on the precision of the input:
+
+  .. math::
+    \begin{align}
+    \mathit{lower\_segment} =&
+      \ \begin{cases}
+        -20 &  x.\mathrm{dtype}=\mathit{float64} \\
+        -10 &  x.\mathrm{dtype}=\mathit{float32} \\
+        \end{cases} \\
+    \mathit{upper\_segment} =&
+      \ \begin{cases}
+        8&  x.\mathrm{dtype}=\mathit{float64} \\
+        5&  x.\mathrm{dtype}=\mathit{float32} \\
+        \end{cases}
+    \end{align}
+
+
+  When `x < lower_segment`, the `ndtr` asymptotic series approximation is:
+
+  .. math::
+    \begin{align}
+     \mathrm{ndtr}(x) =&\  \mathit{scale} * (1 + \mathit{sum}) + R_N \\
+     \mathit{scale}   =&\  \frac{e^{-0.5 x^2}}{-x \sqrt{2 \pi}} \\
+     \mathit{sum}     =&\  \sum_{n=1}^N {-1}^n (2n-1)!! / (x^2)^n \\
+     R_N     =&\  O(e^{-0.5 x^2} (2N+1)!! / |x|^{2N+3})
+    \end{align}
+
+  where :math:`(2n-1)!! = (2n-1) (2n-3) (2n-5) ...  (3) (1)` is a
+  `double-factorial
+  <https://en.wikipedia.org/wiki/Double_factorial>`_ operator.
+
+
+  Args:
+    x: an array of type `float32`, `float64`.
+    series_order: Positive Python integer. Maximum depth to
+      evaluate the asymptotic expansion. This is the `N` above.
+
+  Returns:
+    an array with `dtype=x.dtype`.
+
+  Raises:
+    TypeError: if `x.dtype` is not handled.
+    TypeError: if `series_order` is a not Python `integer.`
+    ValueError:  if `series_order` is not in `[0, 30]`.
+  """
+  if not isinstance(series_order, int):
+    raise TypeError("series_order must be a Python integer.")
+  if series_order < 0:
+    raise ValueError("series_order must be non-negative.")
+  if series_order > 30:
+    raise ValueError("series_order must be <= 30.")
+
+  x_arr = jnp.asarray(x)
+  dtype = lax.dtype(x_arr)
+
+  if dtype == jnp.float64:
+    lower_segment: np.ndarray = _LOGNDTR_FLOAT64_LOWER
+    upper_segment: np.ndarray = _LOGNDTR_FLOAT64_UPPER
+  elif dtype == jnp.float32:
+    lower_segment = _LOGNDTR_FLOAT32_LOWER
+    upper_segment = _LOGNDTR_FLOAT32_UPPER
+  else:
+    raise TypeError(f"x.dtype={np.dtype(dtype)} is not supported.")
+
+  # The basic idea here was ported from:
+  #   https://root.cern.ch/doc/v608/SpecFuncCephesInv_8cxx_source.html
+  # We copy the main idea, with a few changes
+  # * For x >> 1, and X ~ Normal(0, 1),
+  #     Log[P[X < x]] = Log[1 - P[X < -x]] approx -P[X < -x],
+  #     which extends the range of validity of this function.
+  # * We use one fixed series_order for all of 'x', rather than adaptive.
+  # * Our docstring properly reflects that this is an asymptotic series, not a
+  #   Taylor series. We also provided a correct bound on the remainder.
+  # * We need to use the max/min in the _log_ndtr_lower arg to avoid nan when
+  #   x=0. This happens even though the branch is unchosen because when x=0
+  #   the gradient of a select involves the calculation 1*dy+0*(-inf)=nan
+  #   regardless of whether dy is finite. Note that the minimum is a NOP if
+  #   the branch is chosen.
+  return jnp.where(
+      lax.gt(x_arr, upper_segment),
+      -_ndtr(-x_arr),  # log(1-x) ~= -x, x << 1
+      jnp.where(lax.gt(x_arr, lower_segment),
+                       lax.log(_ndtr(lax.max(x_arr, lower_segment))),
+                       _log_ndtr_lower(lax.min(x_arr, lower_segment),
+                                       series_order)))
+
+def _log_ndtr_jvp(series_order, primals, tangents):
+  (x,), (t,) = primals, tangents
+  ans = log_ndtr(x, series_order=series_order)
+  t_out = lax.mul(t, lax.exp(lax.sub(_norm_logpdf(x), ans)))
+  return ans, t_out
+log_ndtr.defjvp(_log_ndtr_jvp)
+
+def _log_ndtr_lower(x, series_order):
+  """Asymptotic expansion version of `Log[cdf(x)]`, appropriate for `x<<-1`."""
+  dtype = lax.dtype(x).type
+  x_2 = lax.square(x)
+  # Log of the term multiplying (1 + sum)
+  log_scale = -dtype(0.5) * x_2 - lax.log(-x) - dtype(0.5 * np.log(2. * np.pi))
+  return log_scale + lax.log(_log_ndtr_asymptotic_series(x, series_order))
+
+
+def _log_ndtr_asymptotic_series(x, series_order):
+  """Calculates the asymptotic series used in log_ndtr."""
+  dtype = lax.dtype(x).type
+  if series_order <= 0:
+    return np.array(1, dtype)
+  x_2 = lax.square(x)
+  even_sum = jnp.zeros_like(x)
+  odd_sum = jnp.zeros_like(x)
+  x_2n = x_2  # Start with x^{2*1} = x^{2*n} with n = 1.
+  for n in range(1, series_order + 1):
+    y = np.array(_double_factorial(2 * n - 1), dtype) / x_2n
+    if n % 2:
+      odd_sum += y
+    else:
+      even_sum += y
+    x_2n *= x_2
+  return dtype(1.) + even_sum - odd_sum
+
+
+def _double_factorial(n: int) -> np.ndarray:
+  """The double factorial function for small Python integer `n`."""
+  return np.prod(np.arange(n, 1, -2))
+
+
+_norm_logpdf_constant = np.log(np.sqrt(2 * np.pi))
+
+def _norm_logpdf(x):
+  neg_half = _lax_const(x, -0.5)
+  log_normalizer = _lax_const(x, _norm_logpdf_constant)
+  return lax.sub(lax.mul(neg_half, lax.square(x)), log_normalizer)
+
+
+def i0e(x: ArrayLike) -> Array:
+  r"""Exponentially scaled modified bessel function of zeroth order.
+
+  JAX implementation of :obj:`scipy.special.i0e`.
+
+  .. math::
+
+     \mathrm{i0e}(x) = e^{-|x|} I_0(x)
+
+  where :math:`I_0(x)` is the modified Bessel function :func:`~jax.scipy.special.i0`.
+
+  Args:
+    x: array, real-valued
+
+  Returns:
+    array of bessel function values.
+
+  See also:
+    - :func:`jax.scipy.special.i0`
+    - :func:`jax.scipy.special.i1`
+    - :func:`jax.scipy.special.i1e`
+  """
+  x, = promote_args_inexact("i0e", x)
+  return lax.bessel_i0e(x)
+
+
+def i0(x: ArrayLike) -> Array:
+  r"""Modified bessel function of zeroth order.
+
+  JAX implementation of :obj:`scipy.special.i0`.
+
+  .. math::
+
+     \mathrm{i0}(x) = I_0(x) = \sum_{k=0}^\infty \frac{(x^2/4)^k}{(k!)^2}
+
+  Args:
+    x: array, real-valued
+
+  Returns:
+    array of bessel function values.
+
+  See also:
+    - :func:`jax.scipy.special.i0e`
+    - :func:`jax.scipy.special.i1`
+    - :func:`jax.scipy.special.i1e`
+  """
+  x, = promote_args_inexact("i0", x)
+  return lax.mul(lax.exp(lax.abs(x)), lax.bessel_i0e(x))
+
+
+def i1e(x: ArrayLike) -> Array:
+  r"""Exponentially scaled modified bessel function of first order.
+
+  JAX implementation of :obj:`scipy.special.i1e`.
+
+  .. math::
+
+     \mathrm{i1e}(x) = e^{-|x|} I_1(x)
+
+  where :math:`I_1(x)` is the modified Bessel function :func:`~jax.scipy.special.i1`.
+
+  Args:
+    x: array, real-valued
+
+  Returns:
+    array of bessel function values
+
+  See also:
+    - :func:`jax.scipy.special.i0`
+    - :func:`jax.scipy.special.i0e`
+    - :func:`jax.scipy.special.i1`
+  """
+  x, = promote_args_inexact("i1e", x)
+  return lax.bessel_i1e(x)
+
+
+def i1(x: ArrayLike) -> Array:
+  r"""Modified bessel function of first order.
+
+  JAX implementation of :obj:`scipy.special.i1`.
+
+  .. math::
+
+     \mathrm{i1}(x) = I_1(x) = \frac{1}{2}x\sum_{k=0}^\infty\frac{(x^2/4)^k}{k!(k+1)!}
+
+  Args:
+    x: array, real-valued
+
+  Returns:
+    array of bessel function values
+
+  See also:
+    - :func:`jax.scipy.special.i0`
+    - :func:`jax.scipy.special.i0e`
+    - :func:`jax.scipy.special.i1e`
+  """
+  x, = promote_args_inexact("i1", x)
+  return lax.mul(lax.exp(lax.abs(x)), lax.bessel_i1e(x))
+
+def _bessel_jn_scan_body_fun(carry, k):
+  f0, f1, bs, z = carry
+  f = 2.0 * (k + 1.0) * f1 / z - f0
+
+  def true_fn_update_bs(u):
+    bs, f = u
+    return bs + 2.0 * f
+
+  def false_fn_update_bs(u):
+    bs, _ = u
+    return bs
+
+  bs = lax.cond(jnp.mod(k, 2) == 0, true_fn_update_bs,
+                false_fn_update_bs, operand=(bs, f))
+
+  f0 = f1
+  f1 = f
+  return (f0, f1, bs, z), f
+
+
+def _bessel_jn(z: ArrayLike, *, v: int, n_iter: int=50) -> Array:
+  f0 = _lax_const(z, 0.0)
+  f1 = _lax_const(z, 1E-16)
+  f = _lax_const(z, 0.0)
+  bs = _lax_const(z, 0.0)
+
+  (_, _, bs, _), j_vals = lax.scan(
+      f=_bessel_jn_scan_body_fun, init=(f0, f1, bs, z),
+      xs=lax.iota(lax.dtype(z), n_iter+1), reverse=True)
+
+  f = j_vals[0]  # Use the value at the last iteration.
+  j_vals = j_vals[:v+1]
+  j_vals = j_vals / (bs - f)
+
+  return j_vals
+
+
+@partial(jit, static_argnames=["v", "n_iter"])
+def bessel_jn(z: ArrayLike, *, v: int, n_iter: int=50) -> Array:
+  """Bessel function of the first kind of integer order and real argument.
+
+  Reference:
+  Shanjie Zhang and Jian-Ming Jin. Computation of special functions.
+  Wiley-Interscience, 1996.
+
+  Args:
+    z: The sampling point(s) at which the Bessel function of the first kind are
+      computed.
+    v: The order (int) of the Bessel function.
+    n_iter: The number of iterations required for updating the function
+      values. As a rule of thumb, `n_iter` is the smallest nonnegative integer
+      that satisfies the condition
+      `int(0.5 * log10(6.28 + n_iter) - n_iter *  log10(1.36 + abs(z) / n_iter)) > 20`.
+      Details in `BJNDD` (https://people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.f)
+
+  Returns:
+    An array of shape `(v+1, *z.shape)` containing the values of the Bessel
+    function of orders 0, 1, ..., v. The return type matches the type of `z`.
+
+  Raises:
+    TypeError if `v` is not integer.
+    ValueError if elements of array `z` are not float.
+  """
+  z = jnp.asarray(z)
+  z, = promote_dtypes_inexact(z)
+  z_dtype = lax.dtype(z)
+  if dtypes.issubdtype(z_dtype, complex):
+    raise ValueError("complex input not supported.")
+
+  v = core.concrete_or_error(operator.index, v, 'Argument v of bessel_jn.')
+  n_iter = core.concrete_or_error(int, n_iter, 'Argument n_iter of bessel_jn.')
+
+  bessel_jn_fun = partial(_bessel_jn, v=v, n_iter=n_iter)
+  for _ in range(z.ndim):
+    bessel_jn_fun = vmap(bessel_jn_fun)
+  return jnp.moveaxis(bessel_jn_fun(z), -1, 0)
+
+
+def _gen_recurrence_mask(
+    l_max: int, is_normalized: bool, dtype: Any
+) -> tuple[Array, Array]:
+  """Generates a mask for recurrence relation on the remaining entries.
+
+  The remaining entries are with respect to the diagonal and offdiagonal
+  entries.
+
+  Args:
+    l_max: see `gen_normalized_legendre`.
+    is_normalized: True if the recurrence mask is used by normalized associated
+      Legendre functions.
+
+  Returns:
+    Arrays representing the mask used by the recurrence relations.
+  """
+
+  # Computes all coefficients.
+  m_mat, l_mat = jnp.meshgrid(
+    jnp.arange(l_max + 1, dtype=dtype),
+    jnp.arange(l_max + 1, dtype=dtype),
+    indexing='ij')
+  if is_normalized:
+    c0 = l_mat * l_mat
+    c1 = m_mat * m_mat
+    c2 = 2.0 * l_mat
+    c3 = (l_mat - 1.0) * (l_mat - 1.0)
+    d0 = jnp.sqrt((4.0 * c0 - 1.0) / (c0 - c1))
+    d1 = jnp.sqrt(((c2 + 1.0) * (c3 - c1)) / ((c2 - 3.0) * (c0 - c1)))
+  else:
+    d0 = (2.0 * l_mat - 1.0) / (l_mat - m_mat)
+    d1 = (l_mat + m_mat - 1.0) / (l_mat - m_mat)
+
+  d0_mask_indices = jnp.triu_indices(l_max + 1, 1)
+  d1_mask_indices = jnp.triu_indices(l_max + 1, 2)
+  d_zeros = jnp.zeros((l_max + 1, l_max + 1), dtype=dtype)
+  d0_mask = d_zeros.at[d0_mask_indices].set(d0[d0_mask_indices])
+  d1_mask = d_zeros.at[d1_mask_indices].set(d1[d1_mask_indices])
+
+  # Creates a 3D mask that contains 1s on the diagonal plane and 0s elsewhere.
+  # i = jnp.arange(l_max + 1)[:, None, None]
+  # j = jnp.arange(l_max + 1)[None, :, None]
+  # k = jnp.arange(l_max + 1)[None, None, :]
+  i, j, k = jnp.ogrid[:l_max + 1, :l_max + 1, :l_max + 1]
+  mask = (i + j - k == 0).astype(dtype)
+
+  d0_mask_3d = jnp.einsum('jk,ijk->ijk', d0_mask, mask)
+  d1_mask_3d = jnp.einsum('jk,ijk->ijk', d1_mask, mask)
+
+  return (d0_mask_3d, d1_mask_3d)
+
+
+@partial(jit, static_argnums=(2))
+def _gen_derivatives(p: Array,
+                     x: Array,
+                     is_normalized: bool) -> Array:
+  """Generates derivatives of associated Legendre functions of the first kind.
+
+  Args:
+    p: The 3D array containing the values of associated Legendre functions; the
+      dimensions are in the sequence of order (m), degree (l), and evaluation
+      points.
+    x: A vector of type `float32` or `float64` containing the sampled points.
+    is_normalized: True if the associated Legendre functions are normalized.
+  Returns:
+    The 3D array representing the derivatives of associated Legendre functions
+    of the first kind.
+  """
+
+  num_m, num_l, num_x = p.shape
+
+  # p_{l-1}^m.
+  p_m_lm1 = jnp.pad(p, ((0, 0), (1, 0), (0, 0)))[:, :num_l, :]
+
+  # p_{l-1}^{m+2}.
+  p_mp2_lm1 = jnp.pad(p_m_lm1, ((0, 2), (0, 0), (0, 0)))[2:num_m + 2, :, :]
+
+  # p_{l-1}^{m-2}.
+  p_mm2_lm1 = jnp.pad(p_m_lm1, ((2, 0), (0, 0), (0, 0)))[:num_m, :, :]
+
+  # Derivative computation requires negative orders.
+  if is_normalized:
+    raise NotImplementedError(
+        'Negative orders for normalization is not implemented yet.')
+  else:
+    if num_l > 1:
+      l_vec = jnp.arange(1, num_l - 1, dtype=x.dtype)
+      p_p1 = p[1, 1:num_l - 1, :]
+      coeff = -1.0 / ((l_vec + 1) * l_vec)
+      update_p_p1 = jnp.einsum('i,ij->ij', coeff, p_p1)
+      p_mm2_lm1 = p_mm2_lm1.at[1, 2:num_l, :].set(update_p_p1)
+
+    if num_l > 2:
+      l_vec = jnp.arange(2, num_l - 1, dtype=x.dtype)
+      p_p2 = p[2, 2:num_l - 1, :]
+      coeff = 1.0 / ((l_vec + 2) * (l_vec + 1) * l_vec * (l_vec - 1))
+      update_p_p2 = jnp.einsum('i,ij->ij', coeff, p_p2)
+      p_mm2_lm1 = p_mm2_lm1.at[0, 3:num_l, :].set(update_p_p2)
+
+  m_mat, l_mat = jnp.meshgrid(
+    jnp.arange(num_m, dtype=x.dtype),
+    jnp.arange(num_l, dtype=x.dtype),
+    indexing='ij')
+
+  coeff_zeros = jnp.zeros((num_m, num_l), dtype=x.dtype)
+  upper_0_indices = jnp.triu_indices(num_m, 0, num_l)
+  zero_vec = jnp.zeros((num_l,), dtype=x.dtype)
+
+  a0 = -0.5 / (m_mat - 1.0)
+  a0_masked = coeff_zeros.at[upper_0_indices].set(a0[upper_0_indices])
+  a0_masked = a0_masked.at[1, :].set(zero_vec)
+
+  b0 = l_mat + m_mat
+  c0 = a0 * (b0 - 2.0) * (b0 - 1.0)
+  c0_masked = coeff_zeros.at[upper_0_indices].set(c0[upper_0_indices])
+  c0_masked = c0_masked.at[1, :].set(zero_vec)
+
+  # p_l^{m-1}.
+  p_mm1_l = (jnp.einsum('ij,ijk->ijk', a0_masked, p_m_lm1) +
+             jnp.einsum('ij,ijk->ijk', c0_masked, p_mm2_lm1))
+
+  d0 = -0.5 / (m_mat + 1.0)
+  d0_masked = coeff_zeros.at[upper_0_indices].set(d0[upper_0_indices])
+  e0 = d0 * b0 * (b0 + 1.0)
+  e0_masked = coeff_zeros.at[upper_0_indices].set(e0[upper_0_indices])
+
+  # p_l^{m+1}.
+  p_mp1_l = (jnp.einsum('ij,ijk->ijk', d0_masked, p_mp2_lm1) +
+             jnp.einsum('ij,ijk->ijk', e0_masked, p_m_lm1))
+
+  f0 = b0 * (l_mat - m_mat + 1.0) / 2.0
+  f0_masked = coeff_zeros.at[upper_0_indices].set(f0[upper_0_indices])
+  p_derivative = jnp.einsum('ij,ijk->ijk', f0_masked, p_mm1_l) - 0.5 * p_mp1_l
+
+  # Special treatment of the singularity at m = 1.
+  if num_m > 1:
+    l_vec = jnp.arange(num_l, dtype=p.dtype)
+    g0 = jnp.einsum('i,ij->ij', (l_vec + 1) * l_vec, p[0, :, :])
+    if num_l > 2:
+      g0 = g0 -  p[2, :, :]
+    p_derivative_m0 = jnp.einsum('j,ij->ij', 0.5 / jnp.sqrt(1 - x * x), g0)
+    p_derivative = p_derivative.at[1, :, :].set(p_derivative_m0)
+    p_derivative = p_derivative.at[1, 0, :].set(0)
+
+  return p_derivative
+
+
+@partial(jit, static_argnums=(0, 2))
+def _gen_associated_legendre(l_max: int,
+                             x: Array,
+                             is_normalized: bool) -> Array:
+  r"""Computes associated Legendre functions (ALFs) of the first kind.
+
+  The ALFs of the first kind are used in spherical harmonics. The spherical
+  harmonic of degree `l` and order `m` can be written as
+  `Y_l^m(θ, φ) = N_l^m * P_l^m(cos(θ)) * exp(i m φ)`, where `N_l^m` is the
+  normalization factor and θ and φ are the colatitude and longitude,
+  respectively. `N_l^m` is chosen in the way that the spherical harmonics form
+  a set of orthonormal basis functions of L^2(S^2). For the computational
+  efficiency of spherical harmonics transform, the normalization factor is
+  used in the computation of the ALFs. In addition, normalizing `P_l^m`
+  avoids overflow/underflow and achieves better numerical stability. Three
+  recurrence relations are used in the computation.
+
+  Args:
+    l_max: The maximum degree of the associated Legendre function. Both the
+      degrees and orders are `[0, 1, 2, ..., l_max]`.
+    x: A vector of type `float32`, `float64` containing the sampled points in
+      spherical coordinates, at which the ALFs are computed; `x` is essentially
+      `cos(θ)`. For the numerical integration used by the spherical harmonics
+      transforms, `x` contains the quadrature points in the interval of
+      `[-1, 1]`. There are several approaches to provide the quadrature points:
+      Gauss-Legendre method (`scipy.special.roots_legendre`), Gauss-Chebyshev
+      method (`scipy.special.roots_chebyu`), and Driscoll & Healy
+      method (Driscoll, James R., and Dennis M. Healy. "Computing Fourier
+      transforms and convolutions on the 2-sphere." Advances in applied
+      mathematics 15, no. 2 (1994): 202-250.). The Gauss-Legendre quadrature
+      points are nearly equal-spaced along θ and provide exact discrete
+      orthogonality, (P^m)^T W P_m = I, where `T` represents the transpose
+      operation, `W` is a diagonal matrix containing the quadrature weights,
+      and `I` is the identity matrix. The Gauss-Chebyshev points are equally
+      spaced, which only provide approximate discrete orthogonality. The
+      Driscoll & Healy quadrature points are equally spaced and provide the
+      exact discrete orthogonality. The number of sampling points is required to
+      be twice as the number of frequency points (modes) in the Driscoll & Healy
+      approach, which enables FFT and achieves a fast spherical harmonics
+      transform.
+    is_normalized: True if the associated Legendre functions are normalized.
+      With normalization, `N_l^m` is applied such that the spherical harmonics
+      form a set of orthonormal basis functions of L^2(S^2).
+
+  Returns:
+    The 3D array of shape `(l_max + 1, l_max + 1, len(x))` containing the values
+    of the ALFs at `x`; the dimensions in the sequence of order, degree, and
+    evaluation points.
+  """
+  p = jnp.zeros((l_max + 1, l_max + 1, x.shape[0]), dtype=x.dtype)
+
+  a_idx = jnp.arange(1, l_max + 1, dtype=x.dtype)
+  b_idx = jnp.arange(l_max, dtype=x.dtype)
+  if is_normalized:
+    initial_value: ArrayLike = 0.5 / jnp.sqrt(jnp.pi)  # The initial value p(0,0).
+    f_a = jnp.cumprod(-1 * jnp.sqrt(1.0 + 0.5 / a_idx))
+    f_b = jnp.sqrt(2.0 * b_idx + 3.0)
+  else:
+    initial_value = 1.0  # The initial value p(0,0).
+    f_a = jnp.cumprod(1.0 - 2.0 * a_idx)
+    f_b = 2.0 * b_idx + 1.0
+
+  p = p.at[(0, 0)].set(initial_value)
+
+  # Compute the diagonal entries p(l,l) with recurrence.
+  y = jnp.cumprod(
+      jnp.broadcast_to(jnp.sqrt(1.0 - x * x), (l_max, x.shape[0])),
+      axis=0)
+  p_diag = initial_value * jnp.einsum('i,ij->ij', f_a, y)
+  diag_indices = jnp.diag_indices(l_max + 1)
+  p = p.at[(diag_indices[0][1:], diag_indices[1][1:])].set(p_diag)
+
+  # Compute the off-diagonal entries with recurrence.
+  p_offdiag = jnp.einsum('ij,ij->ij',
+                         jnp.einsum('i,j->ij', f_b, x),
+                         p[jnp.diag_indices(l_max)])
+  offdiag_indices = (diag_indices[0][:l_max], diag_indices[1][:l_max] + 1)
+  p = p.at[offdiag_indices].set(p_offdiag)
+
+  # Compute the remaining entries with recurrence.
+  d0_mask_3d, d1_mask_3d = _gen_recurrence_mask(
+      l_max, is_normalized=is_normalized, dtype=x.dtype)
+
+  def body_fun(i, p_val):
+    coeff_0 = d0_mask_3d[i]
+    coeff_1 = d1_mask_3d[i]
+    h = (jnp.einsum('ij,ijk->ijk',
+                    coeff_0,
+                    jnp.einsum(
+                        'ijk,k->ijk', jnp.roll(p_val, shift=1, axis=1), x)) -
+         jnp.einsum('ij,ijk->ijk', coeff_1, jnp.roll(p_val, shift=2, axis=1)))
+    p_val = p_val + h
+    return p_val
+
+  # TODO(jakevdp): use some sort of fixed-point procedure here instead?
+  p = p.astype(jnp.result_type(p, x, d0_mask_3d))
+  if l_max > 1:
+    p = lax.fori_loop(lower=2, upper=l_max+1, body_fun=body_fun, init_val=p)
+
+  return p
+
+
+def lpmn(m: int, n: int, z: Array) -> tuple[Array, Array]:
+  """The associated Legendre functions (ALFs) of the first kind.
+
+  Args:
+    m: The maximum order of the associated Legendre functions.
+    n: The maximum degree of the associated Legendre function, often called
+      `l` in describing ALFs. Both the degrees and orders are
+      `[0, 1, 2, ..., l_max]`, where `l_max` denotes the maximum degree.
+    z: A vector of type `float32` or `float64` containing the sampling
+      points at which the ALFs are computed.
+
+  Returns:
+    A 2-tuple of 3D arrays of shape `(l_max + 1, l_max + 1, len(z))` containing
+    the values and derivatives of the associated Legendre functions of the
+    first kind. The return type matches the type of `z`.
+
+  Raises:
+    TypeError if elements of array `z` are not in (float32, float64).
+    ValueError if array `z` is not 1D.
+    NotImplementedError if `m!=n`.
+  """
+  dtype = lax.dtype(z)
+  if dtype not in (jnp.float32, jnp.float64):
+    raise TypeError(
+        'z.dtype={} is not supported, see docstring for supported types.'
+        .format(dtype))
+
+  if z.ndim != 1:
+    raise ValueError('z must be a 1D array.')
+
+  m = core.concrete_or_error(int, m, 'Argument m of lpmn.')
+  n = core.concrete_or_error(int, n, 'Argument n of lpmn.')
+
+  if m != n:
+    raise NotImplementedError('Computations for m!=n are not yet supported.')
+
+  l_max = n
+  is_normalized = False
+  p_vals = _gen_associated_legendre(l_max, z, is_normalized)
+  p_derivatives = _gen_derivatives(p_vals, z, is_normalized)
+
+  return (p_vals, p_derivatives)
+
+
+def lpmn_values(m: int, n: int, z: Array, is_normalized: bool) -> Array:
+  r"""The associated Legendre functions (ALFs) of the first kind.
+
+  Unlike `lpmn`, this function only computes the values of ALFs.
+  The ALFs of the first kind can be used in spherical harmonics. The
+  spherical harmonic of degree `l` and order `m` can be written as
+  :math:`Y_l^m(\theta, \phi) = N_l^m * P_l^m(\cos \theta) * \exp(i m \phi)`,
+  where :math:`N_l^m` is the normalization factor and θ and φ are the
+  colatitude and longitude, respectively. :math:`N_l^m` is chosen in the
+  way that the spherical harmonics form a set of orthonormal basis function
+  of :math:`L^2(S^2)`. Normalizing :math:`P_l^m` avoids overflow/underflow
+  and achieves better numerical stability.
+
+  Args:
+    m: The maximum order of the associated Legendre functions.
+    n: The maximum degree of the associated Legendre function, often called
+      `l` in describing ALFs. Both the degrees and orders are
+      `[0, 1, 2, ..., l_max]`, where `l_max` denotes the maximum degree.
+    z: A vector of type `float32` or `float64` containing the sampling
+      points at which the ALFs are computed.
+    is_normalized: True if the associated Legendre functions are normalized.
+      With normalization, :math:`N_l^m` is applied such that the spherical
+      harmonics form a set of orthonormal basis functions of :math:`L^2(S^2)`.
+
+  Returns:
+    A 3D array of shape `(l_max + 1, l_max + 1, len(z))` containing
+    the values of the associated Legendre functions of the first kind. The
+    return type matches the type of `z`.
+
+  Raises:
+    TypeError if elements of array `z` are not in (float32, float64).
+    ValueError if array `z` is not 1D.
+    NotImplementedError if `m!=n`.
+  """
+  dtype = lax.dtype(z)
+  if dtype not in (jnp.float32, jnp.float64):
+    raise TypeError(
+        'z.dtype={} is not supported, see docstring for supported types.'
+        .format(dtype))
+
+  if z.ndim != 1:
+    raise ValueError('z must be a 1D array.')
+
+  m = core.concrete_or_error(int, m, 'Argument m of lpmn.')
+  n = core.concrete_or_error(int, n, 'Argument n of lpmn.')
+
+  if m != n:
+    raise NotImplementedError('Computations for m!=n are not yet supported.')
+
+  l_max = n
+
+  return _gen_associated_legendre(l_max, z, is_normalized)
+
+
+
+@partial(jit, static_argnums=(4,))
+def _sph_harm(m: Array,
+              n: Array,
+              theta: Array,
+              phi: Array,
+              n_max: int) -> Array:
+  """Computes the spherical harmonics."""
+
+  cos_colatitude = jnp.cos(phi)
+
+  legendre = _gen_associated_legendre(n_max, cos_colatitude, True)
+  legendre_val = legendre.at[abs(m), n, jnp.arange(len(n))].get(mode="clip")
+
+  angle = abs(m) * theta
+  vandermonde = lax.complex(jnp.cos(angle), jnp.sin(angle))
+  harmonics = lax.complex(legendre_val * jnp.real(vandermonde),
+                          legendre_val * jnp.imag(vandermonde))
+
+  # Negative order.
+  harmonics = jnp.where(m < 0,
+                        (-1.0)**abs(m) * jnp.conjugate(harmonics),
+                        harmonics)
+
+  return harmonics
+
+
+def sph_harm(m: Array,
+             n: Array,
+             theta: Array,
+             phi: Array,
+             n_max: int | None = None) -> Array:
+  r"""Computes the spherical harmonics.
+
+  The JAX version has one extra argument `n_max`, the maximum value in `n`.
+
+  The spherical harmonic of degree `n` and order `m` can be written as
+  :math:`Y_n^m(\theta, \phi) = N_n^m * P_n^m(\cos \phi) * \exp(i m \theta)`,
+  where :math:`N_n^m = \sqrt{\frac{\left(2n+1\right) \left(n-m\right)!}
+  {4 \pi \left(n+m\right)!}}` is the normalization factor and :math:`\phi` and
+  :math:`\theta` are the colatitude and longitude, respectively. :math:`N_n^m` is
+  chosen in the way that the spherical harmonics form a set of orthonormal basis
+  functions of :math:`L^2(S^2)`.
+
+  Args:
+    m: The order of the harmonic; must have `|m| <= n`. Return values for
+      `|m| > n` are undefined.
+    n: The degree of the harmonic; must have `n >= 0`. The standard notation for
+      degree in descriptions of spherical harmonics is `l (lower case L)`. We
+      use `n` here to be consistent with `scipy.special.sph_harm`. Return
+      values for `n < 0` are undefined.
+    theta: The azimuthal (longitudinal) coordinate; must be in [0, 2*pi].
+    phi: The polar (colatitudinal) coordinate; must be in [0, pi].
+    n_max: The maximum degree `max(n)`. If the supplied `n_max` is not the true
+      maximum value of `n`, the results are clipped to `n_max`. For example,
+      `sph_harm(m=jnp.array([2]), n=jnp.array([10]), theta, phi, n_max=6)`
+      actually returns
+      `sph_harm(m=jnp.array([2]), n=jnp.array([6]), theta, phi, n_max=6)`
+  Returns:
+    A 1D array containing the spherical harmonics at (m, n, theta, phi).
+  """
+
+  if jnp.isscalar(phi):
+    phi = jnp.array([phi])
+
+  if n_max is None:
+    n_max = np.max(n)
+  n_max = core.concrete_or_error(
+      int, n_max, 'The `n_max` argument of `jnp.scipy.special.sph_harm` must '
+      'be statically specified to use `sph_harm` within JAX transformations.')
+
+  return _sph_harm(m, n, theta, phi, n_max)
+
+
+# exponential integrals
+# these algorithms are ported over from the files ei.c and expn.c in the Cephes mathematical library.
+# https://fossies.org/dox/cephes-math-28/ei_8c_source.html
+# https://fossies.org/dox/cephes-math-28/expn_8c_source.html
+
+
+def _expint1(x: Array) -> Array:
+  # 0 < x <= 2
+  A = [
+    -5.350447357812542947283e0,
+    2.185049168816613393830e2,
+    -4.176572384826693777058e3,
+    5.541176756393557601232e4,
+    -3.313381331178144034309e5,
+    1.592627163384945414220e6,
+  ]
+  B = [
+    1.0,
+    -5.250547959112862969197e1,
+    1.259616186786790571525e3,
+    -1.756549581973534652631e4,
+    1.493062117002725991967e5,
+    -7.294949239640527645655e5,
+    1.592627163384945429726e6,
+  ]
+  A_arr = jnp.array(A, dtype=x.dtype)
+  B_arr = jnp.array(B, dtype=x.dtype)
+  f = jnp.polyval(A_arr, x) / jnp.polyval(B_arr, x)
+  return x * f + jnp.euler_gamma + jnp.log(x)
+
+
+def _eval_expint_k(A: list[float], B: list[float], x: Array) -> Array:
+  # helper function for all subsequent intervals
+  A_arr = jnp.array(A, dtype=x.dtype)
+  B_arr = jnp.array(B, dtype=x.dtype)
+  one = _lax_const(x, 1.0)
+  w = one / x
+  f = jnp.polyval(A_arr, w) / jnp.polyval(B_arr, w)
+  f = w * f + one
+  return jnp.exp(x) * w * f
+
+
+def _expint2(x: Array) -> Array:
+  # 2 <= x < 4
+  A = [
+    1.981808503259689673238e-2,
+    -1.271645625984917501326e0,
+    -2.088160335681228318920e0,
+    2.755544509187936721172e0,
+    -4.409507048701600257171e-1,
+    4.665623805935891391017e-2,
+    -1.545042679673485262580e-3,
+    7.059980605299617478514e-5,
+  ]
+  B = [
+    1.0,
+    1.476498670914921440652e0,
+    5.629177174822436244827e-1,
+    1.699017897879307263248e-1,
+    2.291647179034212017463e-2,
+    4.450150439728752875043e-3,
+    1.727439612206521482874e-4,
+    3.953167195549672482304e-5,
+  ]
+  return _eval_expint_k(A, B, x)
+
+
+def _expint3(x: Array) -> Array:
+  # 4 <= x <= 8
+  A = [
+    -1.373215375871208729803e0,
+    -7.084559133740838761406e-1,
+    1.580806855547941010501e0,
+    -2.601500427425622944234e-1,
+    2.994674694113713763365e-2,
+    -1.038086040188744005513e-3,
+    4.371064420753005429514e-5,
+    2.141783679522602903795e-6,
+  ]
+  B = [
+    1.0,
+    8.585231423622028380768e-1,
+    4.483285822873995129957e-1,
+    7.687932158124475434091e-2,
+    2.449868241021887685904e-2,
+    8.832165941927796567926e-4,
+    4.590952299511353531215e-4,
+    -4.729848351866523044863e-6,
+    2.665195537390710170105e-6,
+  ]
+  return _eval_expint_k(A, B, x)
+
+
+def _expint4(x: Array) -> Array:
+  # 8 <= x <= 16
+  A = [
+    -2.106934601691916512584e0,
+    1.732733869664688041885e0,
+    -2.423619178935841904839e-1,
+    2.322724180937565842585e-2,
+    2.372880440493179832059e-4,
+    -8.343219561192552752335e-5,
+    1.363408795605250394881e-5,
+    -3.655412321999253963714e-7,
+    1.464941733975961318456e-8,
+    6.176407863710360207074e-10,
+  ]
+  B = [
+    1.0,
+    -2.298062239901678075778e-1,
+    1.105077041474037862347e-1,
+    -1.566542966630792353556e-2,
+    2.761106850817352773874e-3,
+    -2.089148012284048449115e-4,
+    1.708528938807675304186e-5,
+    -4.459311796356686423199e-7,
+    1.394634930353847498145e-8,
+    6.150865933977338354138e-10,
+  ]
+  return _eval_expint_k(A, B, x)
+
+
+def _expint5(x):
+  # 16 <= x <= 32
+  A = [
+    -2.458119367674020323359e-1,
+    -1.483382253322077687183e-1,
+    7.248291795735551591813e-2,
+    -1.348315687380940523823e-2,
+    1.342775069788636972294e-3,
+    -7.942465637159712264564e-5,
+    2.644179518984235952241e-6,
+    -4.239473659313765177195e-8,
+  ]
+  B = [
+    1.0,
+    -1.044225908443871106315e-1,
+    -2.676453128101402655055e-1,
+    9.695000254621984627876e-2,
+    -1.601745692712991078208e-2,
+    1.496414899205908021882e-3,
+    -8.462452563778485013756e-5,
+    2.728938403476726394024e-6,
+    -4.239462431819542051337e-8,
+  ]
+  return _eval_expint_k(A, B, x)
+
+
+def _expint6(x):
+  # 32 <= x <= 64
+  A = [
+    1.212561118105456670844e-1,
+    -5.823133179043894485122e-1,
+    2.348887314557016779211e-1,
+    -3.040034318113248237280e-2,
+    1.510082146865190661777e-3,
+    -2.523137095499571377122e-5,
+  ]
+  B = [
+    1.0,
+    -1.002252150365854016662e0,
+    2.928709694872224144953e-1,
+    -3.337004338674007801307e-2,
+    1.560544881127388842819e-3,
+    -2.523137093603234562648e-5,
+  ]
+  return _eval_expint_k(A, B, x)
+
+
+def _expint7(x):
+  # x > 64
+  A = [
+    -7.657847078286127362028e-1,
+    6.886192415566705051750e-1,
+    -2.132598113545206124553e-1,
+    3.346107552384193813594e-2,
+    -3.076541477344756050249e-3,
+    1.747119316454907477380e-4,
+    -6.103711682274170530369e-6,
+    1.218032765428652199087e-7,
+    -1.086076102793290233007e-9,
+  ]
+  B = [
+    1.0,
+    -1.888802868662308731041e0,
+    1.066691687211408896850e0,
+    -2.751915982306380647738e-1,
+    3.930852688233823569726e-2,
+    -3.414684558602365085394e-3,
+    1.866844370703555398195e-4,
+    -6.345146083130515357861e-6,
+    1.239754287483206878024e-7,
+    -1.086076102793126632978e-9,
+  ]
+  return _eval_expint_k(A, B, x)
+
+
+def _expi_pos(x: Array) -> Array:
+  # x >= 0
+  _c = _lax_const
+  conds = [(_c(x, 0) < x) & (x <= _c(x, 2))] + [
+    (_c(x, 2 ** i) < x) & (x <= _c(x, 2 ** (i + 1))) for i in range(1, 6)
+  ]
+  return jnp.piecewise(
+    x,
+    conds,
+    [_expint1, _expint2, _expint3, _expint4, _expint5, _expint6, _expint7],
+  )
+
+def _expi_neg(x: Array) -> Array:
+  # x < 0
+  return -exp1(-x)
+
+@custom_derivatives.custom_jvp
+@jit
+def expi(x: ArrayLike) -> Array:
+  r"""Exponential integral function.
+
+  JAX implementation of :obj:`scipy.special.expi`
+
+  .. math::
+
+     \mathrm{expi}(x) = \int_{-\infty}^x \frac{e^t}{t} \mathrm{d}t
+
+  Args:
+    x: arraylike, real-valued
+
+  Returns:
+    array of expi values
+
+  See also:
+    - :func:`jax.scipy.special.expn`
+    - :func:`jax.scipy.special.exp1`
+  """
+  x_arr, = promote_args_inexact("expi", x)
+  return jnp.piecewise(x_arr, [x_arr < 0], [_expi_neg, _expi_pos])
+
+
+@expi.defjvp
+@jit
+def expi_jvp(primals, tangents):
+  (x,) = primals
+  (x_dot,) = tangents
+  return expi(x), jnp.exp(x) / x * x_dot
+
+
+def _expn1(n: int, x_in: ArrayLike) -> Array:
+  # exponential integral En
+  _c = _lax_const
+  x = jnp.asarray(x_in)
+  MACHEP = jnp.finfo(x.dtype).eps
+
+  zero = _c(x, 0.0)
+  one = _c(x, 1.0)
+  psi = -jnp.euler_gamma - jnp.log(x)
+  psi = lax.fori_loop(_c(n, 1), n, lambda i, psi: psi + one / i, psi)
+  n1 = jnp.where(n == _c(n, 1), one + one, n)
+  init = dict(
+    x=x,
+    z=-x,
+    xk=zero,
+    yk=one,
+    pk=one - n,
+    ans=jnp.where(n == _c(n, 1), zero, one / (one - n1)),
+    t=jnp.inf,
+  )
+
+  def body(d):
+    d["xk"] += one
+    d["yk"] *= d["z"] / d["xk"]
+    d["pk"] += one
+    d["ans"] += jnp.where(d["pk"] != zero, d["yk"] / d["pk"], zero)
+    d["t"] = jnp.where(d["ans"] != zero, abs(d["yk"] / d["ans"]), one)
+    return d
+
+  def cond(d):
+    return (d["x"] > _c(d["x"], 0.0)) & (d["t"] > MACHEP)
+
+  d = lax.while_loop(cond, body, init)
+  t = n
+  r = n - _c(n, 1)
+  return d["z"] ** r * psi / jnp.exp(gammaln(t)) - d["ans"]
+
+
+def _expn2(n: int, x: Array) -> Array:
+  # x > 1.
+  _c = _lax_const
+  BIG = _c(x, 1.44115188075855872e17)
+  MACHEP = jnp.finfo(BIG.dtype).eps  # ?
+  zero = _c(x, 0.0)
+  one = _c(x, 1.0)
+
+  init = dict(
+    k=_c(n, 1),
+    pkm2=one,
+    qkm2=x,
+    pkm1=one,
+    qkm1=x + n,
+    ans=one / (x + n),
+    t=_c(x, jnp.inf),
+    r=zero,
+    x=x,
+  )
+
+  def body(d):
+    x = d["x"]
+    d["k"] += _c(d["k"], 1)
+    k = d["k"]
+    odd = k % _c(k, 2) == _c(k, 1)
+    yk = jnp.where(odd, one, x)
+    xk = jnp.where(odd, n + (k - _c(k, 1)) / _c(k, 2), k / _c(k, 2))
+    pk = d["pkm1"] * yk + d["pkm2"] * xk
+    qk = d["qkm1"] * yk + d["qkm2"] * xk
+    nz = qk != zero
+    d["r"] = r = jnp.where(nz, pk / qk, d["r"])
+    d["t"] = jnp.where(nz, abs((d["ans"] - r) / r), one)
+    d["ans"] = jnp.where(nz, r, d["ans"])
+    d["pkm2"] = d["pkm1"]
+    d["pkm1"] = pk
+    d["qkm2"] = d["qkm1"]
+    d["qkm1"] = qk
+    is_big = abs(pk) > BIG
+    for s in "pq":
+      for i in "12":
+        key = s + "km" + i
+        d[key] = jnp.where(is_big, d[key] / BIG, d[key])
+    return d
+
+  def cond(d):
+    return (d["x"] > _c(d["k"], 0)) & (d["t"] > MACHEP)
+
+  d = lax.while_loop(cond, body, init)
+  return d["ans"] * jnp.exp(-x)
+
+
+def _expn3(n: int, x: Array) -> Array:
+  # n >= 5000
+  _c = _lax_const
+  one = _c(x, 1.0)
+  xk = x + n
+  yk = one / (xk * xk)
+  t = n
+  ans = yk * t * (_c(x, 6) * x * x - _c(x, 8) * t * x + t * t)
+  ans = yk * (ans + t * (t - _c(x, 2) * x))
+  ans = yk * (ans + t)
+  return (ans + one) * jnp.exp(-x) / xk
+
+
+@partial(custom_derivatives.custom_jvp, nondiff_argnums=(0,))
+@jnp.vectorize
+@jit
+def expn(n: ArrayLike, x: ArrayLike) -> Array:
+  r"""Generalized exponential integral function.
+
+  JAX implementation of :obj:`scipy.special.expn`.
+
+  .. math::
+
+     \mathrm{expn}(x) = E_n(x) = x^{n-1}\int_x^\infty\frac{e^{-t}}{t^n}\mathrm{d}t
+
+  Args:
+    n: arraylike, real-valued
+    x: arraylike, real-valued
+
+  Returns:
+    array of expn values
+
+  See also:
+    - :func:`jax.scipy.special.expi`
+    - :func:`jax.scipy.special.exp1`
+  """
+  n, x = promote_args_inexact("expn", n, x)
+  _c = _lax_const
+  zero = _c(x, 0)
+  one = _c(x, 1)
+  conds = [
+    (n < _c(n, 0)) | (x < zero),
+    (x == zero) & (n < _c(n, 2)),
+    (x == zero) & (n >= _c(n, 2)),
+    (n == _c(n, 0)) & (x >= zero),
+    (n >= _c(n, 5000)),
+    (x > one),
+  ]
+  n1 = jnp.where(n == _c(n, 1), n + n, n)
+  vals = [
+    jnp.nan,
+    jnp.inf,
+    one / n1,  # prevent div by zero
+    jnp.exp(-x) / x,
+    partial(_expn3, n),
+    partial(_expn2, n),
+    partial(_expn1, n),
+  ]
+  ret = jnp.piecewise(x, conds, vals)
+  return ret
+
+
+@expn.defjvp
+@jit
+def expn_jvp(n, primals, tangents):
+  (x,), (x_dot,) = primals, tangents
+  return expn(n, x), lax.mul(
+    lax.neg(x_dot), expn(lax.sub(n, _lax_const(n, 1)), x)
+  )
+
+
+def exp1(x: ArrayLike) -> Array:
+  r"""Exponential integral function.
+
+  JAX implementation of :obj:`scipy.special.exp1`
+
+  .. math::
+
+     \mathrm{exp1}(x) = E_1(x) = x^{n-1}\int_x^\infty\frac{e^{-t}}{t}\mathrm{d}t
+
+
+  Args:
+    x: arraylike, real-valued
+
+  Returns:
+    array of exp1 values
+
+  See also:
+    - :func:`jax.scipy.special.expi`
+    - :func:`jax.scipy.special.expn`
+  """
+  x, = promote_args_inexact("exp1", x)
+  # Casting because custom_jvp generic does not work correctly with mypy.
+  return cast(Array, expn(1, x))
+
+
+def _spence_poly(w: Array) -> Array:
+  A = jnp.array([4.65128586073990045278E-5,
+                  7.31589045238094711071E-3,
+                  1.33847639578309018650E-1,
+                  8.79691311754530315341E-1,
+                  2.71149851196553469920E0,
+                  4.25697156008121755724E0,
+                  3.29771340985225106936E0,
+                  1.00000000000000000126E0,
+                  ], dtype=w.dtype)
+
+  B = jnp.array([6.90990488912553276999E-4,
+                  2.54043763932544379113E-2,
+                  2.82974860602568089943E-1,
+                  1.41172597751831069617E0,
+                  3.63800533345137075418E0,
+                  5.03278880143316990390E0,
+                  3.54771340985225096217E0,
+                  9.99999999999999998740E-1,
+                  ],dtype=w.dtype)
+
+  return -w * jnp.polyval(A, w) / jnp.polyval(B, w)
+
+
+def _spence_calc(x: Array) -> Array:
+  x2_bool = x > 2.0
+  x = jnp.piecewise(x, [x2_bool],
+                    [lambda x: 1.0 / x, lambda x: x])
+
+  x1_5_bool = x > 1.5
+  x_5_bool = x < 0.5
+  x2_bool = x2_bool | x1_5_bool
+
+  w = jnp.piecewise(x,
+                    [x1_5_bool, x_5_bool],
+                    [lambda x: 1.0 / x - 1.0,
+                      lambda x: -x,
+                      lambda x: x - 1.0])
+
+  y = _spence_poly(w)
+  y_flag_one = jnp.pi ** 2 / 6.0 - jnp.log(x) * jnp.log(1.0 - x) - y
+  y = jnp.where(x_5_bool, y_flag_one, y)
+  y_flag_two = -0.5 * jnp.log(x) ** 2 - y
+  return jnp.where(x2_bool, y_flag_two, y)
+
+
+def _spence(x: Array) -> Array:
+  return jnp.piecewise(x,
+                       [x < 0.0, x == 1.0, x == 0.0],
+                       [jnp.nan, 0, jnp.pi ** 2 / 6, _spence_calc])
+
+
+def spence(x: Array) -> Array:
+  r"""Spence's function, also known as the dilogarithm for real values.
+
+  JAX implementation of :obj:`scipy.special.spence`.
+
+  It is defined to be:
+
+  .. math::
+    \mathrm{spence}(x) = \begin{equation}
+    \int_1^x \frac{\log(t)}{1 - t}dt
+    \end{equation}
+
+  Unlike the SciPy implementation, this is only defined for positive
+  real values of `z`. For negative values, `NaN` is returned.
+
+  Args:
+    z: An array of type `float32`, `float64`.
+
+  Returns:
+    An array with `dtype=z.dtype`.
+    computed values of Spence's function.
+
+  Raises:
+    TypeError: if elements of array `z` are not in (float32, float64).
+
+  Notes:
+  There is a different convention which defines Spence's function by the
+  integral:
+
+  .. math::
+    \begin{equation}
+    -\int_0^z \frac{\log(1 - t)}{t}dt
+    \end{equation}
+
+  This is our spence(1 - z).
+  """
+  x = jnp.asarray(x)
+  dtype = lax.dtype(x)
+  if dtype not in (jnp.float32, jnp.float64):
+    raise TypeError(
+      f"x.dtype={dtype} is not supported, see docstring for supported types.")
+  return _spence(x)
+
+
+def bernoulli(n: int) -> Array:
+  """Generate the first N Bernoulli numbers.
+
+  JAX implementation of :func:`scipy.special.bernoulli`.
+
+  Args:
+    n: integer, the number of Bernoulli terms to generate.
+
+  Returns:
+    Array containing the first ``n`` Bernoulli numbers.
+
+  Notes:
+    ``bernoulli`` generates numbers using the :math:`B_n^-` convention,
+    such that :math:`B_1=-1/2`.
+  """
+  # Generate Bernoulli numbers using the Chowla and Hartung algorithm.
+  n = core.concrete_or_error(operator.index, n, "Argument n of bernoulli")
+  if n < 0:
+    raise ValueError("n must be a non-negative integer.")
+  b3 = jnp.array([1, -1/2, 1/6])
+  if n < 3:
+    return b3[:n + 1]
+  bn = jnp.zeros(n + 1).at[:3].set(b3)
+  m = jnp.arange(4, n + 1, 2, dtype=bn.dtype)
+  q1 = (1. / jnp.pi ** 2) * jnp.cumprod(-(m - 1) * m / 4 / jnp.pi ** 2)
+  k = jnp.arange(2, 50, dtype=bn.dtype)  # Choose 50 because 2 ** -50 < 1E-15
+  q2 = jnp.sum(k[:, None] ** -m[None, :], axis=0)
+  return bn.at[4::2].set(q1 * (1 + q2))
+
+
+@custom_derivatives.custom_jvp
+def poch(z: ArrayLike, m: ArrayLike) -> Array:
+  r"""The Pochammer symbol.
+
+  JAX implementation of :obj:`scipy.special.poch`.
+
+  .. math::
+
+     \mathrm{poch}(z, m) = (z)_m = \frac{\Gamma(z + m)}{\Gamma(z)}
+
+  where :math:`\Gamma(z)` is the :func:`~jax.scipy.special.gamma` function.
+
+  Args:
+    z: arraylike, real-valued
+    m: arraylike, real-valued
+
+  Returns:
+    array of Pochammer values.
+
+  Notes:
+    The JAX version supports only real-valued inputs.
+  """
+  z, m = promote_args_inexact("poch", z, m)
+
+  return jnp.where(m == 0., jnp.array(1, dtype=z.dtype), gamma(z + m) / gamma(z))
+
+
+def _poch_z_derivative(z, m):
+  """
+  Defined in :
+  https://functions.wolfram.com/GammaBetaErf/Pochhammer/20/01/01/
+  """
+
+  return (digamma(z + m) - digamma(z)) * poch(z, m)
+
+
+def _poch_m_derivative(z, m):
+  """
+  Defined in :
+  https://functions.wolfram.com/GammaBetaErf/Pochhammer/20/01/02/
+  """
+
+  return digamma(z + m) * poch(z, m)
+
+
+poch.defjvps(
+  lambda z_dot, primal_out, z, m:  _poch_z_derivative(z, m) * z_dot,
+  lambda m_dot, primal_out, z, m: _poch_m_derivative(z, m) * m_dot,
+)
+
+
+def _hyp1f1_serie(a, b, x):
+  """
+  Compute the 1F1 hypergeometric function using the taylor expansion
+  See Eq. 3.2 and associated method (a) from PEARSON, OLVER & PORTER 2014
+  https://doi.org/10.48550/arXiv.1407.7786
+  """
+
+  precision = jnp.finfo(x.dtype).eps
+
+  def body(state):
+    serie, k, term = state
+    serie += term
+    term *= (a + k) / (b + k) * x / (k + 1)
+    k += 1
+
+    return serie, k, term
+
+  def cond(state):
+    serie, k, term = state
+
+    return (k < 250) & (lax.abs(term) / lax.abs(serie) > precision)
+
+  init = 1, 1, a / b * x
+
+  return lax.while_loop(cond, body, init)[0]
+
+
+def _hyp1f1_asymptotic(a, b, x):
+  """
+  Compute the 1F1 hypergeometric function using asymptotic expansion
+  See Eq. 3.8 and simplification for real inputs from PEARSON, OLVER & PORTER 2014
+  https://doi.org/10.48550/arXiv.1407.7786
+  """
+
+  precision = jnp.finfo(x.dtype).eps
+
+  def body(state):
+    serie, k, term = state
+    serie += term
+    term *= (b - a + k) * (1 - a + k) / (k + 1) / x
+    k += 1
+
+    return serie, k, term
+
+  def cond(state):
+    serie, k, term = state
+
+    return (k < 250) & (lax.abs(term) / lax.abs(serie) > precision)
+
+  init = 1, 1, (b - a) * (1 - a) / x
+  serie = lax.while_loop(cond, body, init)[0]
+
+  return gamma(b) / gamma(a) * lax.exp(x) * x ** (a - b) * serie
+
+
+@jit
+@jnp.vectorize
+def _hyp1f1_a_derivative(a, b, x):
+  """
+  Define it as a serie using :
+  https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/01/
+  """
+
+  precision = jnp.finfo(x.dtype).eps
+
+  def body(state):
+    serie, k, term = state
+    serie += term * (digamma(a + k) - digamma(a))
+    term *= (a + k) / (b + k) * x / (k + 1)
+    k += 1
+
+    return serie, k, term
+
+  def cond(state):
+    serie, k, term = state
+
+    return (k < 250) & (lax.abs(term) / lax.abs(serie) > precision)
+
+  init = 0, 1, a / b * x
+
+  return lax.while_loop(cond, body, init)[0]
+
+
+@jit
+@jnp.vectorize
+def _hyp1f1_b_derivative(a, b, x):
+  """
+  Define it as a serie using :
+  https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/02/
+  """
+
+  precision = jnp.finfo(x.dtype).eps
+
+  def body(state):
+    serie, k, term = state
+    serie += term * (digamma(b) - digamma(b + k))
+    term *= (a + k) / (b + k) * x / (k + 1)
+    k += 1
+
+    return serie, k, term
+
+  def cond(state):
+    serie, k, term = state
+
+    return (k < 250) & (lax.abs(term) / lax.abs(serie) > precision)
+
+  init = 0, 1, a / b * x
+
+  return lax.while_loop(cond, body, init)[0]
+
+
+@jit
+def _hyp1f1_x_derivative(a, b, x):
+  """
+  Define it as a serie using :
+  https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/04/
+  """
+
+  return a / b * hyp1f1(a + 1, b + 1, x)
+
+
+@custom_derivatives.custom_jvp
+@jit
+@jnp.vectorize
+def hyp1f1(a: ArrayLike, b: ArrayLike, x: ArrayLike) -> Array:
+  r"""The 1F1 hypergeometric function.
+
+  JAX implementation of :obj:`scipy.special.hyp1f1`.
+
+  .. math::
+
+     \mathrm{hyp1f1}(a, b, x) = {}_1F_1(x;a, b) = \sum_{k=0}^\infty \frac{(a)_k}{(b)_kk!}x^k
+
+  where :math:`(\cdot)_k` is the Pochammer symbol (refer to :func:`~jax.scipy.special.poch`).
+
+  The JAX version only accepts positive and real inputs. Values of ``a``, ``b``,
+  and ``x``, leading to high values of 1F1 may lead to erroneous results;
+  consider enabling double precision in this case. The convention for
+  ``a = b = 0`` is ``1``, unlike in scipy's implementation.
+
+  Args:
+    a: arraylike, real-valued
+    b: arraylike, real-valued
+    x: arraylike, real-valued
+
+  Returns:
+    array of 1F1 values.
+  """
+  # This is backed by https://doi.org/10.48550/arXiv.1407.7786
+  # There is room for improvement in the implementation using recursion to
+  # evaluate lower values of hyp1f1 when a or b or both are > 60-80
+  a, b, x = promote_args_inexact('hyp1f1', a, b, x)
+
+  result = lax.cond(lax.abs(x) < 100, _hyp1f1_serie, _hyp1f1_asymptotic, a, b, x)
+  index = (a == 0) * 1 + ((a == b) & (a != 0)) * 2 + ((b == 0) & (a != 0)) * 3
+
+  return lax.select_n(index,
+                      result,
+                      jnp.array(1, dtype=x.dtype),
+                      jnp.exp(x),
+                      jnp.array(jnp.inf, dtype=x.dtype))
+
+
+hyp1f1.defjvps(
+  lambda a_dot, primal_out, a, b, x: _hyp1f1_a_derivative(a, b, x) * a_dot,
+  lambda b_dot, primal_out, a, b, x: _hyp1f1_b_derivative(a, b, x) * b_dot,
+  lambda x_dot, primal_out, a, b, x: _hyp1f1_x_derivative(a, b, x) * x_dot
+)