fonttools 4.56.0__cp313-cp313-win_amd64.whl → 4.58.0__cp313-cp313-win_amd64.whl

fontTools/subset/__init__.py

@@ -16,6 +16,7 @@ from fontTools.subset.cff import *
 from fontTools.subset.svg import *
 from fontTools.varLib import varStore, multiVarStore  # For monkey-patching
 from fontTools.ttLib.tables._n_a_m_e import NameRecordVisitor
+from fontTools.unicodedata import mirrored
 import sys
 import struct
 import array
@@ -2870,6 +2871,15 @@ def prune_post_subset(self, font, options):
 def closure_glyphs(self, s):
     tables = [t for t in self.tables if t.isUnicode()]
 
+    # Closure unicodes, which for now is pulling in bidi mirrored variants
+    if s.options.bidi_closure:
+        additional_unicodes = set()
+        for u in s.unicodes_requested:
+            mirror_u = mirrored(u)
+            if mirror_u is not None:
+                additional_unicodes.add(mirror_u)
+        s.unicodes_requested.update(additional_unicodes)
+
     # Close glyphs
     for table in tables:
         if table.format == 14:
@@ -3191,6 +3201,7 @@ class Options(object):
         self.font_number = -1
         self.pretty_svg = False
         self.lazy = True
+        self.bidi_closure = True
 
         self.set(**kwargs)
 

fontTools/ttLib/__init__.py

@@ -1,5 +1,6 @@
 """fontTools.ttLib -- a package for dealing with TrueType fonts."""
 
+from fontTools.config import OPTIONS
 from fontTools.misc.loggingTools import deprecateFunction
 import logging
 
@@ -7,6 +8,9 @@ import logging
 log = logging.getLogger(__name__)
 
 
+OPTIMIZE_FONT_SPEED = OPTIONS["fontTools.ttLib:OPTIMIZE_FONT_SPEED"]
+
+
 class TTLibError(Exception):
     pass
 

fontTools/ttLib/__main__.py

@@ -1,5 +1,5 @@
 import sys
-from fontTools.ttLib import TTLibError, TTLibFileIsCollectionError
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, TTLibError, TTLibFileIsCollectionError
 from fontTools.ttLib.ttFont import *
 from fontTools.ttLib.ttCollection import TTCollection
 
@@ -51,7 +51,7 @@ def main(args=None):
     )
     parser.add_argument("font", metavar="font", nargs="*", help="Font file.")
     parser.add_argument(
-        "-t", "--table", metavar="table", nargs="*", help="Tables to decompile."
+        "-t", "--table", metavar="table", action="append", help="Tables to decompile."
     )
     parser.add_argument(
         "-o", "--output", metavar="FILE", default=None, help="Output file."
@@ -71,27 +71,66 @@ def main(args=None):
         default=None,
         help="Flavor of output font. 'woff' or 'woff2'.",
     )
+    parser.add_argument(
+        "--no-recalc-timestamp",
+        dest="recalcTimestamp",
+        action="store_false",
+        help="Keep the original font 'modified' timestamp.",
+    )
+    parser.add_argument(
+        "-b",
+        dest="recalcBBoxes",
+        action="store_false",
+        help="Don't recalc glyph bounding boxes: use the values in the original font.",
+    )
+    parser.add_argument(
+        "--optimize-font-speed",
+        action="store_true",
+        help=(
+            "Enable optimizations that prioritize speed over file size. This "
+            "mainly affects how glyf table and gvar / VARC tables are compiled."
+        ),
+    )
     options = parser.parse_args(args)
 
     fontNumber = int(options.y) if options.y is not None else None
     outFile = options.output
     lazy = options.lazy
     flavor = options.flavor
-    tables = options.table if options.table is not None else ["*"]
+    tables = options.table
+    recalcBBoxes = options.recalcBBoxes
+    recalcTimestamp = options.recalcTimestamp
+    optimizeFontSpeed = options.optimize_font_speed
 
     fonts = []
     for f in options.font:
         try:
