fonttools 4.56.0__cp312-cp312-musllinux_1_2_aarch64.whl → 4.57.0__cp312-cp312-musllinux_1_2_aarch64.whl

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/_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
 

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
@@ -57,6 +58,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())
@@ -91,9 +93,9 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
         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:
@@ -106,7 +108,7 @@ class table__g_v_a_r(DefaultTable.DefaultTable):
                     pointCountUnused,
                     axisTags,
                     sharedCoordIndices,
-                    optimizeSize=optimizeSize,
+                    optimizeSize=not optimizeSpeed,
                 )
             )
         return result

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:

fontTools/ttLib/ttFont.py

@@ -593,10 +593,8 @@ class TTFont(object):
         # temporary cmap and by the real cmap in case we don't find a unicode
         # cmap.
         numGlyphs = int(self["maxp"].numGlyphs)
-        glyphOrder = [None] * numGlyphs
+        glyphOrder = ["glyph%.5d" % i for i in range(numGlyphs)]
         glyphOrder[0] = ".notdef"
-        for i in range(1, numGlyphs):
-            glyphOrder[i] = "glyph%.5d" % i
         # Set the glyph order, so the cmap parser has something
         # to work with (so we don't get called recursively).
         self.glyphOrder = glyphOrder
@@ -606,7 +604,7 @@ class TTFont(object):
         # this naming table will usually not cover all glyphs in the font.
         # If the font has no Unicode cmap table, reversecmap will be empty.
         if "cmap" in self:
-            reversecmap = self["cmap"].buildReversed()
+            reversecmap = self["cmap"].buildReversedMin()
         else:
             reversecmap = {}
         useCount = {}
@@ -616,7 +614,7 @@ class TTFont(object):
                 # If a font maps both U+0041 LATIN CAPITAL LETTER A and
                 # U+0391 GREEK CAPITAL LETTER ALPHA to the same glyph,
                 # we prefer naming the glyph as "A".
-                glyphName = self._makeGlyphName(min(reversecmap[tempName]))
+                glyphName = self._makeGlyphName(reversecmap[tempName])
                 numUses = useCount[glyphName] = useCount.get(glyphName, 0) + 1
                 if numUses > 1:
                     glyphName = "%s.alt%d" % (glyphName, numUses - 1)

fontTools/ttLib/ttGlyphSet.py

@@ -104,16 +104,6 @@ class _TTGlyphSetGlyf(_TTGlyphSet):
         return _TTGlyphGlyf(self, glyphName, recalcBounds=self.recalcBounds)
 
 
-class _TTGlyphSetGlyf(_TTGlyphSet):
-    def __init__(self, font, location, recalcBounds=True):
-        self.glyfTable = font["glyf"]
-        super().__init__(font, location, self.glyfTable, recalcBounds=recalcBounds)
-        self.gvarTable = font.get("gvar")
-
-    def __getitem__(self, glyphName):
-        return _TTGlyphGlyf(self, glyphName, recalcBounds=self.recalcBounds)
-
-
 class _TTGlyphSetCFF(_TTGlyphSet):
     def __init__(self, font, location):
         tableTag = "CFF2" if "CFF2" in font else "CFF "

fontTools/ttx.py

@@ -101,9 +101,15 @@ Compile options
 --with-zopfli
              Use Zopfli instead of Zlib to compress WOFF. The Python
              extension is available at https://pypi.python.org/pypi/zopfli
