fonttools 4.55.8__cp39-cp39-musllinux_1_2_aarch64.whl → 4.57.0__cp39-cp39-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/otData.py

@@ -385,7 +385,7 @@ otData = [
             (
                 "DeltaValue",
                 "DeltaValue",
-                "",
+                None,
                 "DeltaFormat in (1,2,3)",
                 "Array of compressed data",
             ),

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:
@@ -2226,24 +2230,28 @@ _equivalents = {
 def fixLookupOverFlows(ttf, overflowRecord):
     """Either the offset from the LookupList to a lookup overflowed, or
     an offset from a lookup to a subtable overflowed.
-    The table layout is:
-    GPSO/GUSB
-            Script List
-            Feature List
-            LookUpList
-                    Lookup[0] and contents
-                            SubTable offset list
-                                    SubTable[0] and contents
-                                    ...
-                                    SubTable[n] and contents
-                    ...
-                    Lookup[n] and contents
-                            SubTable offset list
-                                    SubTable[0] and contents
-                                    ...
-                                    SubTable[n] and contents
+
+    The table layout is::
+
+      GPSO/GUSB
+              Script List
+              Feature List
+              LookUpList
+                      Lookup[0] and contents
+                              SubTable offset list
+                                      SubTable[0] and contents
+                                      ...
+                                      SubTable[n] and contents
+                      ...
+                      Lookup[n] and contents
+                              SubTable offset list
+                                      SubTable[0] and contents
+                                      ...
+                                      SubTable[n] and contents
+
     If the offset to a lookup overflowed (SubTableIndex is None)
-            we must promote the *previous*	lookup to an Extension type.
+            we must promote the *previous* lookup to an Extension type.
+
     If the offset from a lookup to subtable overflowed, then we must promote it
             to an Extension Lookup type.
     """

fontTools/ttLib/tables/otTraverse.py

@@ -79,7 +79,8 @@ def bfs_base_table(
     """Breadth-first search tree of BaseTables.
 
     Args:
-    the root of the tree.
+        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

fontTools/ttLib/ttFont.py

@@ -27,6 +27,7 @@ class TTFont(object):
     they're actually accessed. This means that simple operations can be extremely fast.
 
     Example usage:
+
     .. code-block:: pycon
 
         >>>
@@ -39,8 +40,10 @@ class TTFont(object):
         >> tt['head'].unitsPerEm
         2048
 
-    For details of the objects returned when accessing each table, see :ref:`tables`.
+    For details of the objects returned when accessing each table, see the
+    :doc:`tables </ttLib/tables>` documentation.
     To add a table to the font, use the :py:func:`newTable` function:
+
     .. code-block:: pycon
 
         >>>
@@ -50,7 +53,8 @@ class TTFont(object):
         >> font["OS/2"] = os2
 
     TrueType fonts can also be serialized to and from XML format (see also the
-    :ref:`ttx` binary):
+    :doc:`ttx </ttx>` binary):
+
     .. code-block:: pycon
 
         >>
@@ -589,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
@@ -602,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 = {}
@@ -612,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.
 """
@@ -325,7 +325,6 @@ def _add_gvar(font, masterModel, master_ttfs, tolerance=0.5, optimize=True):
 
     for glyph in font.getGlyphOrder():
         log.debug("building gvar for glyph '%s'", glyph)
-        isComposite = glyf[glyph].isComposite()
 
         allData = [
             m.glyf._getCoordinatesAndControls(glyph, m.hMetrics, m.vMetrics)
@@ -363,7 +362,7 @@ def _add_gvar(font, masterModel, master_ttfs, tolerance=0.5, optimize=True):
         endPts = control.endPts
 
         for i, (delta, support) in enumerate(zip(deltas[1:], supports[1:])):
-            if all(v == 0 for v in delta.array) and not isComposite:
+            if all(v == 0 for v in delta.array):
                 continue
             var = TupleVariation(support, delta)
             if optimize:
@@ -372,16 +371,6 @@ def _add_gvar(font, masterModel, master_ttfs, tolerance=0.5, optimize=True):
                 )
 
                 if None in delta_opt:
-                    """In composite glyphs, there should be one 0 entry
-                    to make sure the gvar entry is written to the font.
-
-                    This is to work around an issue with macOS 10.14 and can be
-                    removed once the behaviour of macOS is changed.
-
-                    https://github.com/fonttools/fonttools/issues/1381
-                    """
-                    if all(d is None for d in delta_opt):
-                        delta_opt = [(0, 0)] + [None] * (len(delta_opt) - 1)
                     # Use "optimized" version only if smaller...
                     var_opt = TupleVariation(support, delta_opt)
 
@@ -490,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(
@@ -500,6 +497,7 @@ HVAR_FIELDS = _MetricsFields(
     sb2="RsbMap",
     advMapping="AdvWidthMap",
     vOrigMapping=None,
+    phantomIndex=0,
 )
 
 VVAR_FIELDS = _MetricsFields(
@@ -509,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
@@ -632,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]
@@ -644,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
@@ -668,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):