-            font = TTFont(f, fontNumber=fontNumber, lazy=lazy)
+            font = TTFont(
+                f,
+                recalcBBoxes=recalcBBoxes,
+                recalcTimestamp=recalcTimestamp,
+                fontNumber=fontNumber,
+                lazy=lazy,
+            )
+            if optimizeFontSpeed:
+                font.cfg[OPTIMIZE_FONT_SPEED] = optimizeFontSpeed
             fonts.append(font)
         except TTLibFileIsCollectionError:
             collection = TTCollection(f, lazy=lazy)
             fonts.extend(collection.fonts)
 
-    if lazy is False:
-        for font in fonts:
-            for table in tables if "*" not in tables else font.keys():
-                font[table]  # Decompiles
+    if tables is None:
+        if lazy is False:
+            tables = ["*"]
+        elif optimizeFontSpeed:
+            tables = {"glyf", "gvar", "VARC"}.intersection(font.keys())
+        else:
+            tables = []
+    for font in fonts:
+        if "GlyphOrder" in tables:
+            font.getGlyphOrder()
+        for table in tables if "*" not in tables else font.keys():
+            font[table]  # Decompiles
 
     if outFile is not None:
         if len(fonts) == 1:

fontTools/ttLib/tables/D__e_b_g.py

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

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

fontTools/ttLib/tables/T_S_I__0.py

@@ -1,4 +1,4 @@
-""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+"""TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
 tool to store its hinting source data.
 
 TSI0 is the index table containing the lengths and offsets for the glyph
@@ -8,9 +8,13 @@ in the TSI1 table.
 See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
 """
 
-from . import DefaultTable
+import logging
 import struct
 
+from . import DefaultTable
+
+log = logging.getLogger(__name__)
+
 tsi0Format = ">HHL"
 
 
@@ -25,7 +29,14 @@ class table_T_S_I__0(DefaultTable.DefaultTable):
         numGlyphs = ttFont["maxp"].numGlyphs
         indices = []
         size = struct.calcsize(tsi0Format)
-        for i in range(numGlyphs + 5):
+        numEntries = len(data) // size
+        if numEntries != numGlyphs + 5:
+            diff = numEntries - numGlyphs - 5
+            log.warning(
+                "Number of glyphPrograms differs from the number of glyphs in the font "
+                f"by {abs(diff)} ({numEntries - 5} programs vs. {numGlyphs} glyphs)."
+            )
+        for _ in range(numEntries):
             glyphID, textLength, textOffset = fixlongs(
                 *struct.unpack(tsi0Format, data[:size])
             )

fontTools/ttLib/tables/T_S_I__5.py

@@ -1,4 +1,4 @@
-""" TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
+"""TSI{0,1,2,3,5} are private tables used by Microsoft Visual TrueType (VTT)
 tool to store its hinting source data.
 
 TSI5 contains the VTT character groups.
