# Source code for fontTools.varLib.instancer

    """ Partially instantiate a variable font.

    The module exports an `instantiateVariableFont` function and CLI that allow to
    create full instances (i.e. static fonts) from variable fonts, as well as "partial"
    variable fonts that only contain a subset of the original variation space.

    For example, if you wish to pin the width axis to a given location while also
    restricting the weight axis to 400..700 range, you can do:

    .. code-block:: sh

        $ fonttools varLib.instancer ./NotoSans-VF.ttf wdth=85 wght=400:700

    See `fonttools varLib.instancer --help` for more info on the CLI options.

    The module's entry point is the `instantiateVariableFont` function, which takes
    a TTFont object and a dict specifying either axis coodinates or (min, max) ranges,
    and returns a new TTFont representing either a partial VF, or full instance if all
    the VF axes were given an explicit coordinate.

    E.g. here's how to pin the wght axis at a given location in a wght+wdth variable
    font, keeping only the deltas associated with the wdth axis:
    .. code-block:: pycon

        >>>
        >> from fontTools import ttLib
        >> from fontTools.varLib import instancer
        >> varfont = ttLib.TTFont("path/to/MyVariableFont.ttf")
        >> [a.axisTag for a in varfont["fvar"].axes]  # the varfont's current axes
        ['wght', 'wdth']
        >> partial = instancer.instantiateVariableFont(varfont, {"wght": 300})
        >> [a.axisTag for a in partial["fvar"].axes]  # axes left after pinning 'wght'
        ['wdth']

    If the input location specifies all the axes, the resulting instance is no longer
    'variable' (same as using fontools varLib.mutator):
    .. code-block:: pycon

        >>>
        >> instance = instancer.instantiateVariableFont(
        ...     varfont, {"wght": 700, "wdth": 67.5}
        ... )
        >> "fvar" not in instance
        True

    If one just want to drop an axis at the default location, without knowing in
    advance what the default value for that axis is, one can pass a `None` value:
    .. code-block:: pycon

        >>>
        >> instance = instancer.instantiateVariableFont(varfont, {"wght": None})
        >> len(varfont["fvar"].axes)
        1

    From the console script, this is equivalent to passing `wght=drop` as input.

    This module is similar to fontTools.varLib.mutator, which it's intended to supersede.
    Note that, unlike varLib.mutator, when an axis is not mentioned in the input
    location, the varLib.instancer will keep the axis and the corresponding deltas,
    whereas mutator implicitly drops the axis at its default coordinate.

    The module supports all the following "levels" of instancing, which can of
    course be combined:

    L1
        dropping one or more axes while leaving the default tables unmodified;
        .. code-block:: pycon

            >>>
            >> font = instancer.instantiateVariableFont(varfont, {"wght": None})

    L2
        dropping one or more axes while pinning them at non-default locations;
        .. code-block:: pycon

            >>>
            >> font = instancer.instantiateVariableFont(varfont, {"wght": 700})

    L3
        restricting the range of variation of one or more axes, by setting either
        a new minimum or maximum, potentially -- though not necessarily -- dropping
        entire regions of variations that fall completely outside this new range.
        .. code-block:: pycon

            >>>
            >> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300)})

    L4
        moving the default location of an axis, by specifying (min,defalt,max) values:
        .. code-block:: pycon

            >>>
            >> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300, 700)})

    Currently only TrueType-flavored variable fonts (i.e. containing 'glyf' table)
    are supported, but support for CFF2 variable fonts will be added soon.

    The discussion and implementation of these features are tracked at
    https://github.com/fonttools/fonttools/issues/1537
    """

    from fontTools.misc.fixedTools import (
        floatToFixedToFloat,
        strToFixedToFloat,
        otRound,
    )
    from fontTools.varLib.models import normalizeValue, piecewiseLinearMap
    from fontTools.ttLib import TTFont, newTable
    from fontTools.ttLib.tables.TupleVariation import TupleVariation
    from fontTools.ttLib.tables import _g_l_y_f
    from fontTools import varLib

    # we import the `subset` module because we use the `prune_lookups` method on the GSUB
    # table class, and that method is only defined dynamically upon importing `subset`
    from fontTools import subset  # noqa: F401
    from fontTools.cffLib import privateDictOperators2
    from fontTools.cffLib.specializer import (
        programToCommands,
        commandsToProgram,
        specializeCommands,
        generalizeCommands,
    )
    from fontTools.varLib import builder
    from fontTools.varLib.mvar import MVAR_ENTRIES
    from fontTools.varLib.merger import MutatorMerger
    from fontTools.varLib.instancer import names
    from .featureVars import instantiateFeatureVariations
    from fontTools.misc.cliTools import makeOutputFileName
    from fontTools.varLib.instancer import solver
    from fontTools.ttLib.tables.otTables import VarComponentFlags
    import collections
    import dataclasses
    from contextlib import contextmanager
    from copy import deepcopy
    from enum import IntEnum
    import logging
    import os
    import re
    from typing import Dict, Iterable, Mapping, Optional, Sequence, Tuple, Union
    import warnings

    log = logging.getLogger("fontTools.varLib.instancer")

    def AxisRange(minimum, maximum):
        warnings.warn(
            "AxisRange is deprecated; use AxisTriple instead",
            DeprecationWarning,
            stacklevel=2,
        )
        return AxisTriple(minimum, None, maximum)

    def NormalizedAxisRange(minimum, maximum):
        warnings.warn(
            "NormalizedAxisRange is deprecated; use AxisTriple instead",
            DeprecationWarning,
            stacklevel=2,
        )
        return NormalizedAxisTriple(minimum, None, maximum)

    @dataclasses.dataclass(frozen=True, order=True, repr=False)
    class AxisTriple(Sequence):
        """A triple of (min, default, max) axis values.

        Any of the values can be None, in which case the limitRangeAndPopulateDefaults()
        method can be used to fill in the missing values based on the fvar axis values.
        """

        minimum: Optional[float]
        default: Optional[float]
        maximum: Optional[float]

        def __post_init__(self):
            if self.default is None and self.minimum == self.maximum:
                object.__setattr__(self, "default", self.minimum)
            if (
                (
                    self.minimum is not None
                    and self.default is not None
                    and self.minimum > self.default
                )
                or (
                    self.default is not None
                    and self.maximum is not None
                    and self.default > self.maximum
                )
                or (
                    self.minimum is not None
                    and self.maximum is not None
                    and self.minimum > self.maximum
                )
            ):
                raise ValueError(
                    f"{type(self).__name__} minimum ({self.minimum}), default ({self.default}), maximum ({self.maximum}) must be in sorted order"
                )

        def __getitem__(self, i):
            fields = dataclasses.fields(self)
            return getattr(self, fields[i].name)

        def __len__(self):
            return len(dataclasses.fields(self))

        def _replace(self, **kwargs):
            return dataclasses.replace(self, **kwargs)

        def __repr__(self):
            return (
                f"({', '.join(format(v, 'g') if v is not None else 'None' for v in self)})"
            )

        @classmethod
        def expand(
            cls,
            v: Union[
                "AxisTriple",
                float,  # pin axis at single value, same as min==default==max
                Tuple[float, float],  # (min, max), restrict axis and keep default
                Tuple[float, float, float],  # (min, default, max)
            ],
        ) -> "AxisTriple":
            """Convert a single value or a tuple into an AxisTriple.

            If the input is a single value, it is interpreted as a pin at that value.
            If the input is a tuple, it is interpreted as (min, max) or (min, default, max).
            """
            if isinstance(v, cls):
                return v
            if isinstance(v, (int, float)):
                return cls(v, v, v)
            try:
                n = len(v)
            except TypeError as e:
                raise ValueError(
                    f"expected float, 2- or 3-tuple of floats; got {type(v)}: {v!r}"
                ) from e
            default = None
            if n == 2:
                minimum, maximum = v
            elif n >= 3:
                return cls(*v)
            else:
                raise ValueError(f"expected sequence of 2 or 3; got {n}: {v!r}")
            return cls(minimum, default, maximum)

        def limitRangeAndPopulateDefaults(self, fvarTriple) -> "AxisTriple":
            """Return a new AxisTriple with the default value filled in.

            Set default to fvar axis default if the latter is within the min/max range,
            otherwise set default to the min or max value, whichever is closer to the
            fvar axis default.
            If the default value is already set, return self.
            """
            minimum = self.minimum
            if minimum is None:
                minimum = fvarTriple[0]
            default = self.default
            if default is None:
                default = fvarTriple[1]
            maximum = self.maximum
            if maximum is None:
                maximum = fvarTriple[2]

            minimum = max(minimum, fvarTriple[0])
            maximum = max(maximum, fvarTriple[0])
            minimum = min(minimum, fvarTriple[2])
            maximum = min(maximum, fvarTriple[2])
            default = max(minimum, min(maximum, default))

            return AxisTriple(minimum, default, maximum)

    @dataclasses.dataclass(frozen=True, order=True, repr=False)
    class NormalizedAxisTriple(AxisTriple):
        """A triple of (min, default, max) normalized axis values."""

        minimum: float
        default: float
        maximum: float

        def __post_init__(self):
            if self.default is None:
                object.__setattr__(self, "default", max(self.minimum, min(self.maximum, 0)))
            if not (-1.0 <= self.minimum <= self.default <= self.maximum <= 1.0):
                raise ValueError(
                    "Normalized axis values not in -1..+1 range; got "
                    f"minimum={self.minimum:g}, default={self.default:g}, maximum={self.maximum:g})"
                )

    @dataclasses.dataclass(frozen=True, order=True, repr=False)
    class NormalizedAxisTripleAndDistances(AxisTriple):
        """A triple of (min, default, max) normalized axis values,
        with distances between min and default, and default and max,
        in the *pre-normalized* space."""

        minimum: float
        default: float
        maximum: float
        distanceNegative: Optional[float] = 1
        distancePositive: Optional[float] = 1

        def __post_init__(self):
            if self.default is None:
                object.__setattr__(self, "default", max(self.minimum, min(self.maximum, 0)))
            if not (-1.0 <= self.minimum <= self.default <= self.maximum <= 1.0):
                raise ValueError(
                    "Normalized axis values not in -1..+1 range; got "
                    f"minimum={self.minimum:g}, default={self.default:g}, maximum={self.maximum:g})"
                )

        def reverse_negate(self):
            v = self
            return self.__class__(-v[2], -v[1], -v[0], v[4], v[3])

        def renormalizeValue(self, v, extrapolate=True):
            """Renormalizes a normalized value v to the range of this axis,
            considering the pre-normalized distances as well as the new
            axis limits."""

            lower, default, upper, distanceNegative, distancePositive = self
            assert lower <= default <= upper

            if not extrapolate:
                v = max(lower, min(upper, v))

            if v == default:
                return 0

            if default < 0:
                return -self.reverse_negate().renormalizeValue(-v, extrapolate=extrapolate)

            # default >= 0 and v != default

            if v > default:
                return (v - default) / (upper - default)

            # v < default

            if lower >= 0:
                return (v - default) / (default - lower)

            # lower < 0 and v < default

            totalDistance = distanceNegative * -lower + distancePositive * default

            if v >= 0:
                vDistance = (default - v) * distancePositive
            else:
                vDistance = -v * distanceNegative + distancePositive * default

            return -vDistance / totalDistance

    class _BaseAxisLimits(Mapping[str, AxisTriple]):
        def __getitem__(self, key: str) -> AxisTriple:
            return self._data[key]

        def __iter__(self) -> Iterable[str]:
            return iter(self._data)

        def __len__(self) -> int:
            return len(self._data)

        def __repr__(self) -> str:
            return f"{type(self).__name__}({self._data!r})"

        def __str__(self) -> str:
            return str(self._data)

        def defaultLocation(self) -> Dict[str, float]:
            """Return a dict of default axis values."""
            return {k: v.default for k, v in self.items()}

        def pinnedLocation(self) -> Dict[str, float]:
            """Return a location dict with only the pinned axes."""
            return {k: v.default for k, v in self.items() if v.minimum == v.maximum}

    class AxisLimits(_BaseAxisLimits):
        """Maps axis tags (str) to AxisTriple values."""

        def __init__(self, *args, **kwargs):
            self._data = data = {}
            for k, v in dict(*args, **kwargs).items():
                if v is None:
                    # will be filled in by limitAxesAndPopulateDefaults
                    data[k] = v
                else:
                    try:
                        triple = AxisTriple.expand(v)
                    except ValueError as e:
                        raise ValueError(f"Invalid axis limits for {k!r}: {v!r}") from e
                    data[k] = triple

        def limitAxesAndPopulateDefaults(self, varfont) -> "AxisLimits":
            """Return a new AxisLimits with defaults filled in from fvar table.

            If all axis limits already have defaults, return self.
            """
            fvar = varfont["fvar"]
            fvarTriples = {
                a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in fvar.axes
            }
            newLimits = {}
            for axisTag, triple in self.items():
                fvarTriple = fvarTriples[axisTag]
                default = fvarTriple[1]
                if triple is None:
                    newLimits[axisTag] = AxisTriple(default, default, default)
                else:
                    newLimits[axisTag] = triple.limitRangeAndPopulateDefaults(fvarTriple)
            return type(self)(newLimits)

        def normalize(self, varfont, usingAvar=True) -> "NormalizedAxisLimits":
            """Return a new NormalizedAxisLimits with normalized -1..0..+1 values.

            If usingAvar is True, the avar table is used to warp the default normalization.
            """
            fvar = varfont["fvar"]
            badLimits = set(self.keys()).difference(a.axisTag for a in fvar.axes)
            if badLimits:
                raise ValueError("Cannot limit: {} not present in fvar".format(badLimits))

            axes = {
                a.axisTag: (a.minValue, a.defaultValue, a.maxValue)
                for a in fvar.axes
                if a.axisTag in self
            }

            avarSegments = {}
            if usingAvar and "avar" in varfont:
                avarSegments = varfont["avar"].segments

            normalizedLimits = {}

            for axis_tag, triple in axes.items():
                distanceNegative = triple[1] - triple[0]
                distancePositive = triple[2] - triple[1]

                if self[axis_tag] is None:
                    normalizedLimits[axis_tag] = NormalizedAxisTripleAndDistances(
                        0, 0, 0, distanceNegative, distancePositive
                    )
                    continue

                minV, defaultV, maxV = self[axis_tag]

                if defaultV is None:
                    defaultV = triple[1]

                avarMapping = avarSegments.get(axis_tag, None)
                normalizedLimits[axis_tag] = NormalizedAxisTripleAndDistances(
                    *(normalize(v, triple, avarMapping) for v in (minV, defaultV, maxV)),
                    distanceNegative,
                    distancePositive,
                )

            return NormalizedAxisLimits(normalizedLimits)

    class NormalizedAxisLimits(_BaseAxisLimits):
        """Maps axis tags (str) to NormalizedAxisTriple values."""

        def __init__(self, *args, **kwargs):
            self._data = data = {}
            for k, v in dict(*args, **kwargs).items():
                try:
                    triple = NormalizedAxisTripleAndDistances.expand(v)
                except ValueError as e:
                    raise ValueError(f"Invalid axis limits for {k!r}: {v!r}") from e
                data[k] = triple

    class OverlapMode(IntEnum):
        KEEP_AND_DONT_SET_FLAGS = 0
        KEEP_AND_SET_FLAGS = 1
        REMOVE = 2
        REMOVE_AND_IGNORE_ERRORS = 3

    def instantiateVARC(varfont, axisLimits):
        log.info("Instantiating VARC tables")

        # TODO(behdad) My confidence in this function is rather low;
        # It needs more testing. Specially with partial-instancing,
        # I don't think it currently works.

        varc = varfont["VARC"].table
        fvarAxes = varfont["fvar"].axes if "fvar" in varfont else []

        location = axisLimits.pinnedLocation()
        axisMap = [i for i, axis in enumerate(fvarAxes) if axis.axisTag not in location]
        reverseAxisMap = {i: j for j, i in enumerate(axisMap)}

        if varc.AxisIndicesList:
            axisIndicesList = varc.AxisIndicesList.Item
            for i, axisIndices in enumerate(axisIndicesList):
                if any(fvarAxes[j].axisTag in axisLimits for j in axisIndices):
                    raise NotImplementedError(
                        "Instancing across VarComponent axes is not supported."
                    )
                axisIndicesList[i] = [reverseAxisMap[j] for j in axisIndices]

        store = varc.MultiVarStore
        if store:
            for region in store.SparseVarRegionList.Region:
                newRegionAxis = []
                for regionRecord in region.SparseVarRegionAxis:
                    tag = fvarAxes[regionRecord.AxisIndex].axisTag
                    if tag in axisLimits:
                        raise NotImplementedError(
                            "Instancing across VarComponent axes is not supported."
                        )
                    regionRecord.AxisIndex = reverseAxisMap[regionRecord.AxisIndex]

    def instantiateTupleVariationStore(
        variations, axisLimits, origCoords=None, endPts=None
    ):
        """Instantiate TupleVariation list at the given location, or limit axes' min/max.

        The 'variations' list of TupleVariation objects is modified in-place.
        The 'axisLimits' (dict) maps axis tags (str) to NormalizedAxisTriple namedtuples
        specifying (minimum, default, maximum) in the -1,0,+1 normalized space. Pinned axes
        have minimum == default == maximum.

        A 'full' instance (i.e. static font) is produced when all the axes are pinned to
        single coordinates; a 'partial' instance (i.e. a less variable font) is produced
        when some of the axes are omitted, or restricted with a new range.

        Tuples that do not participate are kept as they are. Those that have 0 influence
        at the given location are removed from the variation store.
        Those that are fully instantiated (i.e. all their axes are being pinned) are also
        removed from the variation store, their scaled deltas accummulated and returned, so
        that they can be added by the caller to the default instance's coordinates.
        Tuples that are only partially instantiated (i.e. not all the axes that they
        participate in are being pinned) are kept in the store, and their deltas multiplied
        by the scalar support of the axes to be pinned at the desired location.

        Args:
            variations: List[TupleVariation] from either 'gvar' or 'cvar'.
            axisLimits: NormalizedAxisLimits: map from axis tags to (min, default, max)
                normalized coordinates for the full or partial instance.
            origCoords: GlyphCoordinates: default instance's coordinates for computing 'gvar'
                inferred points (cf. table__g_l_y_f._getCoordinatesAndControls).
            endPts: List[int]: indices of contour end points, for inferring 'gvar' deltas.

        Returns:
            List[float]: the overall delta adjustment after applicable deltas were summed.
        """

        newVariations = changeTupleVariationsAxisLimits(variations, axisLimits)

        mergedVariations = collections.OrderedDict()
        for var in newVariations:
            # compute inferred deltas only for gvar ('origCoords' is None for cvar)
            if origCoords is not None:
                var.calcInferredDeltas(origCoords, endPts)

            # merge TupleVariations with overlapping "tents"
            axes = frozenset(var.axes.items())
            if axes in mergedVariations:
                mergedVariations[axes] += var
            else:
                mergedVariations[axes] = var

        # drop TupleVariation if all axes have been pinned (var.axes.items() is empty);
        # its deltas will be added to the default instance's coordinates
        defaultVar = mergedVariations.pop(frozenset(), None)

        for var in mergedVariations.values():
            var.roundDeltas()
        variations[:] = list(mergedVariations.values())

        return defaultVar.coordinates if defaultVar is not None else []

    def changeTupleVariationsAxisLimits(variations, axisLimits):
        for axisTag, axisLimit in sorted(axisLimits.items()):
            newVariations = []
            for var in variations:
                newVariations.extend(changeTupleVariationAxisLimit(var, axisTag, axisLimit))
            variations = newVariations
        return variations

    def changeTupleVariationAxisLimit(var, axisTag, axisLimit):
        assert isinstance(axisLimit, NormalizedAxisTripleAndDistances)

        # Skip when current axis is missing or peaks at 0 (i.e. doesn't participate)
        lower, peak, upper = var.axes.get(axisTag, (-1, 0, 1))
        if peak == 0:
            # explicitly defined, no-op axes can be omitted
            # https://github.com/fonttools/fonttools/issues/3453
            if axisTag in var.axes:
                del var.axes[axisTag]
            return [var]
        # Drop if the var 'tent' isn't well-formed
        if not (lower <= peak <= upper) or (lower < 0 and upper > 0):
            return []

        if axisTag not in var.axes:
            return [var]

        tent = var.axes[axisTag]

        solutions = solver.rebaseTent(tent, axisLimit)

        out = []
        for scalar, tent in solutions:
            newVar = (
                TupleVariation(var.axes, var.coordinates) if len(solutions) > 1 else var
            )
            if tent is None:
                newVar.axes.pop(axisTag)
            else:
                assert tent[1] != 0, tent
                newVar.axes[axisTag] = tent
            newVar *= scalar
            out.append(newVar)

        return out

    def instantiateCFF2(
        varfont,
        axisLimits,
        *,
        round=round,
        specialize=True,
        generalize=False,
        downgrade=False,
    ):
        # The algorithm here is rather simple:
        #
        # Take all blend operations and store their deltas in the (otherwise empty)
        # CFF2 VarStore. Then, instantiate the VarStore with the given axis limits,
        # and read back the new deltas. This is done for both the CharStrings and
        # the Private dicts.
        #
        # Then prune unused things and possibly drop the VarStore if it's empty.
        # In which case, downgrade to CFF table if requested.

        log.info("Instantiating CFF2 table")

        fvarAxes = varfont["fvar"].axes

        cff = varfont["CFF2"].cff
        topDict = cff.topDictIndex[0]
        varStore = topDict.VarStore.otVarStore
        if not varStore:
            if downgrade:
                from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF

                convertCFF2ToCFF(varfont)
            return

        cff.desubroutinize()

        def getNumRegions(vsindex):
            return varStore.VarData[vsindex if vsindex is not None else 0].VarRegionCount

        charStrings = topDict.CharStrings.values()

        # Gather all unique private dicts
        uniquePrivateDicts = set()
        privateDicts = []
        for fd in topDict.FDArray:
            if fd.Private not in uniquePrivateDicts:
                uniquePrivateDicts.add(fd.Private)
                privateDicts.append(fd.Private)

        allCommands = []
        for cs in charStrings:
            assert cs.private.vstore.otVarStore is varStore  # Or in many places!!
            commands = programToCommands(cs.program, getNumRegions=getNumRegions)
            if generalize:
                commands = generalizeCommands(commands)
            if specialize:
                commands = specializeCommands(commands, generalizeFirst=not generalize)
            allCommands.append(commands)

        def storeBlendsToVarStore(arg):
            if not isinstance(arg, list):
                return

            if any(isinstance(subarg, list) for subarg in arg[:-1]):
                raise NotImplementedError("Nested blend lists not supported (yet)")

            count = arg[-1]
            assert (len(arg) - 1) % count == 0
            nRegions = (len(arg) - 1) // count - 1
            assert nRegions == getNumRegions(vsindex)
            for i in range(count, len(arg) - 1, nRegions):
                deltas = arg[i : i + nRegions]
                assert len(deltas) == nRegions
                varData = varStore.VarData[vsindex]
                varData.Item.append(deltas)
                varData.ItemCount += 1

        def fetchBlendsFromVarStore(arg):
            if not isinstance(arg, list):
                return [arg]

            if any(isinstance(subarg, list) for subarg in arg[:-1]):
                raise NotImplementedError("Nested blend lists not supported (yet)")

            count = arg[-1]
            assert (len(arg) - 1) % count == 0
            numRegions = getNumRegions(vsindex)
            newDefaults = []
            newDeltas = []
            for i in range(count):
                defaultValue = arg[i]

                major = vsindex
                minor = varDataCursor[major]
                varDataCursor[major] += 1

                varIdx = (major << 16) + minor

                defaultValue += round(defaultDeltas[varIdx])
                newDefaults.append(defaultValue)

                varData = varStore.VarData[major]
                deltas = varData.Item[minor]
                assert len(deltas) == numRegions
                newDeltas.extend(deltas)

            if not numRegions:
                return newDefaults  # No deltas, just return the defaults

            return [newDefaults + newDeltas + [count]]

        # Check VarData's are empty
        for varData in varStore.VarData:
            assert varData.Item == []
            assert varData.ItemCount == 0

        # Add charstring blend lists to VarStore so we can instantiate them
        for commands in allCommands:
            vsindex = 0
            for command in commands:
                if command[0] == "vsindex":
                    vsindex = command[1][0]
                    continue
                for arg in command[1]:
                    storeBlendsToVarStore(arg)

        # Add private blend lists to VarStore so we can instantiate values
        vsindex = 0
        for opcode, name, arg_type, default, converter in privateDictOperators2:
            if arg_type not in ("number", "delta", "array"):
                continue

            vsindex = 0
            for private in privateDicts:
                if not hasattr(private, name):
                    continue
                values = getattr(private, name)

                if name == "vsindex":
                    vsindex = values[0]
                    continue

                if arg_type == "number":
                    values = [values]

                for value in values:
                    if not isinstance(value, list):
                        continue

                    assert len(value) % (getNumRegions(vsindex) + 1) == 0
                    count = len(value) // (getNumRegions(vsindex) + 1)
                    storeBlendsToVarStore(value + [count])

        # Instantiate VarStore
        defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)

        # Read back new charstring blends from the instantiated VarStore
        varDataCursor = [0] * len(varStore.VarData)
        for commands in allCommands:
            vsindex = 0
            for command in commands:
                if command[0] == "vsindex":
                    vsindex = command[1][0]
                    continue
                newArgs = []
                for arg in command[1]:
                    newArgs.extend(fetchBlendsFromVarStore(arg))
                command[1][:] = newArgs

        # Read back new private blends from the instantiated VarStore
        for opcode, name, arg_type, default, converter in privateDictOperators2:
            if arg_type not in ("number", "delta", "array"):
                continue

            for private in privateDicts:
                if not hasattr(private, name):
                    continue
                values = getattr(private, name)
                if arg_type == "number":
                    values = [values]

                newValues = []
                for value in values:
                    if not isinstance(value, list):
                        newValues.append(value)
                        continue

                    value.append(1)
                    value = fetchBlendsFromVarStore(value)
                    newValues.extend(v[:-1] if isinstance(v, list) else v for v in value)

                if arg_type == "number":
                    newValues = newValues[0]

                setattr(private, name, newValues)

        # Empty out the VarStore
        for i, varData in enumerate(varStore.VarData):
            assert varDataCursor[i] == varData.ItemCount, (
                varDataCursor[i],
                varData.ItemCount,
            )
            varData.Item = []
            varData.ItemCount = 0

        # Remove vsindex commands that are no longer needed, collect those that are.
        usedVsindex = set()
        for commands in allCommands:
            if any(isinstance(arg, list) for command in commands for arg in command[1]):
                vsindex = 0
                for command in commands:
                    if command[0] == "vsindex":
                        vsindex = command[1][0]
                        continue
                    if any(isinstance(arg, list) for arg in command[1]):
                        usedVsindex.add(vsindex)
            else:
                commands[:] = [command for command in commands if command[0] != "vsindex"]

        # Remove unused VarData and update vsindex values
        vsindexMapping = {v: i for i, v in enumerate(sorted(usedVsindex))}
        varStore.VarData = [
            varData for i, varData in enumerate(varStore.VarData) if i in usedVsindex
        ]
        varStore.VarDataCount = len(varStore.VarData)
        for commands in allCommands:
            for command in commands:
                if command[0] == "vsindex":
                    command[1][0] = vsindexMapping[command[1][0]]

        # Remove initial vsindex commands that are implied
        for commands in allCommands:
            if commands and commands[0] == ("vsindex", [0]):
                commands.pop(0)

        # Ship the charstrings!
        for cs, commands in zip(charStrings, allCommands):
            cs.program = commandsToProgram(commands)

        # Remove empty VarStore
        if not varStore.VarData:
            if "VarStore" in topDict.rawDict:
                del topDict.rawDict["VarStore"]
            del topDict.VarStore
            del topDict.CharStrings.varStore
            for private in privateDicts:
                del private.vstore

            if downgrade:
                from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF

                convertCFF2ToCFF(varfont)

    def _instantiateGvarGlyph(
        glyphname, glyf, gvar, hMetrics, vMetrics, axisLimits, optimize=True
    ):
        coordinates, ctrl = glyf._getCoordinatesAndControls(glyphname, hMetrics, vMetrics)
        endPts = ctrl.endPts

        # Not every glyph may have variations
        tupleVarStore = gvar.variations.get(glyphname)

        if tupleVarStore:
            defaultDeltas = instantiateTupleVariationStore(
                tupleVarStore, axisLimits, coordinates, endPts
            )

            if defaultDeltas:
                coordinates += _g_l_y_f.GlyphCoordinates(defaultDeltas)

        # _setCoordinates also sets the hmtx/vmtx advance widths and sidebearings from
        # the four phantom points and glyph bounding boxes.
        # We call it unconditionally even if a glyph has no variations or no deltas are
        # applied at this location, in case the glyph's xMin and in turn its sidebearing
        # have changed. E.g. a composite glyph has no deltas for the component's (x, y)
        # offset nor for the 4 phantom points (e.g. it's monospaced). Thus its entry in
        # gvar table is empty; however, the composite's base glyph may have deltas
        # applied, hence the composite's bbox and left/top sidebearings may need updating
        # in the instanced font.
        glyf._setCoordinates(glyphname, coordinates, hMetrics, vMetrics)

        if not tupleVarStore:
            if glyphname in gvar.variations:
                del gvar.variations[glyphname]
            return

        if optimize:
            # IUP semantics depend on point equality, and so round prior to
            # optimization to ensure that comparisons that happen now will be the
            # same as those that happen at render time. This is especially needed
            # when floating point deltas have been applied to the default position.
            #     See https://github.com/fonttools/fonttools/issues/3634
            # Rounding must happen only after calculating glyf metrics above, to
            # preserve backwards compatibility.
            #     See 0010a3cd9aa25f84a3a6250dafb119743d32aa40
            coordinates.toInt()

            isComposite = glyf[glyphname].isComposite()

            for var in tupleVarStore:
                var.optimize(coordinates, endPts, isComposite=isComposite)

    def instantiateGvarGlyph(varfont, glyphname, axisLimits, optimize=True):
        """Remove?
        https://github.com/fonttools/fonttools/pull/2266"""
        gvar = varfont["gvar"]
        glyf = varfont["glyf"]
        hMetrics = varfont["hmtx"].metrics
        vMetrics = getattr(varfont.get("vmtx"), "metrics", None)
        _instantiateGvarGlyph(
            glyphname, glyf, gvar, hMetrics, vMetrics, axisLimits, optimize=optimize
        )

    def instantiateGvar(varfont, axisLimits, optimize=True):
        log.info("Instantiating glyf/gvar tables")

        gvar = varfont["gvar"]
        glyf = varfont["glyf"]
        hMetrics = varfont["hmtx"].metrics
        vMetrics = getattr(varfont.get("vmtx"), "metrics", None)
        # Get list of glyph names sorted by component depth.
        # If a composite glyph is processed before its base glyph, the bounds may
        # be calculated incorrectly because deltas haven't been applied to the
        # base glyph yet.
        glyphnames = sorted(
            glyf.glyphOrder,
            key=lambda name: (
                (
                    glyf[name].getCompositeMaxpValues(glyf).maxComponentDepth
                    if glyf[name].isComposite()
                    else 0
                ),
                name,
            ),
        )
        for glyphname in glyphnames:
            _instantiateGvarGlyph(
                glyphname, glyf, gvar, hMetrics, vMetrics, axisLimits, optimize=optimize
            )

        if not gvar.variations:
            del varfont["gvar"]

    def setCvarDeltas(cvt, deltas):
        for i, delta in enumerate(deltas):
            if delta:
                cvt[i] += otRound(delta)

    def instantiateCvar(varfont, axisLimits):
        log.info("Instantiating cvt/cvar tables")

        cvar = varfont["cvar"]

        defaultDeltas = instantiateTupleVariationStore(cvar.variations, axisLimits)

        if defaultDeltas:
            setCvarDeltas(varfont["cvt "], defaultDeltas)

        if not cvar.variations:
            del varfont["cvar"]

    def setMvarDeltas(varfont, deltas):
        mvar = varfont["MVAR"].table
        records = mvar.ValueRecord
        for rec in records:
            mvarTag = rec.ValueTag
            if mvarTag not in MVAR_ENTRIES:
                continue
            tableTag, itemName = MVAR_ENTRIES[mvarTag]
            delta = deltas[rec.VarIdx]
            if delta != 0:
                setattr(
                    varfont[tableTag],
                    itemName,
                    getattr(varfont[tableTag], itemName) + otRound(delta),
                )

    @contextmanager
    def verticalMetricsKeptInSync(varfont):
        """Ensure hhea vertical metrics stay in sync with OS/2 ones after instancing.

        When applying MVAR deltas to the OS/2 table, if the ascender, descender and
        line gap change but they were the same as the respective hhea metrics in the
        original font, this context manager ensures that hhea metrcs also get updated
        accordingly.
        The MVAR spec only has tags for the OS/2 metrics, but it is common in fonts
        to have the hhea metrics be equal to those for compat reasons.

        https://learn.microsoft.com/en-us/typography/opentype/spec/mvar
        https://googlefonts.github.io/gf-guide/metrics.html#7-hhea-and-typo-metrics-should-be-equal
        https://github.com/fonttools/fonttools/issues/3297
        """
        current_os2_vmetrics = [
            getattr(varfont["OS/2"], attr)
            for attr in ("sTypoAscender", "sTypoDescender", "sTypoLineGap")
        ]
        metrics_are_synced = current_os2_vmetrics == [
            getattr(varfont["hhea"], attr) for attr in ("ascender", "descender", "lineGap")
        ]

        yield metrics_are_synced

        if metrics_are_synced:
            new_os2_vmetrics = [
                getattr(varfont["OS/2"], attr)
                for attr in ("sTypoAscender", "sTypoDescender", "sTypoLineGap")
            ]
            if current_os2_vmetrics != new_os2_vmetrics:
                for attr, value in zip(
                    ("ascender", "descender", "lineGap"), new_os2_vmetrics
                ):
                    setattr(varfont["hhea"], attr, value)

    def instantiateMVAR(varfont, axisLimits):
        log.info("Instantiating MVAR table")

        mvar = varfont["MVAR"].table
        fvarAxes = varfont["fvar"].axes
        varStore = mvar.VarStore
        defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)

        with verticalMetricsKeptInSync(varfont):
            setMvarDeltas(varfont, defaultDeltas)

        if varStore.VarRegionList.Region:
            varIndexMapping = varStore.optimize()
            for rec in mvar.ValueRecord:
                rec.VarIdx = varIndexMapping[rec.VarIdx]
        else:
            del varfont["MVAR"]

    def _remapVarIdxMap(table, attrName, varIndexMapping, glyphOrder):
        oldMapping = getattr(table, attrName).mapping
        newMapping = [varIndexMapping[oldMapping[glyphName]] for glyphName in glyphOrder]
        setattr(table, attrName, builder.buildVarIdxMap(newMapping, glyphOrder))

    # TODO(anthrotype) Add support for HVAR/VVAR in CFF2
    def _instantiateVHVAR(varfont, axisLimits, tableFields, *, round=round):
        location = axisLimits.pinnedLocation()
        tableTag = tableFields.tableTag
        fvarAxes = varfont["fvar"].axes

        log.info("Instantiating %s table", tableTag)
        vhvar = varfont[tableTag].table
        varStore = vhvar.VarStore

        if "glyf" in varfont:
            # Deltas from gvar table have already been applied to the hmtx/vmtx. For full
            # instances (i.e. all axes pinned), we can simply drop HVAR/VVAR and return
            if set(location).issuperset(axis.axisTag for axis in fvarAxes):
                log.info("Dropping %s table", tableTag)
                del varfont[tableTag]
                return

        defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)

        if "glyf" not in varfont:
            # CFF2 fonts need hmtx/vmtx updated here. For glyf fonts, the instantiateGvar
            # function already updated the hmtx/vmtx from phantom points. Maybe remove
            # that and do it here for both CFF2 and glyf fonts?
            #
            # Specially, if a font has glyf but not gvar, the hmtx/vmtx will not have been
            # updated by instantiateGvar. Though one can call that a faulty font.
            metricsTag = "vmtx" if tableTag == "VVAR" else "hmtx"
            if metricsTag in varfont:
                advMapping = getattr(vhvar, tableFields.advMapping)
                metricsTable = varfont[metricsTag]
                metrics = metricsTable.metrics
                for glyphName, (advanceWidth, sb) in metrics.items():
                    if advMapping:
                        varIdx = advMapping.mapping[glyphName]
                    else:
                        varIdx = varfont.getGlyphID(glyphName)
                    metrics[glyphName] = (advanceWidth + round(defaultDeltas[varIdx]), sb)

                if (
                    tableTag == "VVAR"
                    and getattr(vhvar, tableFields.vOrigMapping) is not None
                ):
                    log.warning(
                        "VORG table not yet updated to reflect changes in VVAR table"
                    )

                # For full instances (i.e. all axes pinned), we can simply drop HVAR/VVAR and return
                if set(location).issuperset(axis.axisTag for axis in fvarAxes):
                    log.info("Dropping %s table", tableTag)
                    del varfont[tableTag]
                    return

        if varStore.VarRegionList.Region:
            # Only re-optimize VarStore if the HVAR/VVAR already uses indirect AdvWidthMap
            # or AdvHeightMap. If a direct, implicit glyphID->VariationIndex mapping is
            # used for advances, skip re-optimizing and maintain original VariationIndex.
            if getattr(vhvar, tableFields.advMapping):
                varIndexMapping = varStore.optimize(use_NO_VARIATION_INDEX=False)
                glyphOrder = varfont.getGlyphOrder()
                _remapVarIdxMap(vhvar, tableFields.advMapping, varIndexMapping, glyphOrder)
                if getattr(vhvar, tableFields.sb1):  # left or top sidebearings
                    _remapVarIdxMap(vhvar, tableFields.sb1, varIndexMapping, glyphOrder)
                if getattr(vhvar, tableFields.sb2):  # right or bottom sidebearings
                    _remapVarIdxMap(vhvar, tableFields.sb2, varIndexMapping, glyphOrder)
                if tableTag == "VVAR" and getattr(vhvar, tableFields.vOrigMapping):
                    _remapVarIdxMap(
                        vhvar, tableFields.vOrigMapping, varIndexMapping, glyphOrder
                    )

    def instantiateHVAR(varfont, axisLimits):
        return _instantiateVHVAR(varfont, axisLimits, varLib.HVAR_FIELDS)

    def instantiateVVAR(varfont, axisLimits):
        return _instantiateVHVAR(varfont, axisLimits, varLib.VVAR_FIELDS)

    class _TupleVarStoreAdapter(object):
        def __init__(self, regions, axisOrder, tupleVarData, itemCounts):
            self.regions = regions
            self.axisOrder = axisOrder
            self.tupleVarData = tupleVarData
            self.itemCounts = itemCounts

        @classmethod
        def fromItemVarStore(cls, itemVarStore, fvarAxes):
            axisOrder = [axis.axisTag for axis in fvarAxes]
            regions = [
                region.get_support(fvarAxes) for region in itemVarStore.VarRegionList.Region
            ]
            tupleVarData = []
            itemCounts = []
            for varData in itemVarStore.VarData:
                variations = []
                varDataRegions = (regions[i] for i in varData.VarRegionIndex)
                for axes, coordinates in zip(varDataRegions, zip(*varData.Item)):
                    variations.append(TupleVariation(axes, list(coordinates)))
                tupleVarData.append(variations)
                itemCounts.append(varData.ItemCount)
            return cls(regions, axisOrder, tupleVarData, itemCounts)

        def rebuildRegions(self):
            # Collect the set of all unique region axes from the current TupleVariations.
            # We use an OrderedDict to de-duplicate regions while keeping the order.
            uniqueRegions = collections.OrderedDict.fromkeys(
                (
                    frozenset(var.axes.items())
                    for variations in self.tupleVarData
                    for var in variations
                )
            )
            # Maintain the original order for the regions that pre-existed, appending
            # the new regions at the end of the region list.
            newRegions = []
            for region in self.regions:
                regionAxes = frozenset(region.items())
                if regionAxes in uniqueRegions:
                    newRegions.append(region)
                    del uniqueRegions[regionAxes]
            if uniqueRegions:
                newRegions.extend(dict(region) for region in uniqueRegions)
            self.regions = newRegions

        def instantiate(self, axisLimits):
            defaultDeltaArray = []
            for variations, itemCount in zip(self.tupleVarData, self.itemCounts):
                defaultDeltas = instantiateTupleVariationStore(variations, axisLimits)
                if not defaultDeltas:
                    defaultDeltas = [0] * itemCount
                defaultDeltaArray.append(defaultDeltas)

            # rebuild regions whose axes were dropped or limited
            self.rebuildRegions()

            pinnedAxes = set(axisLimits.pinnedLocation())
            self.axisOrder = [
                axisTag for axisTag in self.axisOrder if axisTag not in pinnedAxes
            ]

            return defaultDeltaArray

        def asItemVarStore(self):
            regionOrder = [frozenset(axes.items()) for axes in self.regions]
            varDatas = []
            for variations, itemCount in zip(self.tupleVarData, self.itemCounts):
                if variations:
                    assert len(variations[0].coordinates) == itemCount
                    varRegionIndices = [
                        regionOrder.index(frozenset(var.axes.items())) for var in variations
                    ]
                    varDataItems = list(zip(*(var.coordinates for var in variations)))
                    varDatas.append(
                        builder.buildVarData(varRegionIndices, varDataItems, optimize=False)
                    )
                else:
                    varDatas.append(
                        builder.buildVarData([], [[] for _ in range(itemCount)])
                    )
            regionList = builder.buildVarRegionList(self.regions, self.axisOrder)
            itemVarStore = builder.buildVarStore(regionList, varDatas)
            # remove unused regions from VarRegionList
            itemVarStore.prune_regions()
            return itemVarStore

    def instantiateItemVariationStore(itemVarStore, fvarAxes, axisLimits):
        """Compute deltas at partial location, and update varStore in-place.

        Remove regions in which all axes were instanced, or fall outside the new axis
        limits. Scale the deltas of the remaining regions where only some of the axes
        were instanced.

        The number of VarData subtables, and the number of items within each, are
        not modified, in order to keep the existing VariationIndex valid.
        One may call VarStore.optimize() method after this to further optimize those.

        Args:
            varStore: An otTables.VarStore object (Item Variation Store)
            fvarAxes: list of fvar's Axis objects
            axisLimits: NormalizedAxisLimits: mapping axis tags to normalized
                min/default/max axis coordinates. May not specify coordinates/ranges for
                all the fvar axes.

        Returns:
            defaultDeltas: to be added to the default instance, of type dict of floats
                keyed by VariationIndex compound values: i.e. (outer << 16) + inner.
        """
        tupleVarStore = _TupleVarStoreAdapter.fromItemVarStore(itemVarStore, fvarAxes)
        defaultDeltaArray = tupleVarStore.instantiate(axisLimits)
        newItemVarStore = tupleVarStore.asItemVarStore()

        itemVarStore.VarRegionList = newItemVarStore.VarRegionList
        if not hasattr(itemVarStore, "VarDataCount"):  # Happens fromXML
            itemVarStore.VarDataCount = len(newItemVarStore.VarData)
        assert itemVarStore.VarDataCount == newItemVarStore.VarDataCount
        itemVarStore.VarData = newItemVarStore.VarData

        defaultDeltas = {
            ((major << 16) + minor): delta
            for major, deltas in enumerate(defaultDeltaArray)
            for minor, delta in enumerate(deltas)
        }
        defaultDeltas[itemVarStore.NO_VARIATION_INDEX] = 0
        return defaultDeltas

    def instantiateOTL(varfont, axisLimits):
        # TODO(anthrotype) Support partial instancing of JSTF and BASE tables

        if (
            "GDEF" not in varfont
            or varfont["GDEF"].table.Version < 0x00010003
            or not varfont["GDEF"].table.VarStore
        ):
            return

        if "GPOS" in varfont:
            msg = "Instantiating GDEF and GPOS tables"
        else:
            msg = "Instantiating GDEF table"
        log.info(msg)

        gdef = varfont["GDEF"].table
        varStore = gdef.VarStore
        fvarAxes = varfont["fvar"].axes

        defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)

        # When VF are built, big lookups may overflow and be broken into multiple
        # subtables. MutatorMerger (which inherits from AligningMerger) reattaches
        # them upon instancing, in case they can now fit a single subtable (if not,
        # they will be split again upon compilation).
        # This 'merger' also works as a 'visitor' that traverses the OTL tables and
        # calls specific methods when instances of a given type are found.
        # Specifically, it adds default deltas to GPOS Anchors/ValueRecords and GDEF
        # LigatureCarets, and optionally deletes all VariationIndex tables if the
        # VarStore is fully instanced.
        merger = MutatorMerger(
            varfont, defaultDeltas, deleteVariations=(not varStore.VarRegionList.Region)
        )
        merger.mergeTables(varfont, [varfont], ["GDEF", "GPOS"])

        if varStore.VarRegionList.Region:
            varIndexMapping = varStore.optimize()
            gdef.remap_device_varidxes(varIndexMapping)
            if "GPOS" in varfont:
                varfont["GPOS"].table.remap_device_varidxes(varIndexMapping)
        else:
            # Downgrade GDEF.
            del gdef.VarStore
            gdef.Version = 0x00010002
            if gdef.MarkGlyphSetsDef is None:
                del gdef.MarkGlyphSetsDef
                gdef.Version = 0x00010000

            if not (
                gdef.LigCaretList
                or gdef.MarkAttachClassDef
                or gdef.GlyphClassDef
                or gdef.AttachList
                or (gdef.Version >= 0x00010002 and gdef.MarkGlyphSetsDef)
            ):
                del varfont["GDEF"]

    def _isValidAvarSegmentMap(axisTag, segmentMap):
        if not segmentMap:
            return True
        if not {(-1.0, -1.0), (0, 0), (1.0, 1.0)}.issubset(segmentMap.items()):
            log.warning(
                f"Invalid avar SegmentMap record for axis '{axisTag}': does not "
                "include all required value maps {-1.0: -1.0, 0: 0, 1.0: 1.0}"
            )
            return False
        previousValue = None
        for fromCoord, toCoord in sorted(segmentMap.items()):
            if previousValue is not None and previousValue > toCoord:
                log.warning(
                    f"Invalid avar AxisValueMap({fromCoord}, {toCoord}) record "
                    f"for axis '{axisTag}': the toCoordinate value must be >= to "
                    f"the toCoordinate value of the preceding record ({previousValue})."
                )
                return False
            previousValue = toCoord
        return True

    def instantiateAvar(varfont, axisLimits):
        # 'axisLimits' dict must contain user-space (non-normalized) coordinates.

        avar = varfont["avar"]
        if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
            raise NotImplementedError("avar table with VarStore is not supported")

        segments = avar.segments

        # drop table if we instantiate all the axes
        pinnedAxes = set(axisLimits.pinnedLocation())
        if pinnedAxes.issuperset(segments):
            log.info("Dropping avar table")
            del varfont["avar"]
            return

        log.info("Instantiating avar table")
        for axis in pinnedAxes:
            if axis in segments:
                del segments[axis]

        # First compute the default normalization for axisLimits coordinates: i.e.
        # min = -1.0, default = 0, max = +1.0, and in between values interpolated linearly,
        # without using the avar table's mappings.
        # Then, for each SegmentMap, if we are restricting its axis, compute the new
        # mappings by dividing the key/value pairs by the desired new min/max values,
        # dropping any mappings that fall outside the restricted range.
        # The keys ('fromCoord') are specified in default normalized coordinate space,
        # whereas the values ('toCoord') are "mapped forward" using the SegmentMap.
        normalizedRanges = axisLimits.normalize(varfont, usingAvar=False)
        newSegments = {}
        for axisTag, mapping in segments.items():
            if not _isValidAvarSegmentMap(axisTag, mapping):
                continue
            if mapping and axisTag in normalizedRanges:
                axisRange = normalizedRanges[axisTag]
                mappedMin = floatToFixedToFloat(
                    piecewiseLinearMap(axisRange.minimum, mapping), 14
                )
                mappedDef = floatToFixedToFloat(
                    piecewiseLinearMap(axisRange.default, mapping), 14
                )
                mappedMax = floatToFixedToFloat(
                    piecewiseLinearMap(axisRange.maximum, mapping), 14
                )
                mappedAxisLimit = NormalizedAxisTripleAndDistances(
                    mappedMin,
                    mappedDef,
                    mappedMax,
                    axisRange.distanceNegative,
                    axisRange.distancePositive,
                )
                newMapping = {}
                for fromCoord, toCoord in mapping.items():
                    if fromCoord < axisRange.minimum or fromCoord > axisRange.maximum:
                        continue
                    fromCoord = axisRange.renormalizeValue(fromCoord)

                    assert mappedMin <= toCoord <= mappedMax
                    toCoord = mappedAxisLimit.renormalizeValue(toCoord)

                    fromCoord = floatToFixedToFloat(fromCoord, 14)
                    toCoord = floatToFixedToFloat(toCoord, 14)
                    newMapping[fromCoord] = toCoord
                newMapping.update({-1.0: -1.0, 0.0: 0.0, 1.0: 1.0})
                newSegments[axisTag] = newMapping
            else:
                newSegments[axisTag] = mapping
        avar.segments = newSegments

    def isInstanceWithinAxisRanges(location, axisRanges):
        for axisTag, coord in location.items():
            if axisTag in axisRanges:
                axisRange = axisRanges[axisTag]
                if coord < axisRange.minimum or coord > axisRange.maximum:
                    return False
        return True

    def instantiateFvar(varfont, axisLimits):
        # 'axisLimits' dict must contain user-space (non-normalized) coordinates

        location = axisLimits.pinnedLocation()

        fvar = varfont["fvar"]

        # drop table if we instantiate all the axes
        if set(location).issuperset(axis.axisTag for axis in fvar.axes):
            log.info("Dropping fvar table")
            del varfont["fvar"]
            return

        log.info("Instantiating fvar table")

        axes = []
        for axis in fvar.axes:
            axisTag = axis.axisTag
            if axisTag in location:
                continue
            if axisTag in axisLimits:
                triple = axisLimits[axisTag]
                if triple.default is None:
                    triple = (triple.minimum, axis.defaultValue, triple.maximum)
                axis.minValue, axis.defaultValue, axis.maxValue = triple
            axes.append(axis)
        fvar.axes = axes

        # only keep NamedInstances whose coordinates == pinned axis location
        instances = []
        for instance in fvar.instances:
            if any(instance.coordinates[axis] != value for axis, value in location.items()):
                continue
            for axisTag in location:
                del instance.coordinates[axisTag]
            if not isInstanceWithinAxisRanges(instance.coordinates, axisLimits):
                continue
            instances.append(instance)
        fvar.instances = instances

    def instantiateSTAT(varfont, axisLimits):
        # 'axisLimits' dict must contain user-space (non-normalized) coordinates

        stat = varfont["STAT"].table
        if not stat.DesignAxisRecord or not (
            stat.AxisValueArray and stat.AxisValueArray.AxisValue
        ):
            return  # STAT table empty, nothing to do

        log.info("Instantiating STAT table")
        newAxisValueTables = axisValuesFromAxisLimits(stat, axisLimits)
        stat.AxisValueCount = len(newAxisValueTables)
        if stat.AxisValueCount:
            stat.AxisValueArray.AxisValue = newAxisValueTables
        else:
            stat.AxisValueArray = None

    def axisValuesFromAxisLimits(stat, axisLimits):
        def isAxisValueOutsideLimits(axisTag, axisValue):
            if axisTag in axisLimits:
                triple = axisLimits[axisTag]
                if axisValue < triple.minimum or axisValue > triple.maximum:
                    return True
            return False

        # only keep AxisValues whose axis is not pinned nor restricted, or is pinned at the
        # exact (nominal) value, or is restricted but the value is within the new range
        designAxes = stat.DesignAxisRecord.Axis
        newAxisValueTables = []
        for axisValueTable in stat.AxisValueArray.AxisValue:
            axisValueFormat = axisValueTable.Format
            if axisValueFormat in (1, 2, 3):
                axisTag = designAxes[axisValueTable.AxisIndex].AxisTag
                if axisValueFormat == 2:
                    axisValue = axisValueTable.NominalValue
                else:
                    axisValue = axisValueTable.Value
                if isAxisValueOutsideLimits(axisTag, axisValue):
                    continue
            elif axisValueFormat == 4:
                # drop 'non-analytic' AxisValue if _any_ AxisValueRecord doesn't match
                # the pinned location or is outside range
                dropAxisValueTable = False
                for rec in axisValueTable.AxisValueRecord:
                    axisTag = designAxes[rec.AxisIndex].AxisTag
                    axisValue = rec.Value
                    if isAxisValueOutsideLimits(axisTag, axisValue):
                        dropAxisValueTable = True
                        break
                if dropAxisValueTable:
                    continue
            else:
                log.warning("Unknown AxisValue table format (%s); ignored", axisValueFormat)
            newAxisValueTables.append(axisValueTable)
        return newAxisValueTables

    def setMacOverlapFlags(glyfTable):
        flagOverlapCompound = _g_l_y_f.OVERLAP_COMPOUND
        flagOverlapSimple = _g_l_y_f.flagOverlapSimple
        for glyphName in glyfTable.keys():
            glyph = glyfTable[glyphName]
            # Set OVERLAP_COMPOUND bit for compound glyphs
            if glyph.isComposite():
                glyph.components[0].flags |= flagOverlapCompound
            # Set OVERLAP_SIMPLE bit for simple glyphs
            elif glyph.numberOfContours > 0:
                glyph.flags[0] |= flagOverlapSimple

    def normalize(value, triple, avarMapping):
        value = normalizeValue(value, triple)
        if avarMapping:
            value = piecewiseLinearMap(value, avarMapping)
        # Quantize to F2Dot14, to avoid surprise interpolations.
        return floatToFixedToFloat(value, 14)

    def sanityCheckVariableTables(varfont):
        if "fvar" not in varfont:
            raise ValueError("Missing required table fvar")
        if "gvar" in varfont:
            if "glyf" not in varfont:
                raise ValueError("Can't have gvar without glyf")

    def instantiateVariableFont(
        varfont,
        axisLimits,
        inplace=False,
        optimize=True,
        overlap=OverlapMode.KEEP_AND_SET_FLAGS,
        updateFontNames=False,
        *,
        downgradeCFF2=False,
    ):
        """Instantiate variable font, either fully or partially.

        Depending on whether the `axisLimits` dictionary references all or some of the
        input varfont's axes, the output font will either be a full instance (static
        font) or a variable font with possibly less variation data.

        Args:
            varfont: a TTFont instance, which must contain at least an 'fvar' table.
            axisLimits: a dict keyed by axis tags (str) containing the coordinates (float)
                along one or more axes where the desired instance will be located.
                If the value is `None`, the default coordinate as per 'fvar' table for
                that axis is used.
                The limit values can also be (min, max) tuples for restricting an
                axis's variation range. The default axis value must be included in
                the new range.
            inplace (bool): whether to modify input TTFont object in-place instead of
                returning a distinct object.
            optimize (bool): if False, do not perform IUP-delta optimization on the
                remaining 'gvar' table's deltas. Possibly faster, and might work around
                rendering issues in some buggy environments, at the cost of a slightly
                larger file size.
            overlap (OverlapMode): variable fonts usually contain overlapping contours, and
                some font rendering engines on Apple platforms require that the
                `OVERLAP_SIMPLE` and `OVERLAP_COMPOUND` flags in the 'glyf' table be set to
                force rendering using a non-zero fill rule. Thus we always set these flags
                on all glyphs to maximise cross-compatibility of the generated instance.
                You can disable this by passing OverlapMode.KEEP_AND_DONT_SET_FLAGS.
                If you want to remove the overlaps altogether and merge overlapping
                contours and components, you can pass OverlapMode.REMOVE (or
                REMOVE_AND_IGNORE_ERRORS to not hard-fail on tricky glyphs). Note that this
                requires the skia-pathops package (available to pip install).
                The overlap parameter only has effect when generating full static instances.
            updateFontNames (bool): if True, update the instantiated font's name table using
                the Axis Value Tables from the STAT table. The name table and the style bits
                in the head and OS/2 table will be updated so they conform to the R/I/B/BI
                model. If the STAT table is missing or an Axis Value table is missing for
                a given axis coordinate, a ValueError will be raised.
            downgradeCFF2 (bool): if True, downgrade the CFF2 table to CFF table when possible
                ie. full instancing of all axes. This is useful for compatibility with older
                software that does not support CFF2. Defaults to False. Note that this
                operation also removes overlaps within glyph shapes, as CFF does not support
                overlaps but CFF2 does.
        """
        # 'overlap' used to be bool and is now enum; for backward compat keep accepting bool
        overlap = OverlapMode(int(overlap))

        sanityCheckVariableTables(varfont)

        axisLimits = AxisLimits(axisLimits).limitAxesAndPopulateDefaults(varfont)

        log.info("Restricted limits: %s", axisLimits)

        normalizedLimits = axisLimits.normalize(varfont)

        log.info("Normalized limits: %s", normalizedLimits)

        if not inplace:
            varfont = deepcopy(varfont)

        if "DSIG" in varfont:
            del varfont["DSIG"]

        if updateFontNames:
            log.info("Updating name table")
            names.updateNameTable(varfont, axisLimits)

        if "VARC" in varfont:
            instantiateVARC(varfont, normalizedLimits)

        if "CFF2" in varfont:
            instantiateCFF2(varfont, normalizedLimits, downgrade=downgradeCFF2)

        if "gvar" in varfont:
            instantiateGvar(varfont, normalizedLimits, optimize=optimize)

        if "cvar" in varfont:
            instantiateCvar(varfont, normalizedLimits)

        if "MVAR" in varfont:
            instantiateMVAR(varfont, normalizedLimits)

        if "HVAR" in varfont:
            instantiateHVAR(varfont, normalizedLimits)

        if "VVAR" in varfont:
            instantiateVVAR(varfont, normalizedLimits)

        instantiateOTL(varfont, normalizedLimits)

        instantiateFeatureVariations(varfont, normalizedLimits)

        if "avar" in varfont:
            instantiateAvar(varfont, axisLimits)

        with names.pruningUnusedNames(varfont):
            if "STAT" in varfont:
                instantiateSTAT(varfont, axisLimits)

            instantiateFvar(varfont, axisLimits)

        if "fvar" not in varfont:
            if "glyf" in varfont:
                if overlap == OverlapMode.KEEP_AND_SET_FLAGS:
                    setMacOverlapFlags(varfont["glyf"])
                elif overlap in (OverlapMode.REMOVE, OverlapMode.REMOVE_AND_IGNORE_ERRORS):
                    from fontTools.ttLib.removeOverlaps import removeOverlaps

                    log.info("Removing overlaps from glyf table")
                    removeOverlaps(
                        varfont,
                        ignoreErrors=(overlap == OverlapMode.REMOVE_AND_IGNORE_ERRORS),
                    )

        if "OS/2" in varfont:
            varfont["OS/2"].recalcAvgCharWidth(varfont)

        varLib.set_default_weight_width_slant(
            varfont, location=axisLimits.defaultLocation()
        )

        if updateFontNames:
            # Set Regular/Italic/Bold/Bold Italic bits as appropriate, after the
            # name table has been updated.
            setRibbiBits(varfont)

        return varfont

    def setRibbiBits(font):
        """Set the `head.macStyle` and `OS/2.fsSelection` style bits
        appropriately."""

        english_ribbi_style = font["name"].getName(names.NameID.SUBFAMILY_NAME, 3, 1, 0x409)
        if english_ribbi_style is None:
            return

        styleMapStyleName = english_ribbi_style.toStr().lower()
        if styleMapStyleName not in {"regular", "bold", "italic", "bold italic"}:
            return

        if styleMapStyleName == "bold":
            font["head"].macStyle = 0b01
        elif styleMapStyleName == "bold italic":
            font["head"].macStyle = 0b11
        elif styleMapStyleName == "italic":
            font["head"].macStyle = 0b10

        selection = font["OS/2"].fsSelection
        # First clear...
        selection &= ~(1 << 0)
        selection &= ~(1 << 5)
        selection &= ~(1 << 6)
        # ...then re-set the bits.
        if styleMapStyleName == "regular":
            selection |= 1 << 6
        elif styleMapStyleName == "bold":
            selection |= 1 << 5
        elif styleMapStyleName == "italic":
            selection |= 1 << 0
        elif styleMapStyleName == "bold italic":
            selection |= 1 << 0
            selection |= 1 << 5
        font["OS/2"].fsSelection = selection

    def parseLimits(limits: Iterable[str]) -> Dict[str, Optional[AxisTriple]]:
        result = {}
        for limitString in limits:
            match = re.match(
                r"^(\w{1,4})=(?:(drop)|(?:([^:]*)(?:[:]([^:]*))?(?:[:]([^:]*))?))$",
                limitString,
            )
            if not match:
                raise ValueError("invalid location format: %r" % limitString)
            tag = match.group(1).ljust(4)

            if match.group(2):  # 'drop'
                result[tag] = None
                continue

            triple = match.group(3, 4, 5)

            if triple[1] is None:  # "value" syntax
                triple = (triple[0], triple[0], triple[0])
            elif triple[2] is None:  # "min:max" syntax
                triple = (triple[0], None, triple[1])

            triple = tuple(float(v) if v else None for v in triple)

            result[tag] = AxisTriple(*triple)

        return result

    def parseArgs(args):
        """Parse argv.

        Returns:
            3-tuple (infile, axisLimits, options)
            axisLimits is either a Dict[str, Optional[float]], for pinning variation axes
            to specific coordinates along those axes (with `None` as a placeholder for an
            axis' default value); or a Dict[str, Tuple(float, float)], meaning limit this
            axis to min/max range.
            Axes locations are in user-space coordinates, as defined in the "fvar" table.
        """
        from fontTools import configLogger
        import argparse

        parser = argparse.ArgumentParser(
            "fonttools varLib.instancer",
            description="Partially instantiate a variable font",
        )
        parser.add_argument("input", metavar="INPUT.ttf", help="Input variable TTF file.")
        parser.add_argument(
            "locargs",
            metavar="AXIS=LOC",
            nargs="*",
            help="List of space separated locations. A location consists of "
            "the tag of a variation axis, followed by '=' and the literal, "
            "string 'drop', or colon-separated list of one to three values, "
            "each of which is the empty string, or a number. "
            "E.g.: wdth=100 or wght=75.0:125.0 or wght=100:400:700 or wght=:500: "
            "or wght=drop",
        )
        parser.add_argument(
            "-o",
            "--output",
            metavar="OUTPUT.ttf",
            default=None,
            help="Output instance TTF file (default: INPUT-instance.ttf).",
        )
        parser.add_argument(
            "--no-optimize",
            dest="optimize",
            action="store_false",
            help="Don't perform IUP optimization on the remaining gvar TupleVariations",
        )
        parser.add_argument(
            "--no-overlap-flag",
            dest="overlap",
            action="store_false",
            help="Don't set OVERLAP_SIMPLE/OVERLAP_COMPOUND glyf flags (only applicable "
            "when generating a full instance)",
        )
        parser.add_argument(
            "--remove-overlaps",
            dest="remove_overlaps",
            action="store_true",
            help="Merge overlapping contours and components (only applicable "
            "when generating a full instance). Requires skia-pathops",
        )
        parser.add_argument(
            "--ignore-overlap-errors",
            dest="ignore_overlap_errors",
            action="store_true",
            help="Don't crash if the remove-overlaps operation fails for some glyphs.",
        )
        parser.add_argument(
            "--update-name-table",
            action="store_true",
            help="Update the instantiated font's `name` table. Input font must have "
            "a STAT table with Axis Value Tables",
        )
        parser.add_argument(
            "--downgrade-cff2",
            action="store_true",
            help="If all axes are pinned, downgrade CFF2 to CFF table format",
        )
        parser.add_argument(
            "--no-recalc-timestamp",
            dest="recalc_timestamp",
            action="store_false",
            help="Don't set the output font's timestamp to the current time.",
        )
        parser.add_argument(
            "--no-recalc-bounds",
            dest="recalc_bounds",
            action="store_false",
            help="Don't recalculate font bounding boxes",
        )
        loggingGroup = parser.add_mutually_exclusive_group(required=False)
        loggingGroup.add_argument(
            "-v", "--verbose", action="store_true", help="Run more verbosely."
        )
        loggingGroup.add_argument(
            "-q", "--quiet", action="store_true", help="Turn verbosity off."
        )
        options = parser.parse_args(args)

        if options.remove_overlaps:
            if options.ignore_overlap_errors:
                options.overlap = OverlapMode.REMOVE_AND_IGNORE_ERRORS
            else:
                options.overlap = OverlapMode.REMOVE
        else:
            options.overlap = OverlapMode(int(options.overlap))

        infile = options.input
        if not os.path.isfile(infile):
            parser.error("No such file '{}'".format(infile))

        configLogger(
            level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
        )

        try:
            axisLimits = parseLimits(options.locargs)
        except ValueError as e:
            parser.error(str(e))

        if len(axisLimits) != len(options.locargs):
            parser.error("Specified multiple limits for the same axis")

        return (infile, axisLimits, options)

    def main(args=None):
        """Partially instantiate a variable font"""
        infile, axisLimits, options = parseArgs(args)
        log.info("Restricting axes: %s", axisLimits)

        log.info("Loading variable font")
        varfont = TTFont(
            infile,
            recalcTimestamp=options.recalc_timestamp,
            recalcBBoxes=options.recalc_bounds,
        )

        isFullInstance = {
            axisTag
            for axisTag, limit in axisLimits.items()
            if limit is None or limit[0] == limit[2]
        }.issuperset(axis.axisTag for axis in varfont["fvar"].axes)

        instantiateVariableFont(
            varfont,
            axisLimits,
            inplace=True,
            optimize=options.optimize,
            overlap=options.overlap,
            updateFontNames=options.update_name_table,
            downgradeCFF2=options.downgrade_cff2,
        )

        suffix = "-instance" if isFullInstance else "-partial"
        outfile = (
            makeOutputFileName(infile, overWrite=True, suffix=suffix)
            if not options.output
            else options.output
        )

        log.info(
            "Saving %s font %s",
            "instance" if isFullInstance else "partial variable",
            outfile,
        )
        varfont.save(outfile)