+--optimize-font-speed
+             Enable optimizations that prioritize speed over file size.
+             This mainly affects how glyf t able and gvar / VARC tables are
+             compiled. The produced fonts will be larger, but rendering
+             performance will be improved with HarfBuzz and other text
+             layout engines.
 """
 
-from fontTools.ttLib import TTFont, TTLibError
+from fontTools.ttLib import OPTIMIZE_FONT_SPEED, TTFont, TTLibError
 from fontTools.misc.macCreatorType import getMacCreatorAndType
 from fontTools.unicode import setUnicodeData
 from fontTools.misc.textTools import Tag, tostr
@@ -141,6 +147,7 @@ class Options(object):
     recalcTimestamp = None
     flavor = None
     useZopfli = False
+    optimizeFontSpeed = False
 
     def __init__(self, rawOptions, numFiles):
         self.onlyTables = []
@@ -229,6 +236,8 @@ class Options(object):
                 self.flavor = value
             elif option == "--with-zopfli":
                 self.useZopfli = True
+            elif option == "--optimize-font-speed":
+                self.optimizeFontSpeed = True
         if self.verbose and self.quiet:
             raise getopt.GetoptError("-q and -v options are mutually exclusive")
         if self.verbose:
@@ -324,6 +333,8 @@ def ttCompile(input, output, options):
         recalcBBoxes=options.recalcBBoxes,
         recalcTimestamp=options.recalcTimestamp,
     )
+    if options.optimizeFontSpeed:
+        ttf.cfg[OPTIMIZE_FONT_SPEED] = options.optimizeFontSpeed
     ttf.importXML(input)
 
     if options.recalcTimestamp is None and "head" in ttf and input is not sys.stdin:
@@ -386,6 +397,7 @@ def parseOptions(args):
             "version",
             "with-zopfli",
             "newline=",
+            "optimize-font-speed",
         ],
     )
 

fontTools/varLib/__init__.py

@@ -12,13 +12,13 @@ a Glyphs source, eg., using noto-source as an example:
 
     .. code-block:: sh
 
-	$ fontmake -o ttf-interpolatable -g NotoSansArabic-MM.glyphs
+        $ fontmake -o ttf-interpolatable -g NotoSansArabic-MM.glyphs
 
 Then you can make a variable-font this way:
 
     .. code-block:: sh
 
-	$ fonttools varLib master_ufo/NotoSansArabic.designspace
+        $ fonttools varLib master_ufo/NotoSansArabic.designspace
 
 API *will* change in near future.
 """
@@ -479,7 +479,15 @@ def _merge_TTHinting(font, masterModel, master_ttfs):
 
 _MetricsFields = namedtuple(
     "_MetricsFields",
-    ["tableTag", "metricsTag", "sb1", "sb2", "advMapping", "vOrigMapping"],
+    [
+        "tableTag",
+        "metricsTag",
+        "sb1",
+        "sb2",
+        "advMapping",
+        "vOrigMapping",
+        "phantomIndex",
+    ],
 )
 
 HVAR_FIELDS = _MetricsFields(
@@ -489,6 +497,7 @@ HVAR_FIELDS = _MetricsFields(
     sb2="RsbMap",
     advMapping="AdvWidthMap",
     vOrigMapping=None,
+    phantomIndex=0,
 )
 
 VVAR_FIELDS = _MetricsFields(
@@ -498,109 +507,43 @@ VVAR_FIELDS = _MetricsFields(
     sb2="BsbMap",
     advMapping="AdvHeightMap",
     vOrigMapping="VOrgMap",
+    phantomIndex=1,
 )
 
 
 def _add_HVAR(font, masterModel, master_ttfs, axisTags):
-    _add_VHVAR(font, masterModel, master_ttfs, axisTags, HVAR_FIELDS)
+    getAdvanceMetrics = partial(
+        _get_advance_metrics, font, masterModel, master_ttfs, axisTags, HVAR_FIELDS
+    )
+    _add_VHVAR(font, axisTags, HVAR_FIELDS, getAdvanceMetrics)
 
 
 def _add_VVAR(font, masterModel, master_ttfs, axisTags):
-    _add_VHVAR(font, masterModel, master_ttfs, axisTags, VVAR_FIELDS)
+    getAdvanceMetrics = partial(
+        _get_advance_metrics, font, masterModel, master_ttfs, axisTags, VVAR_FIELDS
+    )
+    _add_VHVAR(font, axisTags, VVAR_FIELDS, getAdvanceMetrics)
 
 
-def _add_VHVAR(font, masterModel, master_ttfs, axisTags, tableFields):
+def _add_VHVAR(font, axisTags, tableFields, getAdvanceMetrics):
     tableTag = tableFields.tableTag
     assert tableTag not in font
+    glyphOrder = font.getGlyphOrder()
     log.info("Generating " + tableTag)
     VHVAR = newTable(tableTag)
     tableClass = getattr(ot, tableTag)
     vhvar = VHVAR.table = tableClass()
     vhvar.Version = 0x00010000
 
-    glyphOrder = font.getGlyphOrder()
-
-    # Build list of source font advance widths for each glyph
-    metricsTag = tableFields.metricsTag
-    advMetricses = [m[metricsTag].metrics for m in master_ttfs]
-
-    # Build list of source font vertical origin coords for each glyph
-    if tableTag == "VVAR" and "VORG" in master_ttfs[0]:
-        vOrigMetricses = [m["VORG"].VOriginRecords for m in master_ttfs]
-        defaultYOrigs = [m["VORG"].defaultVertOriginY for m in master_ttfs]
-        vOrigMetricses = list(zip(vOrigMetricses, defaultYOrigs))
-    else:
-        vOrigMetricses = None
-
-    metricsStore, advanceMapping, vOrigMapping = _get_advance_metrics(
-        font,
-        masterModel,
-        master_ttfs,
-        axisTags,
-        glyphOrder,
-        advMetricses,
-        vOrigMetricses,
-    )
+    vhAdvanceDeltasAndSupports, vOrigDeltasAndSupports = getAdvanceMetrics()
 
-    vhvar.VarStore = metricsStore
-    if advanceMapping is None:
-        setattr(vhvar, tableFields.advMapping, None)
+    if vOrigDeltasAndSupports:
+        singleModel = False
     else:
-        setattr(vhvar, tableFields.advMapping, advanceMapping)
-    if vOrigMapping is not None:
-        setattr(vhvar, tableFields.vOrigMapping, vOrigMapping)
-    setattr(vhvar, tableFields.sb1, None)
-    setattr(vhvar, tableFields.sb2, None)
-
-    font[tableTag] = VHVAR
-    return
-
-
-def _get_advance_metrics(
-    font,
-    masterModel,
-    master_ttfs,
-    axisTags,
-    glyphOrder,
-    advMetricses,
-    vOrigMetricses=None,
-):
-    vhAdvanceDeltasAndSupports = {}
-    vOrigDeltasAndSupports = {}
-    # HACK: we treat width 65535 as a sentinel value to signal that a glyph
-    # from a non-default master should not participate in computing {H,V}VAR,
-    # as if it were missing. Allows to variate other glyph-related data independently
-    # from glyph metrics
-    sparse_advance = 0xFFFF
-    for glyph in glyphOrder:
-        vhAdvances = [
-            (
-                metrics[glyph][0]
-                if glyph in metrics and metrics[glyph][0] != sparse_advance
-                else None
-            )
-            for metrics in advMetricses
-        ]
-        vhAdvanceDeltasAndSupports[glyph] = masterModel.getDeltasAndSupports(
-            vhAdvances, round=round
+        singleModel = models.allEqual(
+            id(v[1]) for v in vhAdvanceDeltasAndSupports.values()
         )
 
-    singleModel = models.allEqual(id(v[1]) for v in vhAdvanceDeltasAndSupports.values())
-
-    if vOrigMetricses:
-        singleModel = False
-        for glyph in glyphOrder:
-            # We need to supply a vOrigs tuple with non-None default values
-            # for each glyph. vOrigMetricses contains values only for those
-            # glyphs which have a non-default vOrig.
-            vOrigs = [
-                metrics[glyph] if glyph in metrics else defaultVOrig
-                for metrics, defaultVOrig in vOrigMetricses
-            ]
-            vOrigDeltasAndSupports[glyph] = masterModel.getDeltasAndSupports(
-                vOrigs, round=round
-            )
-
     directStore = None
     if singleModel:
         # Build direct mapping
@@ -621,7 +564,7 @@ def _get_advance_metrics(
         storeBuilder.setSupports(supports)
         advMapping[glyphName] = storeBuilder.storeDeltas(deltas, round=noRound)
 
-    if vOrigMetricses:
+    if vOrigDeltasAndSupports:
         vOrigMap = {}
         for glyphName in glyphOrder:
             deltas, supports = vOrigDeltasAndSupports[glyphName]
@@ -633,7 +576,7 @@ def _get_advance_metrics(
     advMapping = [mapping2[advMapping[g]] for g in glyphOrder]
     advanceMapping = builder.buildVarIdxMap(advMapping, glyphOrder)
 
-    if vOrigMetricses:
+    if vOrigDeltasAndSupports:
         vOrigMap = [mapping2[vOrigMap[g]] for g in glyphOrder]
 
     useDirect = False
@@ -657,10 +600,70 @@ def _get_advance_metrics(
         advanceMapping = None
     else:
         metricsStore = indirectStore
-        if vOrigMetricses:
+        if vOrigDeltasAndSupports:
             vOrigMapping = builder.buildVarIdxMap(vOrigMap, glyphOrder)
 
-    return metricsStore, advanceMapping, vOrigMapping
+    vhvar.VarStore = metricsStore
+    setattr(vhvar, tableFields.advMapping, advanceMapping)
+    if vOrigMapping is not None:
+        setattr(vhvar, tableFields.vOrigMapping, vOrigMapping)
+    setattr(vhvar, tableFields.sb1, None)
+    setattr(vhvar, tableFields.sb2, None)
+
+    font[tableTag] = VHVAR
+    return
+
+
+def _get_advance_metrics(font, masterModel, master_ttfs, axisTags, tableFields):
+    tableTag = tableFields.tableTag
+    glyphOrder = font.getGlyphOrder()
+
+    # Build list of source font advance widths for each glyph
+    metricsTag = tableFields.metricsTag
+    advMetricses = [m[metricsTag].metrics for m in master_ttfs]
+
+    # Build list of source font vertical origin coords for each glyph
+    if tableTag == "VVAR" and "VORG" in master_ttfs[0]:
+        vOrigMetricses = [m["VORG"].VOriginRecords for m in master_ttfs]
+        defaultYOrigs = [m["VORG"].defaultVertOriginY for m in master_ttfs]
+        vOrigMetricses = list(zip(vOrigMetricses, defaultYOrigs))
+    else:
+        vOrigMetricses = None
+
+    vhAdvanceDeltasAndSupports = {}
+    vOrigDeltasAndSupports = {}
+    # HACK: we treat width 65535 as a sentinel value to signal that a glyph
+    # from a non-default master should not participate in computing {H,V}VAR,
+    # as if it were missing. Allows to variate other glyph-related data independently
+    # from glyph metrics
+    sparse_advance = 0xFFFF
+    for glyph in glyphOrder:
+        vhAdvances = [
+            (
+                metrics[glyph][0]
+                if glyph in metrics and metrics[glyph][0] != sparse_advance
+                else None
+            )
+            for metrics in advMetricses
+        ]
+        vhAdvanceDeltasAndSupports[glyph] = masterModel.getDeltasAndSupports(
+            vhAdvances, round=round
+        )
+
+    if vOrigMetricses:
+        for glyph in glyphOrder:
+            # We need to supply a vOrigs tuple with non-None default values
+            # for each glyph. vOrigMetricses contains values only for those
+            # glyphs which have a non-default vOrig.
+            vOrigs = [
+                metrics[glyph] if glyph in metrics else defaultVOrig
+                for metrics, defaultVOrig in vOrigMetricses
+            ]
+            vOrigDeltasAndSupports[glyph] = masterModel.getDeltasAndSupports(
+                vOrigs, round=round
+            )
+
+    return vhAdvanceDeltasAndSupports, vOrigDeltasAndSupports
 
 
 def _add_MVAR(font, masterModel, master_ttfs, axisTags):

fontTools/varLib/hvar.py

@@ -0,0 +1,113 @@
+from fontTools.misc.roundTools import noRound
+from fontTools.ttLib import TTFont, newTable
+from fontTools.ttLib.tables import otTables as ot
+from fontTools.ttLib.tables.otBase import OTTableWriter
+from fontTools.varLib import HVAR_FIELDS, VVAR_FIELDS, _add_VHVAR
+from fontTools.varLib import builder, models, varStore
+from fontTools.misc.fixedTools import fixedToFloat as fi2fl
+from fontTools.misc.cliTools import makeOutputFileName
+from functools import partial
+import logging
+
+log = logging.getLogger("fontTools.varLib.avar")
+
+
+def _get_advance_metrics(font, axisTags, tableFields):
+    # There's two ways we can go from here:
+    # 1. For each glyph, at each master peak, compute the value of the
+    #    advance width at that peak.  Then pass these all to a VariationModel
+    #    builder to compute back the deltas.
+    # 2. For each master peak, pull out the deltas of the advance width directly,
+    #    and feed these to the VarStoreBuilder, forgoing the remoding step.
+    # We'll go with the second option, as it's simpler, faster, and more direct.
+    gvar = font["gvar"]
+    vhAdvanceDeltasAndSupports = {}
+    glyphOrder = font.getGlyphOrder()
+    phantomIndex = tableFields.phantomIndex
+    for glyphName in glyphOrder:
+        supports = []
+        deltas = []
+        variations = gvar.variations.get(glyphName, [])
+
+        for tv in variations:
+            supports.append(tv.axes)
+            phantoms = tv.coordinates[-4:]
+            phantoms = phantoms[phantomIndex * 2 : phantomIndex * 2 + 2]
+            assert len(phantoms) == 2
+            phantoms[0] = phantoms[0][phantomIndex] if phantoms[0] is not None else 0
+            phantoms[1] = phantoms[1][phantomIndex] if phantoms[1] is not None else 0
+            deltas.append(phantoms[1] - phantoms[0])
+
+        vhAdvanceDeltasAndSupports[glyphName] = (deltas, supports)
+
+    vOrigDeltasAndSupports = None  # TODO
+
+    return vhAdvanceDeltasAndSupports, vOrigDeltasAndSupports
+
+
+def add_HVAR(font):
+    if "HVAR" in font:
+        del font["HVAR"]
+    axisTags = [axis.axisTag for axis in font["fvar"].axes]
+    getAdvanceMetrics = partial(_get_advance_metrics, font, axisTags, HVAR_FIELDS)
+    _add_VHVAR(font, axisTags, HVAR_FIELDS, getAdvanceMetrics)
+
+
+def add_VVAR(font):
+    if "VVAR" in font:
+        del font["VVAR"]
+    getAdvanceMetrics = partial(_get_advance_metrics, font, axisTags, HVAR_FIELDS)
+    axisTags = [axis.axisTag for axis in font["fvar"].axes]
+    _add_VHVAR(font, axisTags, VVAR_FIELDS, getAdvanceMetrics)
+
+
+def main(args=None):
+    """Add `HVAR` table to variable font."""
+
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    from fontTools import configLogger
+    from fontTools.designspaceLib import DesignSpaceDocument
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools varLib.hvar",
+        description="Add `HVAR` table from to variable font.",
+    )
+    parser.add_argument("font", metavar="varfont.ttf", help="Variable-font file.")
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        type=str,
+        help="Output font file name.",
+    )
+
+    options = parser.parse_args(args)
+
+    configLogger(level="WARNING")
+
+    font = TTFont(options.font)
+    if not "fvar" in font:
+        log.error("Not a variable font.")
+        return 1
+
+    add_HVAR(font)
+    if "vmtx" in font:
+        add_VVAR(font)
+
+    if options.output_file is None:
+        outfile = makeOutputFileName(options.font, overWrite=True, suffix=".hvar")
+    else:
+        outfile = options.output_file
+    if outfile:
+        log.info("Saving %s", outfile)
+        font.save(outfile)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

fontTools/varLib/iup.c

@@ -1,4 +1,4 @@
-/* Generated by Cython 3.0.11 */
+/* Generated by Cython 3.0.12 */
 
 /* BEGIN: Cython Metadata
 {
@@ -36,10 +36,10 @@ END: Cython Metadata */
 #else
 #define __PYX_EXTRA_ABI_MODULE_NAME ""
 #endif
-#define CYTHON_ABI "3_0_11" __PYX_EXTRA_ABI_MODULE_NAME
+#define CYTHON_ABI "3_0_12" __PYX_EXTRA_ABI_MODULE_NAME
 #define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI
 #define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "."
-#define CYTHON_HEX_VERSION 0x03000BF0
+#define CYTHON_HEX_VERSION 0x03000CF0
 #define CYTHON_FUTURE_DIVISION 1
 #include <stddef.h>
 #ifndef offsetof
@@ -1972,7 +1972,7 @@ static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args,
 #if !CYTHON_VECTORCALL
 #if PY_VERSION_HEX >= 0x03080000
   #include "frameobject.h"
-#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION)
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
@@ -16524,7 +16524,7 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) {
 #include "compile.h"
 #include "frameobject.h"
 #include "traceback.h"
-#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION)
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif
@@ -17714,7 +17714,7 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name
 
 /* CoroutineBase */
 #include <frameobject.h>
-#if PY_VERSION_HEX >= 0x030b00a6
+#if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION)
   #ifndef Py_BUILD_CORE
     #define Py_BUILD_CORE 1
   #endif