@@ -6,22 +6,33 @@ TSI5 contains the VTT character groups.
 See also https://learn.microsoft.com/en-us/typography/tools/vtt/tsi-tables
 """
 
+import array
+import logging
+import sys
+
 from fontTools.misc.textTools import safeEval
+
 from . import DefaultTable
-import sys
-import array
+
+log = logging.getLogger(__name__)
 
 
 class table_T_S_I__5(DefaultTable.DefaultTable):
     def decompile(self, data, ttFont):
         numGlyphs = ttFont["maxp"].numGlyphs
-        assert len(data) == 2 * numGlyphs
         a = array.array("H")
         a.frombytes(data)
         if sys.byteorder != "big":
             a.byteswap()
         self.glyphGrouping = {}
-        for i in range(numGlyphs):
+        numEntries = len(data) // 2
+        if numEntries != numGlyphs:
+            diff = numEntries - numGlyphs
+            log.warning(
+                "Number of entries differs from the number of glyphs in the font "
+                f"by {abs(diff)} ({numEntries} entries vs. {numGlyphs} glyphs)."
+            )
+        for i in range(numEntries):
             self.glyphGrouping[ttFont.getGlyphName(i)] = a[i]
 
     def compile(self, ttFont):

fontTools/ttLib/tables/__init__.py

@@ -23,6 +23,7 @@ def _moduleFinderHint():
     from . import G_P_K_G_
     from . import G_P_O_S_
     from . import G_S_U_B_
+    from . import G_V_A_R_
     from . import G__l_a_t
     from . import G__l_o_c
     from . import H_V_A_R_

fontTools/ttLib/tables/_c_m_a_p.py

@@ -141,6 +141,17 @@ class table__c_m_a_p(DefaultTable.DefaultTable):
                     result.setdefault(name, set()).add(codepoint)
         return result
 
+    def buildReversedMin(self):
+        result = {}
+        for subtable in self.tables:
+            if subtable.isUnicode():
+                for codepoint, name in subtable.cmap.items():
+                    if name in result:
+                        result[name] = min(result[name], codepoint)
+                    else:
+                        result[name] = codepoint
+        return result
+
     def decompile(self, data, ttFont):
         tableVersion, numSubTables = struct.unpack(">HH", data[:4])
         self.tableVersion = int(tableVersion)
@@ -1162,13 +1173,15 @@ class cmap_format_12_or_13(CmapSubtable):
         charCodes = []
         gids = []
         pos = 0
+        groups = array.array("I", data[: self.nGroups * 12])
+        if sys.byteorder != "big":
+            groups.byteswap()
         for i in range(self.nGroups):
-            startCharCode, endCharCode, glyphID = struct.unpack(
-                ">LLL", data[pos : pos + 12]
-            )
-            pos += 12
+            startCharCode = groups[i * 3]
+            endCharCode = groups[i * 3 + 1]
+            glyphID = groups[i * 3 + 2]
             lenGroup = 1 + endCharCode - startCharCode
-            charCodes.extend(list(range(startCharCode, endCharCode + 1)))
+            charCodes.extend(range(startCharCode, endCharCode + 1))
             gids.extend(self._computeGIDs(glyphID, lenGroup))
         self.data = data = None
         self.cmap = _make_map(self.ttFont, charCodes, gids)
@@ -1299,7 +1312,7 @@ class cmap_format_12(cmap_format_12_or_13):
         cmap_format_12_or_13.__init__(self, format)
 
     def _computeGIDs(self, startingGlyph, numberOfGlyphs):
-        return list(range(startingGlyph, startingGlyph + numberOfGlyphs))
+        return range(startingGlyph, startingGlyph + numberOfGlyphs)
 
     def _IsInSameRun(self, glyphID, lastGlyphID, charCode, lastCharCode):
         return (glyphID == 1 + lastGlyphID) and (charCode == 1 + lastCharCode)

fontTools/ttLib/tables/_c_v_t.py

@@ -21,6 +21,8 @@ class table__c_v_t(DefaultTable.DefaultTable):
         self.values = values
 
     def compile(self, ttFont):
+        if not hasattr(self, "values"):
+            return b""
         values = self.values[:]
         if sys.byteorder != "big":
             values.byteswap()

fontTools/ttLib/tables/_f_p_g_m.py

@@ -20,7 +20,9 @@ class table__f_p_g_m(DefaultTable.DefaultTable):
         self.program = program
 
     def compile(self, ttFont):
-        return self.program.getBytecode()
+        if hasattr(self, "program"):
+            return self.program.getBytecode()
+        return b""
 
     def toXML(self, writer, ttFont):
         self.program.toXML(writer, ttFont)

fontTools/ttLib/tables/_g_l_y_f.py

@@ -134,6 +134,8 @@ class table__g_l_y_f(DefaultTable.DefaultTable):
             glyph.expand(self)
 
     def compile(self, ttFont):
+        optimizeSpeed = ttFont.cfg[ttLib.OPTIMIZE_FONT_SPEED]
+
         self.axisTags = (
             [axis.axisTag for axis in ttFont["fvar"].axes] if "fvar" in ttFont else []
         )
@@ -148,7 +150,12 @@ class table__g_l_y_f(DefaultTable.DefaultTable):
         boundsDone = set()
         for glyphName in self.glyphOrder:
             glyph = self.glyphs[glyphName]
-            glyphData = glyph.compile(self, recalcBBoxes, boundsDone=boundsDone)
+            glyphData = glyph.compile(
+                self,
+                recalcBBoxes,
+                boundsDone=boundsDone,
+                optimizeSize=not optimizeSpeed,
+            )
             if padding > 1:
                 glyphData = pad(glyphData, size=padding)
             locations.append(currentLocation)
@@ -714,7 +721,7 @@ class Glyph(object):
             self.decompileCoordinates(data)
 
     def compile(
-        self, glyfTable, recalcBBoxes=True, *, boundsDone=None, optimizeSize=None
+        self, glyfTable, recalcBBoxes=True, *, boundsDone=None, optimizeSize=True
     ):
         if hasattr(self, "data"):
             if recalcBBoxes:
@@ -732,8 +739,6 @@ class Glyph(object):
         if self.isComposite():
             data = data + self.compileComponents(glyfTable)
         else:
-            if optimizeSize is None:
-                optimizeSize = getattr(glyfTable, "optimizeSize", True)
             data = data + self.compileCoordinates(optimizeSize=optimizeSize)
         return data
 
@@ -1220,7 +1225,7 @@ class Glyph(object):
                 if boundsDone is not None:
                     boundsDone.add(glyphName)
             # empty components shouldn't update the bounds of the parent glyph
-            if g.numberOfContours == 0:
+            if g.yMin == g.yMax and g.xMin == g.xMax:
                 continue
 
             x, y = compo.x, compo.y
@@ -1280,11 +1285,7 @@ class Glyph(object):
                 # however, if the referenced component glyph is another composite, we
                 # must not round here but only at the end, after all the nested
                 # transforms have been applied, or else rounding errors will compound.
-                if (
-                    round is not noRound
-                    and g.numberOfContours > 0
-                    and not compo._hasOnlyIntegerTranslate()
-                ):
+                if round is not noRound and g.numberOfContours > 0:
                     coordinates.toInt(round=round)
                 if hasattr(compo, "firstPt"):
                     # component uses two reference points: we apply the transform _before_

fontTools/ttLib/tables/_g_v_a_r.py

@@ -3,6 +3,7 @@ from functools import partial
 from fontTools.misc import sstruct
 from fontTools.misc.textTools import safeEval
 from fontTools.misc.lazyTools import LazyDict
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED
 from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from . import DefaultTable
 import array
@@ -23,19 +24,24 @@ log = logging.getLogger(__name__)
 # FreeType2 source code for parsing 'gvar':
 # http://git.savannah.gnu.org/cgit/freetype/freetype2.git/tree/src/truetype/ttgxvar.c
 
-GVAR_HEADER_FORMAT = """
+GVAR_HEADER_FORMAT_HEAD = """
 	> # big endian
 	version:			H
 	reserved:			H
 	axisCount:			H
 	sharedTupleCount:		H
 	offsetToSharedTuples:		I
-	glyphCount:			H
+"""
+# In between the HEAD and TAIL lies the glyphCount, which is
+# of different size: 2 bytes for gvar, and 3 bytes for GVAR.
+GVAR_HEADER_FORMAT_TAIL = """
+	> # big endian
 	flags:				H
 	offsetToGlyphVariationData:	I
 """
 
-GVAR_HEADER_SIZE = sstruct.calcsize(GVAR_HEADER_FORMAT)
+GVAR_HEADER_SIZE_HEAD = sstruct.calcsize(GVAR_HEADER_FORMAT_HEAD)
+GVAR_HEADER_SIZE_TAIL = sstruct.calcsize(GVAR_HEADER_FORMAT_TAIL)
 
 
 class table__g_v_a_r(DefaultTable.DefaultTable):
@@ -50,6 +56,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
     """
 
     dependencies = ["fvar", "glyf"]
+    gid_size = 2
 
     def __init__(self, tag=None):
         DefaultTable.DefaultTable.__init__(self, tag)
@@ -57,6 +64,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         self.variations = {}
 
     def compile(self, ttFont):
+
         axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
         sharedTuples = tv.compileSharedTuples(
             axisTags, itertools.chain(*self.variations.values())
@@ -72,28 +80,33 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         offsets.append(offset)
         compiledOffsets, tableFormat = self.compileOffsets_(offsets)
 
+        GVAR_HEADER_SIZE = GVAR_HEADER_SIZE_HEAD + self.gid_size + GVAR_HEADER_SIZE_TAIL
         header = {}
         header["version"] = self.version
         header["reserved"] = self.reserved
         header["axisCount"] = len(axisTags)
         header["sharedTupleCount"] = len(sharedTuples)
         header["offsetToSharedTuples"] = GVAR_HEADER_SIZE + len(compiledOffsets)
-        header["glyphCount"] = len(compiledGlyphs)
         header["flags"] = tableFormat
         header["offsetToGlyphVariationData"] = (
             header["offsetToSharedTuples"] + sharedTupleSize
         )
-        compiledHeader = sstruct.pack(GVAR_HEADER_FORMAT, header)
 
-        result = [compiledHeader, compiledOffsets]
+        result = [
+            sstruct.pack(GVAR_HEADER_FORMAT_HEAD, header),
+            len(compiledGlyphs).to_bytes(self.gid_size, "big"),
+            sstruct.pack(GVAR_HEADER_FORMAT_TAIL, header),
+        ]
+
+        result.append(compiledOffsets)
         result.extend(sharedTuples)
         result.extend(compiledGlyphs)
         return b"".join(result)
 
     def compileGlyphs_(self, ttFont, axisTags, sharedCoordIndices):
+        optimizeSpeed = ttFont.cfg[OPTIMIZE_FONT_SPEED]
         result = []
         glyf = ttFont["glyf"]
-        optimizeSize = getattr(self, "optimizeSize", True)
         for glyphName in ttFont.getGlyphOrder():
             variations = self.variations.get(glyphName, [])
             if not variations:
@@ -102,11 +115,12 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
             pointCountUnused = 0  # pointCount is actually unused by compileGlyph
             result.append(
                 compileGlyph_(
+                    self.gid_size,
                     variations,
                     pointCountUnused,
                     axisTags,
                     sharedCoordIndices,
-                    optimizeSize=optimizeSize,
+                    optimizeSize=not optimizeSpeed,
                 )
             )
         return result
@@ -114,7 +128,19 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
     def decompile(self, data, ttFont):
         axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
         glyphs = ttFont.getGlyphOrder()
-        sstruct.unpack(GVAR_HEADER_FORMAT, data[0:GVAR_HEADER_SIZE], self)
+
+        # Parse the header
+        GVAR_HEADER_SIZE = GVAR_HEADER_SIZE_HEAD + self.gid_size + GVAR_HEADER_SIZE_TAIL
+        sstruct.unpack(GVAR_HEADER_FORMAT_HEAD, data[:GVAR_HEADER_SIZE_HEAD], self)
+        self.glyphCount = int.from_bytes(
+            data[GVAR_HEADER_SIZE_HEAD : GVAR_HEADER_SIZE_HEAD + self.gid_size], "big"
+        )
+        sstruct.unpack(
+            GVAR_HEADER_FORMAT_TAIL,
+            data[GVAR_HEADER_SIZE_HEAD + self.gid_size : GVAR_HEADER_SIZE],
+            self,
+        )
+
         assert len(glyphs) == self.glyphCount
         assert len(axisTags) == self.axisCount
         sharedCoords = tv.decompileSharedTuples(
@@ -144,7 +170,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
                 glyph = glyf[glyphName]
                 numPointsInGlyph = self.getNumPoints_(glyph)
                 return decompileGlyph_(
-                    numPointsInGlyph, sharedCoords, axisTags, gvarData
+                    self.gid_size, numPointsInGlyph, sharedCoords, axisTags, gvarData
                 )
 
             return read_item
@@ -262,23 +288,42 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
 
 
 def compileGlyph_(
-    variations, pointCount, axisTags, sharedCoordIndices, *, optimizeSize=True
+    dataOffsetSize,
+    variations,
+    pointCount,
+    axisTags,
+    sharedCoordIndices,
+    *,
+    optimizeSize=True,
 ):
+    assert dataOffsetSize in (2, 3)
     tupleVariationCount, tuples, data = tv.compileTupleVariationStore(
         variations, pointCount, axisTags, sharedCoordIndices, optimizeSize=optimizeSize
     )
     if tupleVariationCount == 0:
         return b""
-    result = [struct.pack(">HH", tupleVariationCount, 4 + len(tuples)), tuples, data]
-    if (len(tuples) + len(data)) % 2 != 0:
+
+    offsetToData = 2 + dataOffsetSize + len(tuples)
+
+    result = [
+        tupleVariationCount.to_bytes(2, "big"),
+        offsetToData.to_bytes(dataOffsetSize, "big"),
+        tuples,
+        data,
+    ]
+    if (offsetToData + len(data)) % 2 != 0:
         result.append(b"\0")  # padding
     return b"".join(result)
 
 
-def decompileGlyph_(pointCount, sharedTuples, axisTags, data):
-    if len(data) < 4:
+def decompileGlyph_(dataOffsetSize, pointCount, sharedTuples, axisTags, data):
+    assert dataOffsetSize in (2, 3)
+    if len(data) < 2 + dataOffsetSize:
         return []
-    tupleVariationCount, offsetToData = struct.unpack(">HH", data[:4])
+
+    tupleVariationCount = int.from_bytes(data[:2], "big")
+    offsetToData = int.from_bytes(data[2 : 2 + dataOffsetSize], "big")
+
     dataPos = offsetToData
     return tv.decompileTupleVariationStore(
         "gvar",
@@ -287,6 +332,6 @@ def decompileGlyph_(pointCount, sharedTuples, axisTags, data):
         pointCount,
         sharedTuples,
         data,
-        4,
+        2 + dataOffsetSize,
         offsetToData,
     )

fontTools/ttLib/tables/_p_o_s_t.py

@@ -122,13 +122,16 @@ class table__p_o_s_t(DefaultTable.DefaultTable):
             glyphName = psName = self.glyphOrder[i]
             if glyphName == "":
                 glyphName = "glyph%.5d" % i
+
             if glyphName in allNames:
                 # make up a new glyphName that's unique
                 n = allNames[glyphName]
-                while (glyphName + "#" + str(n)) in allNames:
+                # check if the exists in any of the seen names or later ones
+                names = set(allNames.keys()) | set(self.glyphOrder)
+                while (glyphName + "." + str(n)) in names:
                     n += 1
                 allNames[glyphName] = n + 1
-                glyphName = glyphName + "#" + str(n)
+                glyphName = glyphName + "." + str(n)
 
             self.glyphOrder[i] = glyphName
             allNames[glyphName] = 1

fontTools/ttLib/tables/otBase.py

@@ -398,6 +398,7 @@ class OTTableWriter(object):
         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()

fontTools/ttLib/tables/otConverters.py

@@ -10,7 +10,7 @@ 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 getSearchRange
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, getSearchRange
 from .otBase import (
     CountReference,
     FormatSwitchingBaseTable,
@@ -1810,7 +1810,10 @@ class TupleValues:
         return TupleVariation.decompileDeltas_(None, data)[0]
 
     def write(self, writer, font, tableDict, values, repeatIndex=None):
-        return bytes(TupleVariation.compileDeltaValues_(values))
+        optimizeSpeed = font.cfg[OPTIMIZE_FONT_SPEED]
+        return bytes(
+            TupleVariation.compileDeltaValues_(values, optimizeSize=not optimizeSpeed)
+        )
 
     def xmlRead(self, attrs, content, font):
         return safeEval(attrs["value"])

fontTools/ttLib/tables/otTables.py

@@ -11,6 +11,7 @@ from functools import reduce
 from math import radians
 import itertools
 from collections import defaultdict, namedtuple
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED
 from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from fontTools.ttLib.tables.otTraverse import dfs_base_table
 from fontTools.misc.arrayTools import quantizeRect
@@ -236,6 +237,8 @@ class VarComponent:
         return data[i:]
 
     def compile(self, font):
+        optimizeSpeed = font.cfg[OPTIMIZE_FONT_SPEED]
+
         data = []
 
         flags = self.flags
@@ -259,7 +262,8 @@ class VarComponent:
             data.append(_write_uint32var(self.axisIndicesIndex))
             data.append(
                 TupleVariation.compileDeltaValues_(
-                    [fl2fi(v, 14) for v in self.axisValues]
+                    [fl2fi(v, 14) for v in self.axisValues],
+                    optimizeSize=not optimizeSpeed,
                 )
             )
         else: