Add files using upload-large-folder tool

.gitattributes

@@ -1577,3 +1577,4 @@ evalkit_tf449/lib/python3.10/site-packages/nvidia/cublas/lib/libcublasLt.so.12 f
 infer_4_47_1/lib/python3.10/site-packages/gradio/_frontend_code/lite/dist/assets/gradio_client-1.5.3-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
 evalkit_cambrian/lib/python3.10/site-packages/transformers/models/perceiver/__pycache__/modeling_perceiver.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 infer_4_47_1/lib/python3.10/site-packages/fontTools/pens/momentsPen.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+deepseekvl2/lib/python3.10/site-packages/nvidia/nccl/lib/libnccl.so.2 filter=lfs diff=lfs merge=lfs -text

deepseekvl2/lib/python3.10/site-packages/nvidia/nccl/lib/libnccl.so.2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5e5d9d2280dd4e34ab57f542a32a3fb6d009fe4ce84c074df3eae99b008c72d
+size 240931768

infer_4_47_1/lib/python3.10/site-packages/fontTools/cffLib/CFF2ToCFF.py

@@ -0,0 +1,203 @@
+"""CFF2 to CFF converter."""
+
+from fontTools.ttLib import TTFont, newTable
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.cffLib import (
+    TopDictIndex,
+    buildOrder,
+    buildDefaults,
+    topDictOperators,
+    privateDictOperators,
+)
+from .width import optimizeWidths
+from collections import defaultdict
+import logging
+
+
+__all__ = ["convertCFF2ToCFF", "main"]
+
+
+log = logging.getLogger("fontTools.cffLib")
+
+
+def _convertCFF2ToCFF(cff, otFont):
+    """Converts this object from CFF2 format to CFF format. This conversion
+    is done 'in-place'. The conversion cannot be reversed.
+
+    The CFF2 font cannot be variable. (TODO Accept those and convert to the
+    default instance?)
+
+    This assumes a decompiled CFF table. (i.e. that the object has been
+    filled via :meth:`decompile` and e.g. not loaded from XML.)"""
+
+    cff.major = 1
+
+    topDictData = TopDictIndex(None)
+    for item in cff.topDictIndex:
+        # Iterate over, such that all are decompiled
+        item.cff2GetGlyphOrder = None
+        topDictData.append(item)
+    cff.topDictIndex = topDictData
+    topDict = topDictData[0]
+
+    if hasattr(topDict, "VarStore"):
+        raise ValueError("Variable CFF2 font cannot be converted to CFF format.")
+
+    opOrder = buildOrder(topDictOperators)
+    topDict.order = opOrder
+    for key in topDict.rawDict.keys():
+        if key not in opOrder:
+            del topDict.rawDict[key]
+            if hasattr(topDict, key):
+                delattr(topDict, key)
+
+    fdArray = topDict.FDArray
+    charStrings = topDict.CharStrings
+
+    defaults = buildDefaults(privateDictOperators)
+    order = buildOrder(privateDictOperators)
+    for fd in fdArray:
+        fd.setCFF2(False)
+        privateDict = fd.Private
+        privateDict.order = order
+        for key in order:
+            if key not in privateDict.rawDict and key in defaults:
+                privateDict.rawDict[key] = defaults[key]
+        for key in privateDict.rawDict.keys():
+            if key not in order:
+                del privateDict.rawDict[key]
+                if hasattr(privateDict, key):
+                    delattr(privateDict, key)
+
+    for cs in charStrings.values():
+        cs.decompile()
+        cs.program.append("endchar")
+    for subrSets in [cff.GlobalSubrs] + [
+        getattr(fd.Private, "Subrs", []) for fd in fdArray
+    ]:
+        for cs in subrSets:
+            cs.program.append("return")
+
+    # Add (optimal) width to CharStrings that need it.
+    widths = defaultdict(list)
+    metrics = otFont["hmtx"].metrics
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        if fdIndex == None:
+            fdIndex = 0
+        widths[fdIndex].append(metrics[glyphName][0])
+    for fdIndex, widthList in widths.items():
+        bestDefault, bestNominal = optimizeWidths(widthList)
+        private = fdArray[fdIndex].Private
+        private.defaultWidthX = bestDefault
+        private.nominalWidthX = bestNominal
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        if fdIndex == None:
+            fdIndex = 0
+        private = fdArray[fdIndex].Private
+        width = metrics[glyphName][0]
+        if width != private.defaultWidthX:
+            cs.program.insert(0, width - private.nominalWidthX)
+
+    mapping = {
+        name: ("cid" + str(n) if n else ".notdef")
+        for n, name in enumerate(topDict.charset)
+    }
+    topDict.charset = [
+        "cid" + str(n) if n else ".notdef" for n in range(len(topDict.charset))
+    ]
+    charStrings.charStrings = {
+        mapping[name]: v for name, v in charStrings.charStrings.items()
+    }
+
+    # I'm not sure why the following is *not* necessary. And it breaks
+    # the output if I add it.
+    # topDict.ROS = ("Adobe", "Identity", 0)
+
+
+def convertCFF2ToCFF(font, *, updatePostTable=True):
+    cff = font["CFF2"].cff
+    _convertCFF2ToCFF(cff, font)
+    del font["CFF2"]
+    table = font["CFF "] = newTable("CFF ")
+    table.cff = cff
+
+    if updatePostTable and "post" in font:
+        # Only version supported for fonts with CFF table is 0x00030000 not 0x20000
+        post = font["post"]
+        if post.formatType == 2.0:
+            post.formatType = 3.0
+
+
+def main(args=None):
+    """Convert CFF OTF font to CFF2 OTF font"""
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools cffLib.CFFToCFF2",
+        description="Upgrade a CFF font to CFF2.",
+    )
+    parser.add_argument(
+        "input", metavar="INPUT.ttf", help="Input OTF file with CFF table."
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="OUTPUT.ttf",
+        default=None,
+        help="Output instance OTF file (default: INPUT-CFF2.ttf).",
+    )
+    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.",
+    )
+    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)
+
+    from fontTools import configLogger
+
+    configLogger(
+        level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
+    )
+
+    import os
+
+    infile = options.input
+    if not os.path.isfile(infile):
+        parser.error("No such file '{}'".format(infile))
+
+    outfile = (
+        makeOutputFileName(infile, overWrite=True, suffix="-CFF")
+        if not options.output
+        else options.output
+    )
+
+    font = TTFont(infile, recalcTimestamp=options.recalc_timestamp, recalcBBoxes=False)
+
+    convertCFF2ToCFF(font)
+
+    log.info(
+        "Saving %s",
+        outfile,
+    )
+    font.save(outfile)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main(sys.argv[1:]))

infer_4_47_1/lib/python3.10/site-packages/fontTools/cffLib/CFFToCFF2.py

@@ -0,0 +1,305 @@
+"""CFF to CFF2 converter."""
+
+from fontTools.ttLib import TTFont, newTable
+from fontTools.misc.cliTools import makeOutputFileName
+from fontTools.misc.psCharStrings import T2WidthExtractor
+from fontTools.cffLib import (
+    TopDictIndex,
+    FDArrayIndex,
+    FontDict,
+    buildOrder,
+    topDictOperators,
+    privateDictOperators,
+    topDictOperators2,
+    privateDictOperators2,
+)
+from io import BytesIO
+import logging
+
+__all__ = ["convertCFFToCFF2", "main"]
+
+
+log = logging.getLogger("fontTools.cffLib")
+
+
+class _NominalWidthUsedError(Exception):
+    def __add__(self, other):
+        raise self
+
+    def __radd__(self, other):
+        raise self
+
+
+def _convertCFFToCFF2(cff, otFont):
+    """Converts this object from CFF format to CFF2 format. This conversion
+    is done 'in-place'. The conversion cannot be reversed.
+
+    This assumes a decompiled CFF table. (i.e. that the object has been
+    filled via :meth:`decompile` and e.g. not loaded from XML.)"""
+
+    # Clean up T2CharStrings
+
+    topDict = cff.topDictIndex[0]
+    fdArray = topDict.FDArray if hasattr(topDict, "FDArray") else None
+    charStrings = topDict.CharStrings
+    globalSubrs = cff.GlobalSubrs
+    localSubrs = (
+        [getattr(fd.Private, "Subrs", []) for fd in fdArray]
+        if fdArray
+        else (
+            [topDict.Private.Subrs]
+            if hasattr(topDict, "Private") and hasattr(topDict.Private, "Subrs")
+            else []
+        )
+    )
+
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        cs.decompile()
+
+    # Clean up subroutines first
+    for subrs in [globalSubrs] + localSubrs:
+        for subr in subrs:
+            program = subr.program
+            i = j = len(program)
+            try:
+                i = program.index("return")
+            except ValueError:
+                pass
+            try:
+                j = program.index("endchar")
+            except ValueError:
+                pass
+            program[min(i, j) :] = []
+
+    # Clean up glyph charstrings
+    removeUnusedSubrs = False
+    nominalWidthXError = _NominalWidthUsedError()
+    for glyphName in charStrings.keys():
+        cs, fdIndex = charStrings.getItemAndSelector(glyphName)
+        program = cs.program
+
+        thisLocalSubrs = (
+            localSubrs[fdIndex]
+            if fdIndex is not None
+            else (
+                getattr(topDict.Private, "Subrs", [])
+                if hasattr(topDict, "Private")
+                else []
+            )
+        )
+
+        # Intentionally use custom type for nominalWidthX, such that any
+        # CharString that has an explicit width encoded will throw back to us.
+        extractor = T2WidthExtractor(
+            thisLocalSubrs,
+            globalSubrs,
+            nominalWidthXError,
+            0,
+        )
+        try:
+            extractor.execute(cs)
+        except _NominalWidthUsedError:
+            # Program has explicit width. We want to drop it, but can't
+            # just pop the first number since it may be a subroutine call.
+            # Instead, when seeing that, we embed the subroutine and recurse.
+            # If this ever happened, we later prune unused subroutines.
+            while len(program) >= 2 and program[1] in ["callsubr", "callgsubr"]:
+                removeUnusedSubrs = True
+                subrNumber = program.pop(0)
+                assert isinstance(subrNumber, int), subrNumber
+                op = program.pop(0)
+                bias = extractor.localBias if op == "callsubr" else extractor.globalBias
+                subrNumber += bias
+                subrSet = thisLocalSubrs if op == "callsubr" else globalSubrs
+                subrProgram = subrSet[subrNumber].program
+                program[:0] = subrProgram
+            # Now pop the actual width
+            assert len(program) >= 1, program
+            program.pop(0)
+
+        if program and program[-1] == "endchar":
+            program.pop()
+
+    if removeUnusedSubrs:
+        cff.remove_unused_subroutines()
+
+    # Upconvert TopDict
+
+    cff.major = 2
+    cff2GetGlyphOrder = cff.otFont.getGlyphOrder
+    topDictData = TopDictIndex(None, cff2GetGlyphOrder)
+    for item in cff.topDictIndex:
+        # Iterate over, such that all are decompiled
+        topDictData.append(item)
+    cff.topDictIndex = topDictData
+    topDict = topDictData[0]
+    if hasattr(topDict, "Private"):
+        privateDict = topDict.Private
+    else:
+        privateDict = None
+    opOrder = buildOrder(topDictOperators2)
+    topDict.order = opOrder
+    topDict.cff2GetGlyphOrder = cff2GetGlyphOrder
+
+    if not hasattr(topDict, "FDArray"):
+        fdArray = topDict.FDArray = FDArrayIndex()
+        fdArray.strings = None
+        fdArray.GlobalSubrs = topDict.GlobalSubrs
+        topDict.GlobalSubrs.fdArray = fdArray
+        charStrings = topDict.CharStrings
+        if charStrings.charStringsAreIndexed:
+            charStrings.charStringsIndex.fdArray = fdArray
+        else:
+            charStrings.fdArray = fdArray
+        fontDict = FontDict()
+        fontDict.setCFF2(True)
+        fdArray.append(fontDict)
+        fontDict.Private = privateDict
+        privateOpOrder = buildOrder(privateDictOperators2)
+        if privateDict is not None:
+            for entry in privateDictOperators:
+                key = entry[1]
+                if key not in privateOpOrder:
+                    if key in privateDict.rawDict:
+                        # print "Removing private dict", key
+                        del privateDict.rawDict[key]
+                    if hasattr(privateDict, key):
+                        delattr(privateDict, key)
+                        # print "Removing privateDict attr", key
+    else:
+        # clean up the PrivateDicts in the fdArray
+        fdArray = topDict.FDArray
+        privateOpOrder = buildOrder(privateDictOperators2)
+        for fontDict in fdArray:
+            fontDict.setCFF2(True)
+            for key in list(fontDict.rawDict.keys()):
+                if key not in fontDict.order:
+                    del fontDict.rawDict[key]
+                    if hasattr(fontDict, key):
+                        delattr(fontDict, key)
+
+            privateDict = fontDict.Private
+            for entry in privateDictOperators:
+                key = entry[1]
+                if key not in privateOpOrder:
+                    if key in list(privateDict.rawDict.keys()):
+                        # print "Removing private dict", key
+                        del privateDict.rawDict[key]
+                    if hasattr(privateDict, key):
+                        delattr(privateDict, key)
+                        # print "Removing privateDict attr", key
+
+    # Now delete up the deprecated topDict operators from CFF 1.0
+    for entry in topDictOperators:
+        key = entry[1]
+        # We seem to need to keep the charset operator for now,
+        # or we fail to compile with some fonts, like AdditionFont.otf.
+        # I don't know which kind of CFF font those are. But keeping
+        # charset seems to work. It will be removed when we save and
+        # read the font again.
+        #
+        # AdditionFont.otf has <Encoding name="StandardEncoding"/>.
+        if key == "charset":
+            continue
+        if key not in opOrder:
+            if key in topDict.rawDict:
+                del topDict.rawDict[key]
+            if hasattr(topDict, key):
+                delattr(topDict, key)
+
+    # TODO(behdad): What does the following comment even mean? Both CFF and CFF2
+    # use the same T2Charstring class. I *think* what it means is that the CharStrings
+    # were loaded for CFF1, and we need to reload them for CFF2 to set varstore, etc
+    # on them. At least that's what I understand. It's probably safe to remove this
+    # and just set vstore where needed.
+    #
+    # See comment above about charset as well.
+
+    # At this point, the Subrs and Charstrings are all still T2Charstring class
+    # easiest to fix this by compiling, then decompiling again
+    file = BytesIO()
+    cff.compile(file, otFont, isCFF2=True)
+    file.seek(0)
+    cff.decompile(file, otFont, isCFF2=True)
+
+
+def convertCFFToCFF2(font):
+    cff = font["CFF "].cff
+    del font["CFF "]
+    _convertCFFToCFF2(cff, font)
+    table = font["CFF2"] = newTable("CFF2")
+    table.cff = cff
+
+
+def main(args=None):
+    """Convert CFF OTF font to CFF2 OTF font"""
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools cffLib.CFFToCFF2",
+        description="Upgrade a CFF font to CFF2.",
+    )
+    parser.add_argument(
+        "input", metavar="INPUT.ttf", help="Input OTF file with CFF table."
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="OUTPUT.ttf",
+        default=None,
+        help="Output instance OTF file (default: INPUT-CFF2.ttf).",
+    )
+    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.",
+    )
+    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)
+
+    from fontTools import configLogger
+
+    configLogger(
+        level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
+    )
+
+    import os
+
+    infile = options.input
+    if not os.path.isfile(infile):
+        parser.error("No such file '{}'".format(infile))
+
+    outfile = (
+        makeOutputFileName(infile, overWrite=True, suffix="-CFF2")
+        if not options.output
+        else options.output
+    )
+
+    font = TTFont(infile, recalcTimestamp=options.recalc_timestamp, recalcBBoxes=False)
+
+    convertCFFToCFF2(font)
+
+    log.info(
+        "Saving %s",
+        outfile,
+    )
+    font.save(outfile)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main(sys.argv[1:]))

infer_4_47_1/lib/python3.10/site-packages/fontTools/cffLib/specializer.py

@@ -0,0 +1,924 @@
+# -*- coding: utf-8 -*-
+
+"""T2CharString operator specializer and generalizer.
+
+PostScript glyph drawing operations can be expressed in multiple different
+ways. For example, as well as the ``lineto`` operator, there is also a
+``hlineto`` operator which draws a horizontal line, removing the need to
+specify a ``dx`` coordinate, and a ``vlineto`` operator which draws a
+vertical line, removing the need to specify a ``dy`` coordinate. As well
+as decompiling :class:`fontTools.misc.psCharStrings.T2CharString` objects
+into lists of operations, this module allows for conversion between general
+and specific forms of the operation.
+
+"""
+
+from fontTools.cffLib import maxStackLimit
+
+
+def stringToProgram(string):
+    if isinstance(string, str):
+        string = string.split()
+    program = []
+    for token in string:
+        try:
+            token = int(token)
+        except ValueError:
+            try:
+                token = float(token)
+            except ValueError:
+                pass
+        program.append(token)
+    return program
+
+
+def programToString(program):
+    return " ".join(str(x) for x in program)
+
+
+def programToCommands(program, getNumRegions=None):
+    """Takes a T2CharString program list and returns list of commands.
+    Each command is a two-tuple of commandname,arg-list.  The commandname might
+    be empty string if no commandname shall be emitted (used for glyph width,
+    hintmask/cntrmask argument, as well as stray arguments at the end of the
+    program (🤷).
+    'getNumRegions' may be None, or a callable object. It must return the
+    number of regions. 'getNumRegions' takes a single argument, vsindex. It
+    returns the numRegions for the vsindex.
+    The Charstring may or may not start with a width value. If the first
+    non-blend operator has an odd number of arguments, then the first argument is
+    a width, and is popped off. This is complicated with blend operators, as
+    there may be more than one before the first hint or moveto operator, and each
+    one reduces several arguments to just one list argument. We have to sum the
+    number of arguments that are not part of the blend arguments, and all the
+    'numBlends' values. We could instead have said that by definition, if there
+    is a blend operator, there is no width value, since CFF2 Charstrings don't
+    have width values. I discussed this with Behdad, and we are allowing for an
+    initial width value in this case because developers may assemble a CFF2
+    charstring from CFF Charstrings, which could have width values.
+    """
+
+    seenWidthOp = False
+    vsIndex = 0
+    lenBlendStack = 0
+    lastBlendIndex = 0
+    commands = []
+    stack = []
+    it = iter(program)
+
+    for token in it:
+        if not isinstance(token, str):
+            stack.append(token)
+            continue
+
+        if token == "blend":
+            assert getNumRegions is not None
+            numSourceFonts = 1 + getNumRegions(vsIndex)
+            # replace the blend op args on the stack with a single list
+            # containing all the blend op args.
+            numBlends = stack[-1]
+            numBlendArgs = numBlends * numSourceFonts + 1
+            # replace first blend op by a list of the blend ops.
+            stack[-numBlendArgs:] = [stack[-numBlendArgs:]]
+            lenStack = len(stack)
+            lenBlendStack += numBlends + lenStack - 1
+            lastBlendIndex = lenStack
+            # if a blend op exists, this is or will be a CFF2 charstring.
+            continue
+
+        elif token == "vsindex":
+            vsIndex = stack[-1]
+            assert type(vsIndex) is int
+
+        elif (not seenWidthOp) and token in {
+            "hstem",
+            "hstemhm",
+            "vstem",
+            "vstemhm",
+            "cntrmask",
+            "hintmask",
+            "hmoveto",
+            "vmoveto",
+            "rmoveto",
+            "endchar",
+        }:
+            seenWidthOp = True
+            parity = token in {"hmoveto", "vmoveto"}
+            if lenBlendStack:
+                # lenBlendStack has the number of args represented by the last blend
+                # arg and all the preceding args. We need to now add the number of
+                # args following the last blend arg.
+                numArgs = lenBlendStack + len(stack[lastBlendIndex:])
+            else:
+                numArgs = len(stack)
+            if numArgs and (numArgs % 2) ^ parity:
+                width = stack.pop(0)
+                commands.append(("", [width]))
+
+        if token in {"hintmask", "cntrmask"}:
+            if stack:
+                commands.append(("", stack))
+            commands.append((token, []))
+            commands.append(("", [next(it)]))
+        else:
+            commands.append((token, stack))
+        stack = []
+    if stack:
+        commands.append(("", stack))
+    return commands
+
+
+def _flattenBlendArgs(args):
+    token_list = []
+    for arg in args:
+        if isinstance(arg, list):
+            token_list.extend(arg)
+            token_list.append("blend")
+        else:
+            token_list.append(arg)
+    return token_list
+
+
+def commandsToProgram(commands):
+    """Takes a commands list as returned by programToCommands() and converts
+    it back to a T2CharString program list."""
+    program = []
+    for op, args in commands:
+        if any(isinstance(arg, list) for arg in args):
+            args = _flattenBlendArgs(args)
+        program.extend(args)
+        if op:
+            program.append(op)
+    return program
+
+
+def _everyN(el, n):
+    """Group the list el into groups of size n"""
+    l = len(el)
+    if l % n != 0:
+        raise ValueError(el)
+    for i in range(0, l, n):
+        yield el[i : i + n]
+
+
+class _GeneralizerDecombinerCommandsMap(object):
+    @staticmethod
+    def rmoveto(args):
+        if len(args) != 2:
+            raise ValueError(args)
+        yield ("rmoveto", args)
+
+    @staticmethod
+    def hmoveto(args):
+        if len(args) != 1:
+            raise ValueError(args)
+        yield ("rmoveto", [args[0], 0])
+
+    @staticmethod
+    def vmoveto(args):
+        if len(args) != 1:
+            raise ValueError(args)
+        yield ("rmoveto", [0, args[0]])
+
+    @staticmethod
+    def rlineto(args):
+        if not args:
+            raise ValueError(args)
+        for args in _everyN(args, 2):
+            yield ("rlineto", args)
+
+    @staticmethod
+    def hlineto(args):
+        if not args:
+            raise ValueError(args)
+        it = iter(args)
+        try:
+            while True:
+                yield ("rlineto", [next(it), 0])
+                yield ("rlineto", [0, next(it)])
+        except StopIteration:
+            pass
+
+    @staticmethod
+    def vlineto(args):
+        if not args:
+            raise ValueError(args)
+        it = iter(args)
+        try:
+            while True:
+                yield ("rlineto", [0, next(it)])
+                yield ("rlineto", [next(it), 0])
+        except StopIteration:
+            pass
+
+    @staticmethod
+    def rrcurveto(args):
+        if not args:
+            raise ValueError(args)
+        for args in _everyN(args, 6):
+            yield ("rrcurveto", args)
+
+    @staticmethod
+    def hhcurveto(args):
+        l = len(args)
+        if l < 4 or l % 4 > 1:
+            raise ValueError(args)
+        if l % 2 == 1:
+            yield ("rrcurveto", [args[1], args[0], args[2], args[3], args[4], 0])
+            args = args[5:]
+        for args in _everyN(args, 4):
+            yield ("rrcurveto", [args[0], 0, args[1], args[2], args[3], 0])
+
+    @staticmethod
+    def vvcurveto(args):
+        l = len(args)
+        if l < 4 or l % 4 > 1:
+            raise ValueError(args)
+        if l % 2 == 1:
+            yield ("rrcurveto", [args[0], args[1], args[2], args[3], 0, args[4]])
+            args = args[5:]
+        for args in _everyN(args, 4):
+            yield ("rrcurveto", [0, args[0], args[1], args[2], 0, args[3]])
+
+    @staticmethod
+    def hvcurveto(args):
+        l = len(args)
+        if l < 4 or l % 8 not in {0, 1, 4, 5}:
+            raise ValueError(args)
+        last_args = None
+        if l % 2 == 1:
+            lastStraight = l % 8 == 5
+            args, last_args = args[:-5], args[-5:]
+        it = _everyN(args, 4)
+        try:
+            while True:
+                args = next(it)
+                yield ("rrcurveto", [args[0], 0, args[1], args[2], 0, args[3]])
+                args = next(it)
+                yield ("rrcurveto", [0, args[0], args[1], args[2], args[3], 0])
+        except StopIteration:
+            pass
+        if last_args:
+            args = last_args
+            if lastStraight:
+                yield ("rrcurveto", [args[0], 0, args[1], args[2], args[4], args[3]])
+            else:
+                yield ("rrcurveto", [0, args[0], args[1], args[2], args[3], args[4]])
+
+    @staticmethod
+    def vhcurveto(args):
+        l = len(args)
+        if l < 4 or l % 8 not in {0, 1, 4, 5}:
+            raise ValueError(args)
+        last_args = None
+        if l % 2 == 1:
+            lastStraight = l % 8 == 5
+            args, last_args = args[:-5], args[-5:]
+        it = _everyN(args, 4)
+        try:
+            while True:
+                args = next(it)
+                yield ("rrcurveto", [0, args[0], args[1], args[2], args[3], 0])
+                args = next(it)
+                yield ("rrcurveto", [args[0], 0, args[1], args[2], 0, args[3]])
+        except StopIteration:
+            pass
+        if last_args:
+            args = last_args
+            if lastStraight:
+                yield ("rrcurveto", [0, args[0], args[1], args[2], args[3], args[4]])
+            else:
+                yield ("rrcurveto", [args[0], 0, args[1], args[2], args[4], args[3]])
+
+    @staticmethod
+    def rcurveline(args):
+        l = len(args)
+        if l < 8 or l % 6 != 2:
+            raise ValueError(args)
+        args, last_args = args[:-2], args[-2:]
+        for args in _everyN(args, 6):
+            yield ("rrcurveto", args)
+        yield ("rlineto", last_args)
+
+    @staticmethod
+    def rlinecurve(args):
+        l = len(args)
+        if l < 8 or l % 2 != 0:
+            raise ValueError(args)
+        args, last_args = args[:-6], args[-6:]
+        for args in _everyN(args, 2):
+            yield ("rlineto", args)
+        yield ("rrcurveto", last_args)
+
+
+def _convertBlendOpToArgs(blendList):
+    # args is list of blend op args. Since we are supporting
+    # recursive blend op calls, some of these args may also
+    # be a list of blend op args, and need to be converted before
+    # we convert the current list.
+    if any([isinstance(arg, list) for arg in blendList]):
+        args = [
+            i
+            for e in blendList
+            for i in (_convertBlendOpToArgs(e) if isinstance(e, list) else [e])
+        ]
+    else:
+        args = blendList
+
+    # We now know that blendList contains a blend op argument list, even if
+    # some of the args are lists that each contain a blend op argument list.
+    # 	Convert from:
+    # 		[default font arg sequence x0,...,xn] + [delta tuple for x0] + ... + [delta tuple for xn]
+    # 	to:
+    # 		[ [x0] + [delta tuple for x0],
+    #                 ...,
+    #          [xn] + [delta tuple for xn] ]
+    numBlends = args[-1]
+    # Can't use args.pop() when the args are being used in a nested list
+    # comprehension. See calling context
+    args = args[:-1]
+
+    l = len(args)
+    numRegions = l // numBlends - 1
+    if not (numBlends * (numRegions + 1) == l):
+        raise ValueError(blendList)
+
+    defaultArgs = [[arg] for arg in args[:numBlends]]
+    deltaArgs = args[numBlends:]
+    numDeltaValues = len(deltaArgs)
+    deltaList = [
+        deltaArgs[i : i + numRegions] for i in range(0, numDeltaValues, numRegions)
+    ]
+    blend_args = [a + b + [1] for a, b in zip(defaultArgs, deltaList)]
+    return blend_args
+
+
+def generalizeCommands(commands, ignoreErrors=False):
+    result = []
+    mapping = _GeneralizerDecombinerCommandsMap
+    for op, args in commands:
+        # First, generalize any blend args in the arg list.
+        if any([isinstance(arg, list) for arg in args]):
+            try:
+                args = [
+                    n
+                    for arg in args
+                    for n in (
+                        _convertBlendOpToArgs(arg) if isinstance(arg, list) else [arg]
+                    )
+                ]
+            except ValueError:
+                if ignoreErrors:
+                    # Store op as data, such that consumers of commands do not have to
+                    # deal with incorrect number of arguments.
+                    result.append(("", args))
+                    result.append(("", [op]))
+                else:
+                    raise
+
+        func = getattr(mapping, op, None)
+        if func is None:
+            result.append((op, args))
+            continue
+        try:
+            for command in func(args):
+                result.append(command)
+        except ValueError:
+            if ignoreErrors:
+                # Store op as data, such that consumers of commands do not have to
+                # deal with incorrect number of arguments.
+                result.append(("", args))
+                result.append(("", [op]))
+            else:
+                raise
+    return result
+
+
+def generalizeProgram(program, getNumRegions=None, **kwargs):
+    return commandsToProgram(
+        generalizeCommands(programToCommands(program, getNumRegions), **kwargs)
+    )
+
+
+def _categorizeVector(v):
+    """
+    Takes X,Y vector v and returns one of r, h, v, or 0 depending on which
+    of X and/or Y are zero, plus tuple of nonzero ones.  If both are zero,
+    it returns a single zero still.
+
+    >>> _categorizeVector((0,0))
+    ('0', (0,))
+    >>> _categorizeVector((1,0))
+    ('h', (1,))
+    >>> _categorizeVector((0,2))
+    ('v', (2,))
+    >>> _categorizeVector((1,2))
+    ('r', (1, 2))
+    """
+    if not v[0]:
+        if not v[1]:
+            return "0", v[:1]
+        else:
+            return "v", v[1:]
+    else:
+        if not v[1]:
+            return "h", v[:1]
+        else:
+            return "r", v
+
+
+def _mergeCategories(a, b):
+    if a == "0":
+        return b
+    if b == "0":
+        return a
+    if a == b:
+        return a
+    return None
+
+
+def _negateCategory(a):
+    if a == "h":
+        return "v"
+    if a == "v":
+        return "h"
+    assert a in "0r"
+    return a
+
+
+def _convertToBlendCmds(args):
+    # return a list of blend commands, and
+    # the remaining non-blended args, if any.
+    num_args = len(args)
+    stack_use = 0
+    new_args = []
+    i = 0
+    while i < num_args:
+        arg = args[i]
+        i += 1
+        if not isinstance(arg, list):
+            new_args.append(arg)
+            stack_use += 1
+        else:
+            prev_stack_use = stack_use
+            # The arg is a tuple of blend values.
+            # These are each (master 0,delta 1..delta n, 1)
+            # Combine as many successive tuples as we can,
+            # up to the max stack limit.
+            num_sources = len(arg) - 1
+            blendlist = [arg]
+            stack_use += 1 + num_sources  # 1 for the num_blends arg
+
+            # if we are here, max stack is the CFF2 max stack.
+            # I use the CFF2 max stack limit here rather than
+            # the 'maxstack' chosen by the client, as the default
+            # maxstack may have been used unintentionally. For all
+            # the other operators, this just produces a little less
+            # optimization, but here it puts a hard (and low) limit
+            # on the number of source fonts that can be used.
+            #
+            # Make sure the stack depth does not exceed (maxstack - 1), so
+            # that subroutinizer can insert subroutine calls at any point.
+            while (
+                (i < num_args)
+                and isinstance(args[i], list)
+                and stack_use + num_sources < maxStackLimit
+            ):
+                blendlist.append(args[i])
+                i += 1
+                stack_use += num_sources
+            # blendList now contains as many single blend tuples as can be
+            # combined without exceeding the CFF2 stack limit.
+            num_blends = len(blendlist)
+            # append the 'num_blends' default font values
+            blend_args = []
+            for arg in blendlist:
+                blend_args.append(arg[0])
+            for arg in blendlist:
+                assert arg[-1] == 1
+                blend_args.extend(arg[1:-1])
+            blend_args.append(num_blends)
+            new_args.append(blend_args)
+            stack_use = prev_stack_use + num_blends
+
+    return new_args
+
+
+def _addArgs(a, b):
+    if isinstance(b, list):
+        if isinstance(a, list):
+            if len(a) != len(b) or a[-1] != b[-1]:
+                raise ValueError()
+            return [_addArgs(va, vb) for va, vb in zip(a[:-1], b[:-1])] + [a[-1]]
+        else:
+            a, b = b, a
+    if isinstance(a, list):
+        assert a[-1] == 1
+        return [_addArgs(a[0], b)] + a[1:]
+    return a + b
+
+
+def _argsStackUse(args):
+    stackLen = 0
+    maxLen = 0
+    for arg in args:
+        if type(arg) is list:
+            # Blended arg
+            maxLen = max(maxLen, stackLen + _argsStackUse(arg))
+            stackLen += arg[-1]
+        else:
+            stackLen += 1
+    return max(stackLen, maxLen)
+
+
+def specializeCommands(
+    commands,
+    ignoreErrors=False,
+    generalizeFirst=True,
+    preserveTopology=False,
+    maxstack=48,
+):
+    # We perform several rounds of optimizations.  They are carefully ordered and are:
+    #
+    # 0. Generalize commands.
+    #    This ensures that they are in our expected simple form, with each line/curve only
+    #    having arguments for one segment, and using the generic form (rlineto/rrcurveto).
+    #    If caller is sure the input is in this form, they can turn off generalization to
+    #    save time.
+    #
+    # 1. Combine successive rmoveto operations.
+    #
+    # 2. Specialize rmoveto/rlineto/rrcurveto operators into horizontal/vertical variants.
+    #    We specialize into some, made-up, variants as well, which simplifies following
+    #    passes.
+    #
+    # 3. Merge or delete redundant operations, to the extent requested.
+    #    OpenType spec declares point numbers in CFF undefined.  As such, we happily
+    #    change topology.  If client relies on point numbers (in GPOS anchors, or for
+    #    hinting purposes(what?)) they can turn this off.
+    #
+    # 4. Peephole optimization to revert back some of the h/v variants back into their
+    #    original "relative" operator (rline/rrcurveto) if that saves a byte.
+    #
+    # 5. Combine adjacent operators when possible, minding not to go over max stack size.
+    #
+    # 6. Resolve any remaining made-up operators into real operators.
+    #
+    # I have convinced myself that this produces optimal bytecode (except for, possibly
+    # one byte each time maxstack size prohibits combining.)  YMMV, but you'd be wrong. :-)
+    # A dynamic-programming approach can do the same but would be significantly slower.
+    #
+    # 7. For any args which are blend lists, convert them to a blend command.
+
+    # 0. Generalize commands.
+    if generalizeFirst:
+        commands = generalizeCommands(commands, ignoreErrors=ignoreErrors)
+    else:
+        commands = list(commands)  # Make copy since we modify in-place later.
+
+    # 1. Combine successive rmoveto operations.
+    for i in range(len(commands) - 1, 0, -1):
+        if "rmoveto" == commands[i][0] == commands[i - 1][0]:
+            v1, v2 = commands[i - 1][1], commands[i][1]
+            commands[i - 1] = ("rmoveto", [v1[0] + v2[0], v1[1] + v2[1]])
+            del commands[i]
+
+    # 2. Specialize rmoveto/rlineto/rrcurveto operators into horizontal/vertical variants.
+    #
+    # We, in fact, specialize into more, made-up, variants that special-case when both
+    # X and Y components are zero.  This simplifies the following optimization passes.
+    # This case is rare, but OCD does not let me skip it.
+    #
+    # After this round, we will have four variants that use the following mnemonics:
+    #
+    #  - 'r' for relative,   ie. non-zero X and non-zero Y,
+    #  - 'h' for horizontal, ie. zero X and non-zero Y,
+    #  - 'v' for vertical,   ie. non-zero X and zero Y,
+    #  - '0' for zeros,      ie. zero X and zero Y.
+    #
+    # The '0' pseudo-operators are not part of the spec, but help simplify the following
+    # optimization rounds.  We resolve them at the end.  So, after this, we will have four
+    # moveto and four lineto variants:
+    #
+    #  - 0moveto, 0lineto
+    #  - hmoveto, hlineto
+    #  - vmoveto, vlineto
+    #  - rmoveto, rlineto
+    #
+    # and sixteen curveto variants.  For example, a '0hcurveto' operator means a curve
+    # dx0,dy0,dx1,dy1,dx2,dy2,dx3,dy3 where dx0, dx1, and dy3 are zero but not dx3.
+    # An 'rvcurveto' means dx3 is zero but not dx0,dy0,dy3.
+    #
+    # There are nine different variants of curves without the '0'.  Those nine map exactly
+    # to the existing curve variants in the spec: rrcurveto, and the four variants hhcurveto,
+    # vvcurveto, hvcurveto, and vhcurveto each cover two cases, one with an odd number of
+    # arguments and one without.  Eg. an hhcurveto with an extra argument (odd number of
+    # arguments) is in fact an rhcurveto.  The operators in the spec are designed such that
+    # all four of rhcurveto, rvcurveto, hrcurveto, and vrcurveto are encodable for one curve.
+    #
+    # Of the curve types with '0', the 00curveto is equivalent to a lineto variant.  The rest
+    # of the curve types with a 0 need to be encoded as a h or v variant.  Ie. a '0' can be
+    # thought of a "don't care" and can be used as either an 'h' or a 'v'.  As such, we always
+    # encode a number 0 as argument when we use a '0' variant.  Later on, we can just substitute
+    # the '0' with either 'h' or 'v' and it works.
+    #
+    # When we get to curve splines however, things become more complicated...  XXX finish this.
+    # There's one more complexity with splines.  If one side of the spline is not horizontal or
+    # vertical (or zero), ie. if it's 'r', then it limits which spline types we can encode.
+    # Only hhcurveto and vvcurveto operators can encode a spline starting with 'r', and
+    # only hvcurveto and vhcurveto operators can encode a spline ending with 'r'.
+    # This limits our merge opportunities later.
+    #
+    for i in range(len(commands)):
+        op, args = commands[i]
+
+        if op in {"rmoveto", "rlineto"}:
+            c, args = _categorizeVector(args)
+            commands[i] = c + op[1:], args
+            continue
+
+        if op == "rrcurveto":
+            c1, args1 = _categorizeVector(args[:2])
+            c2, args2 = _categorizeVector(args[-2:])
+            commands[i] = c1 + c2 + "curveto", args1 + args[2:4] + args2
+            continue
+
+    # 3. Merge or delete redundant operations, to the extent requested.
+    #
+    # TODO
+    # A 0moveto that comes before all other path operations can be removed.
+    # though I find conflicting evidence for this.
+    #
+    # TODO
+    # "If hstem and vstem hints are both declared at the beginning of a
+    # CharString, and this sequence is followed directly by the hintmask or
+    # cntrmask operators, then the vstem hint operator (or, if applicable,
+    # the vstemhm operator) need not be included."
+    #
+    # "The sequence and form of a CFF2 CharString program may be represented as:
+    # {hs* vs* cm* hm* mt subpath}? {mt subpath}*"
+    #
+    # https://www.microsoft.com/typography/otspec/cff2charstr.htm#section3.1
+    #
+    # For Type2 CharStrings the sequence is:
+    # w? {hs* vs* cm* hm* mt subpath}? {mt subpath}* endchar"
+
+    # Some other redundancies change topology (point numbers).
+    if not preserveTopology:
+        for i in range(len(commands) - 1, -1, -1):
+            op, args = commands[i]
+
+            # A 00curveto is demoted to a (specialized) lineto.
+            if op == "00curveto":
+                assert len(args) == 4
+                c, args = _categorizeVector(args[1:3])
+                op = c + "lineto"
+                commands[i] = op, args
+                # and then...
+
+            # A 0lineto can be deleted.
+            if op == "0lineto":
+                del commands[i]
+                continue
+
+            # Merge adjacent hlineto's and vlineto's.
+            # In CFF2 charstrings from variable fonts, each
+            # arg item may be a list of blendable values, one from
+            # each source font.
+            if i and op in {"hlineto", "vlineto"} and (op == commands[i - 1][0]):
+                _, other_args = commands[i - 1]
+                assert len(args) == 1 and len(other_args) == 1
+                try:
+                    new_args = [_addArgs(args[0], other_args[0])]
+                except ValueError:
+                    continue
+                commands[i - 1] = (op, new_args)
+                del commands[i]
+                continue
+
+    # 4. Peephole optimization to revert back some of the h/v variants back into their
+    #    original "relative" operator (rline/rrcurveto) if that saves a byte.
+    for i in range(1, len(commands) - 1):
+        op, args = commands[i]
+        prv, nxt = commands[i - 1][0], commands[i + 1][0]
+
+        if op in {"0lineto", "hlineto", "vlineto"} and prv == nxt == "rlineto":
+            assert len(args) == 1
+            args = [0, args[0]] if op[0] == "v" else [args[0], 0]
+            commands[i] = ("rlineto", args)
+            continue
+
+        if op[2:] == "curveto" and len(args) == 5 and prv == nxt == "rrcurveto":
+            assert (op[0] == "r") ^ (op[1] == "r")
+            if op[0] == "v":
+                pos = 0
+            elif op[0] != "r":
+                pos = 1
+            elif op[1] == "v":
+                pos = 4
+            else:
+                pos = 5
+            # Insert, while maintaining the type of args (can be tuple or list).
+            args = args[:pos] + type(args)((0,)) + args[pos:]
+            commands[i] = ("rrcurveto", args)
+            continue
+
+    # 5. Combine adjacent operators when possible, minding not to go over max stack size.
+    stackUse = _argsStackUse(commands[-1][1]) if commands else 0
+    for i in range(len(commands) - 1, 0, -1):
+        op1, args1 = commands[i - 1]
+        op2, args2 = commands[i]
+        new_op = None
+
+        # Merge logic...
+        if {op1, op2} <= {"rlineto", "rrcurveto"}:
+            if op1 == op2:
+                new_op = op1
+            else:
+                l = len(args2)
+                if op2 == "rrcurveto" and l == 6:
+                    new_op = "rlinecurve"
+                elif l == 2:
+                    new_op = "rcurveline"
+
+        elif (op1, op2) in {("rlineto", "rlinecurve"), ("rrcurveto", "rcurveline")}:
+            new_op = op2
+
+        elif {op1, op2} == {"vlineto", "hlineto"}:
+            new_op = op1
+
+        elif "curveto" == op1[2:] == op2[2:]:
+            d0, d1 = op1[:2]
+            d2, d3 = op2[:2]
+
+            if d1 == "r" or d2 == "r" or d0 == d3 == "r":
+                continue
+
+            d = _mergeCategories(d1, d2)
+            if d is None:
+                continue
+            if d0 == "r":
+                d = _mergeCategories(d, d3)
+                if d is None:
+                    continue
+                new_op = "r" + d + "curveto"
+            elif d3 == "r":
+                d0 = _mergeCategories(d0, _negateCategory(d))
+                if d0 is None:
+                    continue
+                new_op = d0 + "r" + "curveto"
+            else:
+                d0 = _mergeCategories(d0, d3)
+                if d0 is None:
+                    continue
+                new_op = d0 + d + "curveto"
+
+        # Make sure the stack depth does not exceed (maxstack - 1), so
+        # that subroutinizer can insert subroutine calls at any point.
+        args1StackUse = _argsStackUse(args1)
+        combinedStackUse = max(args1StackUse, len(args1) + stackUse)
+        if new_op and combinedStackUse < maxstack:
+            commands[i - 1] = (new_op, args1 + args2)
+            del commands[i]
+            stackUse = combinedStackUse
+        else:
+            stackUse = args1StackUse
+
+    # 6. Resolve any remaining made-up operators into real operators.
+    for i in range(len(commands)):
+        op, args = commands[i]
+
+        if op in {"0moveto", "0lineto"}:
+            commands[i] = "h" + op[1:], args
+            continue
+
+        if op[2:] == "curveto" and op[:2] not in {"rr", "hh", "vv", "vh", "hv"}:
+            l = len(args)
+
+            op0, op1 = op[:2]
+            if (op0 == "r") ^ (op1 == "r"):
+                assert l % 2 == 1
+            if op0 == "0":
+                op0 = "h"
+            if op1 == "0":
+                op1 = "h"
+            if op0 == "r":
+                op0 = op1
+            if op1 == "r":
+                op1 = _negateCategory(op0)
+            assert {op0, op1} <= {"h", "v"}, (op0, op1)
+
+            if l % 2:
+                if op0 != op1:  # vhcurveto / hvcurveto
+                    if (op0 == "h") ^ (l % 8 == 1):
+                        # Swap last two args order
+                        args = args[:-2] + args[-1:] + args[-2:-1]
+                else:  # hhcurveto / vvcurveto
+                    if op0 == "h":  # hhcurveto
+                        # Swap first two args order
+                        args = args[1:2] + args[:1] + args[2:]
+
+            commands[i] = op0 + op1 + "curveto", args
+            continue
+
+    # 7. For any series of args which are blend lists, convert the series to a single blend arg.
+    for i in range(len(commands)):
+        op, args = commands[i]
+        if any(isinstance(arg, list) for arg in args):
+            commands[i] = op, _convertToBlendCmds(args)
+
+    return commands
+
+
+def specializeProgram(program, getNumRegions=None, **kwargs):
+    return commandsToProgram(
+        specializeCommands(programToCommands(program, getNumRegions), **kwargs)
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) == 1:
+        import doctest
+
+        sys.exit(doctest.testmod().failed)
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools cffLib.specializer",
+        description="CFF CharString generalizer/specializer",
+    )
+    parser.add_argument("program", metavar="command", nargs="*", help="Commands.")
+    parser.add_argument(
+        "--num-regions",
+        metavar="NumRegions",
+        nargs="*",
+        default=None,
+        help="Number of variable-font regions for blend opertaions.",
+    )
+    parser.add_argument(
+        "--font",
+        metavar="FONTFILE",
+        default=None,
+        help="CFF2 font to specialize.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        type=str,
+        help="Output font file name.",
+    )
+
+    options = parser.parse_args(sys.argv[1:])
+
+    if options.program:
+        getNumRegions = (
+            None
+            if options.num_regions is None
+            else lambda vsIndex: int(
+                options.num_regions[0 if vsIndex is None else vsIndex]
+            )
+        )
+
+        program = stringToProgram(options.program)
+        print("Program:")
+        print(programToString(program))
+        commands = programToCommands(program, getNumRegions)
+        print("Commands:")
+        print(commands)
+        program2 = commandsToProgram(commands)
+        print("Program from commands:")
+        print(programToString(program2))
+        assert program == program2
+        print("Generalized program:")
+        print(programToString(generalizeProgram(program, getNumRegions)))
+        print("Specialized program:")
+        print(programToString(specializeProgram(program, getNumRegions)))
+
+    if options.font:
+        from fontTools.ttLib import TTFont
+
+        font = TTFont(options.font)
+        cff2 = font["CFF2"].cff.topDictIndex[0]
+        charstrings = cff2.CharStrings
+        for glyphName in charstrings.keys():
+            charstring = charstrings[glyphName]
+            charstring.decompile()
+            getNumRegions = charstring.private.getNumRegions
+            charstring.program = specializeProgram(
+                charstring.program, getNumRegions, maxstack=maxStackLimit
+            )
+
+        if options.output_file is None:
+            from fontTools.misc.cliTools import makeOutputFileName
+
+            outfile = makeOutputFileName(
+                options.font, overWrite=True, suffix=".specialized"
+            )
+        else:
+            outfile = options.output_file
+        if outfile:
+            print("Saving", outfile)
+            font.save(outfile)

infer_4_47_1/lib/python3.10/site-packages/fontTools/cffLib/transforms.py

@@ -0,0 +1,490 @@
+from fontTools.misc.psCharStrings import (
+    SimpleT2Decompiler,
+    T2WidthExtractor,
+    calcSubrBias,
+)
+
+
+def _uniq_sort(l):
+    return sorted(set(l))
+
+
+class StopHintCountEvent(Exception):
+    pass
+
+
+class _DesubroutinizingT2Decompiler(SimpleT2Decompiler):
+    stop_hintcount_ops = (
+        "op_hintmask",
+        "op_cntrmask",
+        "op_rmoveto",
+        "op_hmoveto",
+        "op_vmoveto",
+    )
+
+    def __init__(self, localSubrs, globalSubrs, private=None):
+        SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs, private)
+
+    def execute(self, charString):
+        self.need_hintcount = True  # until proven otherwise
+        for op_name in self.stop_hintcount_ops:
+            setattr(self, op_name, self.stop_hint_count)
+
+        if hasattr(charString, "_desubroutinized"):
+            # If a charstring has already been desubroutinized, we will still
+            # need to execute it if we need to count hints in order to
+            # compute the byte length for mask arguments, and haven't finished
+            # counting hints pairs.
+            if self.need_hintcount and self.callingStack:
+                try:
+                    SimpleT2Decompiler.execute(self, charString)
+                except StopHintCountEvent:
+                    del self.callingStack[-1]
+            return
+
+        charString._patches = []
+        SimpleT2Decompiler.execute(self, charString)
+        desubroutinized = charString.program[:]
+        for idx, expansion in reversed(charString._patches):
+            assert idx >= 2
+            assert desubroutinized[idx - 1] in [
+                "callsubr",
+                "callgsubr",
+            ], desubroutinized[idx - 1]
+            assert type(desubroutinized[idx - 2]) == int
+            if expansion[-1] == "return":
+                expansion = expansion[:-1]
+            desubroutinized[idx - 2 : idx] = expansion
+        if not self.private.in_cff2:
+            if "endchar" in desubroutinized:
+                # Cut off after first endchar
+                desubroutinized = desubroutinized[
+                    : desubroutinized.index("endchar") + 1
+                ]
+
+        charString._desubroutinized = desubroutinized
+        del charString._patches
+
+    def op_callsubr(self, index):
+        subr = self.localSubrs[self.operandStack[-1] + self.localBias]
+        SimpleT2Decompiler.op_callsubr(self, index)
+        self.processSubr(index, subr)
+
+    def op_callgsubr(self, index):
+        subr = self.globalSubrs[self.operandStack[-1] + self.globalBias]
+        SimpleT2Decompiler.op_callgsubr(self, index)
+        self.processSubr(index, subr)
+
+    def stop_hint_count(self, *args):
+        self.need_hintcount = False
+        for op_name in self.stop_hintcount_ops:
+            setattr(self, op_name, None)
+        cs = self.callingStack[-1]
+        if hasattr(cs, "_desubroutinized"):
+            raise StopHintCountEvent()
+
+    def op_hintmask(self, index):
+        SimpleT2Decompiler.op_hintmask(self, index)
+        if self.need_hintcount:
+            self.stop_hint_count()
+
+    def processSubr(self, index, subr):
+        cs = self.callingStack[-1]
+        if not hasattr(cs, "_desubroutinized"):
+            cs._patches.append((index, subr._desubroutinized))
+
+
+def desubroutinize(cff):
+    for fontName in cff.fontNames:
+        font = cff[fontName]
+        cs = font.CharStrings
+        for c in cs.values():
+            c.decompile()
+            subrs = getattr(c.private, "Subrs", [])
+            decompiler = _DesubroutinizingT2Decompiler(subrs, c.globalSubrs, c.private)
+            decompiler.execute(c)
+            c.program = c._desubroutinized
+            del c._desubroutinized
+        # Delete all the local subrs
+        if hasattr(font, "FDArray"):
+            for fd in font.FDArray:
+                pd = fd.Private
+                if hasattr(pd, "Subrs"):
+                    del pd.Subrs
+                if "Subrs" in pd.rawDict:
+                    del pd.rawDict["Subrs"]
+        else:
+            pd = font.Private
+            if hasattr(pd, "Subrs"):
+                del pd.Subrs
+            if "Subrs" in pd.rawDict:
+                del pd.rawDict["Subrs"]
+    # as well as the global subrs
+    cff.GlobalSubrs.clear()
+
+
+class _MarkingT2Decompiler(SimpleT2Decompiler):
+    def __init__(self, localSubrs, globalSubrs, private):
+        SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs, private)
+        for subrs in [localSubrs, globalSubrs]:
+            if subrs and not hasattr(subrs, "_used"):
+                subrs._used = set()
+
+    def op_callsubr(self, index):
+        self.localSubrs._used.add(self.operandStack[-1] + self.localBias)
+        SimpleT2Decompiler.op_callsubr(self, index)
+
+    def op_callgsubr(self, index):
+        self.globalSubrs._used.add(self.operandStack[-1] + self.globalBias)
+        SimpleT2Decompiler.op_callgsubr(self, index)
+
+
+class _DehintingT2Decompiler(T2WidthExtractor):
+    class Hints(object):
+        def __init__(self):
+            # Whether calling this charstring produces any hint stems
+            # Note that if a charstring starts with hintmask, it will
+            # have has_hint set to True, because it *might* produce an
+            # implicit vstem if called under certain conditions.
+            self.has_hint = False
+            # Index to start at to drop all hints
+            self.last_hint = 0
+            # Index up to which we know more hints are possible.
+            # Only relevant if status is 0 or 1.
+            self.last_checked = 0
+            # The status means:
+            # 0: after dropping hints, this charstring is empty
+            # 1: after dropping hints, there may be more hints
+            # 	continuing after this, or there might be
+            # 	other things.  Not clear yet.
+            # 2: no more hints possible after this charstring
+            self.status = 0
+            # Has hintmask instructions; not recursive
+            self.has_hintmask = False
+            # List of indices of calls to empty subroutines to remove.
+            self.deletions = []
+
+        pass
+
+    def __init__(
+        self, css, localSubrs, globalSubrs, nominalWidthX, defaultWidthX, private=None
+    ):
+        self._css = css
+        T2WidthExtractor.__init__(
+            self, localSubrs, globalSubrs, nominalWidthX, defaultWidthX
+        )
+        self.private = private
+
+    def execute(self, charString):
+        old_hints = charString._hints if hasattr(charString, "_hints") else None
+        charString._hints = self.Hints()
+
+        T2WidthExtractor.execute(self, charString)
+
+        hints = charString._hints
+
+        if hints.has_hint or hints.has_hintmask:
+            self._css.add(charString)
+
+        if hints.status != 2:
+            # Check from last_check, make sure we didn't have any operators.
+            for i in range(hints.last_checked, len(charString.program) - 1):
+                if isinstance(charString.program[i], str):
+                    hints.status = 2
+                    break
+                else:
+                    hints.status = 1  # There's *something* here
+            hints.last_checked = len(charString.program)
+
+        if old_hints:
+            assert hints.__dict__ == old_hints.__dict__
+
+    def op_callsubr(self, index):
+        subr = self.localSubrs[self.operandStack[-1] + self.localBias]
+        T2WidthExtractor.op_callsubr(self, index)
+        self.processSubr(index, subr)
+
+    def op_callgsubr(self, index):
+        subr = self.globalSubrs[self.operandStack[-1] + self.globalBias]
+        T2WidthExtractor.op_callgsubr(self, index)
+        self.processSubr(index, subr)
+
+    def op_hstem(self, index):
+        T2WidthExtractor.op_hstem(self, index)
+        self.processHint(index)
+
+    def op_vstem(self, index):
+        T2WidthExtractor.op_vstem(self, index)
+        self.processHint(index)
+
+    def op_hstemhm(self, index):
+        T2WidthExtractor.op_hstemhm(self, index)
+        self.processHint(index)
+
+    def op_vstemhm(self, index):
+        T2WidthExtractor.op_vstemhm(self, index)
+        self.processHint(index)
+
+    def op_hintmask(self, index):
+        rv = T2WidthExtractor.op_hintmask(self, index)
+        self.processHintmask(index)
+        return rv
+
+    def op_cntrmask(self, index):
+        rv = T2WidthExtractor.op_cntrmask(self, index)
+        self.processHintmask(index)
+        return rv
+
+    def processHintmask(self, index):
+        cs = self.callingStack[-1]
+        hints = cs._hints
+        hints.has_hintmask = True
+        if hints.status != 2:
+            # Check from last_check, see if we may be an implicit vstem
+            for i in range(hints.last_checked, index - 1):
+                if isinstance(cs.program[i], str):
+                    hints.status = 2
+                    break
+            else:
+                # We are an implicit vstem
+                hints.has_hint = True
+                hints.last_hint = index + 1
+                hints.status = 0
+        hints.last_checked = index + 1
+
+    def processHint(self, index):
+        cs = self.callingStack[-1]
+        hints = cs._hints
+        hints.has_hint = True
+        hints.last_hint = index
+        hints.last_checked = index
+
+    def processSubr(self, index, subr):
+        cs = self.callingStack[-1]
+        hints = cs._hints
+        subr_hints = subr._hints
+
+        # Check from last_check, make sure we didn't have
+        # any operators.
+        if hints.status != 2:
+            for i in range(hints.last_checked, index - 1):
+                if isinstance(cs.program[i], str):
+                    hints.status = 2
+                    break
+            hints.last_checked = index
+
+        if hints.status != 2:
+            if subr_hints.has_hint:
+                hints.has_hint = True
+
+                # Decide where to chop off from
+                if subr_hints.status == 0:
+                    hints.last_hint = index
+                else:
+                    hints.last_hint = index - 2  # Leave the subr call in
+
+        elif subr_hints.status == 0:
+            hints.deletions.append(index)
+
+        hints.status = max(hints.status, subr_hints.status)
+
+
+def _cs_subset_subroutines(charstring, subrs, gsubrs):
+    p = charstring.program
+    for i in range(1, len(p)):
+        if p[i] == "callsubr":
+            assert isinstance(p[i - 1], int)
+            p[i - 1] = subrs._used.index(p[i - 1] + subrs._old_bias) - subrs._new_bias
+        elif p[i] == "callgsubr":
+            assert isinstance(p[i - 1], int)
+            p[i - 1] = (
+                gsubrs._used.index(p[i - 1] + gsubrs._old_bias) - gsubrs._new_bias
+            )
+
+
+def _cs_drop_hints(charstring):
+    hints = charstring._hints
+
+    if hints.deletions:
+        p = charstring.program
+        for idx in reversed(hints.deletions):
+            del p[idx - 2 : idx]
+
+    if hints.has_hint:
+        assert not hints.deletions or hints.last_hint <= hints.deletions[0]
+        charstring.program = charstring.program[hints.last_hint :]
+        if not charstring.program:
+            # TODO CFF2 no need for endchar.
+            charstring.program.append("endchar")
+        if hasattr(charstring, "width"):
+            # Insert width back if needed
+            if charstring.width != charstring.private.defaultWidthX:
+                # For CFF2 charstrings, this should never happen
+                assert (
+                    charstring.private.defaultWidthX is not None
+                ), "CFF2 CharStrings must not have an initial width value"
+                charstring.program.insert(
+                    0, charstring.width - charstring.private.nominalWidthX
+                )
+
+    if hints.has_hintmask:
+        i = 0
+        p = charstring.program
+        while i < len(p):
+            if p[i] in ["hintmask", "cntrmask"]:
+                assert i + 1 <= len(p)
+                del p[i : i + 2]
+                continue
+            i += 1
+
+    assert len(charstring.program)
+
+    del charstring._hints
+
+
+def remove_hints(cff, *, removeUnusedSubrs: bool = True):
+    for fontname in cff.keys():
+        font = cff[fontname]
+        cs = font.CharStrings
+        # This can be tricky, but doesn't have to. What we do is:
+        #
+        # - Run all used glyph charstrings and recurse into subroutines,
+        # - For each charstring (including subroutines), if it has any
+        #   of the hint stem operators, we mark it as such.
+        #   Upon returning, for each charstring we note all the
+        #   subroutine calls it makes that (recursively) contain a stem,
+        # - Dropping hinting then consists of the following two ops:
+        #   * Drop the piece of the program in each charstring before the
+        #     last call to a stem op or a stem-calling subroutine,
+        #   * Drop all hintmask operations.
+        # - It's trickier... A hintmask right after hints and a few numbers
+        #    will act as an implicit vstemhm. As such, we track whether
+        #    we have seen any non-hint operators so far and do the right
+        #    thing, recursively... Good luck understanding that :(
+        css = set()
+        for c in cs.values():
+            c.decompile()
+            subrs = getattr(c.private, "Subrs", [])
+            decompiler = _DehintingT2Decompiler(
+                css,
+                subrs,
+                c.globalSubrs,
+                c.private.nominalWidthX,
+                c.private.defaultWidthX,
+                c.private,
+            )
+            decompiler.execute(c)
+            c.width = decompiler.width
+        for charstring in css:
+            _cs_drop_hints(charstring)
+        del css
+
+        # Drop font-wide hinting values
+        all_privs = []
+        if hasattr(font, "FDArray"):
+            all_privs.extend(fd.Private for fd in font.FDArray)
+        else:
+            all_privs.append(font.Private)
+        for priv in all_privs:
+            for k in [
+                "BlueValues",
+                "OtherBlues",
+                "FamilyBlues",
+                "FamilyOtherBlues",
+                "BlueScale",
+                "BlueShift",
+                "BlueFuzz",
+                "StemSnapH",
+                "StemSnapV",
+                "StdHW",
+                "StdVW",
+                "ForceBold",
+                "LanguageGroup",
+                "ExpansionFactor",
+            ]:
+                if hasattr(priv, k):
+                    setattr(priv, k, None)
+    if removeUnusedSubrs:
+        remove_unused_subroutines(cff)
+
+
+def _pd_delete_empty_subrs(private_dict):
+    if hasattr(private_dict, "Subrs") and not private_dict.Subrs:
+        if "Subrs" in private_dict.rawDict:
+            del private_dict.rawDict["Subrs"]
+        del private_dict.Subrs
+
+
+def remove_unused_subroutines(cff):
+    for fontname in cff.keys():
+        font = cff[fontname]
+        cs = font.CharStrings
+        # Renumber subroutines to remove unused ones
+
+        # Mark all used subroutines
+        for c in cs.values():
+            subrs = getattr(c.private, "Subrs", [])
+            decompiler = _MarkingT2Decompiler(subrs, c.globalSubrs, c.private)
+            decompiler.execute(c)
+
+        all_subrs = [font.GlobalSubrs]
+        if hasattr(font, "FDArray"):
+            all_subrs.extend(
+                fd.Private.Subrs
+                for fd in font.FDArray
+                if hasattr(fd.Private, "Subrs") and fd.Private.Subrs
+            )
+        elif hasattr(font.Private, "Subrs") and font.Private.Subrs:
+            all_subrs.append(font.Private.Subrs)
+
+        subrs = set(subrs)  # Remove duplicates
+
+        # Prepare
+        for subrs in all_subrs:
+            if not hasattr(subrs, "_used"):
+                subrs._used = set()
+            subrs._used = _uniq_sort(subrs._used)
+            subrs._old_bias = calcSubrBias(subrs)
+            subrs._new_bias = calcSubrBias(subrs._used)
+
+        # Renumber glyph charstrings
+        for c in cs.values():
+            subrs = getattr(c.private, "Subrs", None)
+            _cs_subset_subroutines(c, subrs, font.GlobalSubrs)
+
+        # Renumber subroutines themselves
+        for subrs in all_subrs:
+            if subrs == font.GlobalSubrs:
+                if not hasattr(font, "FDArray") and hasattr(font.Private, "Subrs"):
+                    local_subrs = font.Private.Subrs
+                elif (
+                    hasattr(font, "FDArray")
+                    and len(font.FDArray) == 1
+                    and hasattr(font.FDArray[0].Private, "Subrs")
+                ):
+                    # Technically we shouldn't do this. But I've run into fonts that do it.
+                    local_subrs = font.FDArray[0].Private.Subrs
+                else:
+                    local_subrs = None
+            else:
+                local_subrs = subrs
+
+            subrs.items = [subrs.items[i] for i in subrs._used]
+            if hasattr(subrs, "file"):
+                del subrs.file
+            if hasattr(subrs, "offsets"):
+                del subrs.offsets
+
+            for subr in subrs.items:
+                _cs_subset_subroutines(subr, local_subrs, font.GlobalSubrs)
+
+        # Delete local SubrsIndex if empty
+        if hasattr(font, "FDArray"):
+            for fd in font.FDArray:
+                _pd_delete_empty_subrs(fd.Private)
+        else:
+            _pd_delete_empty_subrs(font.Private)
+
+        # Cleanup
+        for subrs in all_subrs:
+            del subrs._used, subrs._old_bias, subrs._new_bias

infer_4_47_1/lib/python3.10/site-packages/fontTools/cffLib/width.py

@@ -0,0 +1,210 @@
+# -*- coding: utf-8 -*-
+
+"""T2CharString glyph width optimizer.
+
+CFF glyphs whose width equals the CFF Private dictionary's ``defaultWidthX``
+value do not need to specify their width in their charstring, saving bytes.
+This module determines the optimum ``defaultWidthX`` and ``nominalWidthX``
+values for a font, when provided with a list of glyph widths."""
+
+from fontTools.ttLib import TTFont
+from collections import defaultdict
+from operator import add
+from functools import reduce
+
+
+__all__ = ["optimizeWidths", "main"]
+
+
+class missingdict(dict):
+    def __init__(self, missing_func):
+        self.missing_func = missing_func
+
+    def __missing__(self, v):
+        return self.missing_func(v)
+
+
+def cumSum(f, op=add, start=0, decreasing=False):
+    keys = sorted(f.keys())
+    minx, maxx = keys[0], keys[-1]
+
+    total = reduce(op, f.values(), start)
+
+    if decreasing:
+        missing = lambda x: start if x > maxx else total
+        domain = range(maxx, minx - 1, -1)
+    else:
+        missing = lambda x: start if x < minx else total
+        domain = range(minx, maxx + 1)
+
+    out = missingdict(missing)
+
+    v = start
+    for x in domain:
+        v = op(v, f[x])
+        out[x] = v
+
+    return out
+
+
+def byteCost(widths, default, nominal):
+    if not hasattr(widths, "items"):
+        d = defaultdict(int)
+        for w in widths:
+            d[w] += 1
+        widths = d
+
+    cost = 0
+    for w, freq in widths.items():
+        if w == default:
+            continue
+        diff = abs(w - nominal)
+        if diff <= 107:
+            cost += freq
+        elif diff <= 1131:
+            cost += freq * 2
+        else:
+            cost += freq * 5
+    return cost
+
+
+def optimizeWidthsBruteforce(widths):
+    """Bruteforce version.  Veeeeeeeeeeeeeeeeery slow.  Only works for smallests of fonts."""
+
+    d = defaultdict(int)
+    for w in widths:
+        d[w] += 1
+
+    # Maximum number of bytes using default can possibly save
+    maxDefaultAdvantage = 5 * max(d.values())
+
+    minw, maxw = min(widths), max(widths)
+    domain = list(range(minw, maxw + 1))
+
+    bestCostWithoutDefault = min(byteCost(widths, None, nominal) for nominal in domain)
+
+    bestCost = len(widths) * 5 + 1
+    for nominal in domain:
+        if byteCost(widths, None, nominal) > bestCost + maxDefaultAdvantage:
+            continue
+        for default in domain:
+            cost = byteCost(widths, default, nominal)
+            if cost < bestCost:
+                bestCost = cost
+                bestDefault = default
+                bestNominal = nominal
+
+    return bestDefault, bestNominal
+
+
+def optimizeWidths(widths):
+    """Given a list of glyph widths, or dictionary mapping glyph width to number of
+    glyphs having that, returns a tuple of best CFF default and nominal glyph widths.
+
+    This algorithm is linear in UPEM+numGlyphs."""
+
+    if not hasattr(widths, "items"):
+        d = defaultdict(int)
+        for w in widths:
+            d[w] += 1
+        widths = d
+
+    keys = sorted(widths.keys())
+    minw, maxw = keys[0], keys[-1]
+    domain = list(range(minw, maxw + 1))
+
+    # Cumulative sum/max forward/backward.
+    cumFrqU = cumSum(widths, op=add)
+    cumMaxU = cumSum(widths, op=max)
+    cumFrqD = cumSum(widths, op=add, decreasing=True)
+    cumMaxD = cumSum(widths, op=max, decreasing=True)
+
+    # Cost per nominal choice, without default consideration.
+    nomnCostU = missingdict(
+        lambda x: cumFrqU[x] + cumFrqU[x - 108] + cumFrqU[x - 1132] * 3
+    )
+    nomnCostD = missingdict(
+        lambda x: cumFrqD[x] + cumFrqD[x + 108] + cumFrqD[x + 1132] * 3
+    )
+    nomnCost = missingdict(lambda x: nomnCostU[x] + nomnCostD[x] - widths[x])
+
+    # Cost-saving per nominal choice, by best default choice.
+    dfltCostU = missingdict(
+        lambda x: max(cumMaxU[x], cumMaxU[x - 108] * 2, cumMaxU[x - 1132] * 5)
+    )
+    dfltCostD = missingdict(
+        lambda x: max(cumMaxD[x], cumMaxD[x + 108] * 2, cumMaxD[x + 1132] * 5)
+    )
+    dfltCost = missingdict(lambda x: max(dfltCostU[x], dfltCostD[x]))
+
+    # Combined cost per nominal choice.
+    bestCost = missingdict(lambda x: nomnCost[x] - dfltCost[x])
+
+    # Best nominal.
+    nominal = min(domain, key=lambda x: bestCost[x])
+
+    # Work back the best default.
+    bestC = bestCost[nominal]
+    dfltC = nomnCost[nominal] - bestCost[nominal]
+    ends = []
+    if dfltC == dfltCostU[nominal]:
+        starts = [nominal, nominal - 108, nominal - 1132]
+        for start in starts:
+            while cumMaxU[start] and cumMaxU[start] == cumMaxU[start - 1]:
+                start -= 1
+            ends.append(start)
+    else:
+        starts = [nominal, nominal + 108, nominal + 1132]
+        for start in starts:
+            while cumMaxD[start] and cumMaxD[start] == cumMaxD[start + 1]:
+                start += 1
+            ends.append(start)
+    default = min(ends, key=lambda default: byteCost(widths, default, nominal))
+
+    return default, nominal
+
+
+def main(args=None):
+    """Calculate optimum defaultWidthX/nominalWidthX values"""
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools cffLib.width",
+        description=main.__doc__,
+    )
+    parser.add_argument(
+        "inputs", metavar="FILE", type=str, nargs="+", help="Input TTF files"
+    )
+    parser.add_argument(
+        "-b",
+        "--brute-force",
+        dest="brute",
+        action="store_true",
+        help="Use brute-force approach (VERY slow)",
+    )
+
+    args = parser.parse_args(args)
+
+    for fontfile in args.inputs:
+        font = TTFont(fontfile)
+        hmtx = font["hmtx"]
+        widths = [m[0] for m in hmtx.metrics.values()]
+        if args.brute:
+            default, nominal = optimizeWidthsBruteforce(widths)
+        else:
+            default, nominal = optimizeWidths(widths)
+        print(
+            "glyphs=%d default=%d nominal=%d byteCost=%d"
+            % (len(widths), default, nominal, byteCost(widths, default, nominal))
+        )
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) == 1:
+        import doctest
+
+        sys.exit(doctest.testmod().failed)
+    main()

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .cu2qu import *

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from .cli import _main as main
+
+
+if __name__ == "__main__":
+    sys.exit(main())

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/benchmark.py

@@ -0,0 +1,54 @@
+"""Benchmark the cu2qu algorithm performance."""
+
+from .cu2qu import *
+import random
+import timeit
+
+MAX_ERR = 0.05
+
+
+def generate_curve():
+    return [
+        tuple(float(random.randint(0, 2048)) for coord in range(2))
+        for point in range(4)
+    ]
+
+
+def setup_curve_to_quadratic():
+    return generate_curve(), MAX_ERR
+
+
+def setup_curves_to_quadratic():
+    num_curves = 3
+    return ([generate_curve() for curve in range(num_curves)], [MAX_ERR] * num_curves)
+
+
+def run_benchmark(module, function, setup_suffix="", repeat=5, number=1000):
+    setup_func = "setup_" + function
+    if setup_suffix:
+        print("%s with %s:" % (function, setup_suffix), end="")
+        setup_func += "_" + setup_suffix
+    else:
+        print("%s:" % function, end="")
+
+    def wrapper(function, setup_func):
+        function = globals()[function]
+        setup_func = globals()[setup_func]
+
+        def wrapped():
+            return function(*setup_func())
+
+        return wrapped
+
+    results = timeit.repeat(wrapper(function, setup_func), repeat=repeat, number=number)
+    print("\t%5.1fus" % (min(results) * 1000000.0 / number))
+
+
+def main():
+    run_benchmark("cu2qu", "curve_to_quadratic")
+    run_benchmark("cu2qu", "curves_to_quadratic")
+
+
+if __name__ == "__main__":
+    random.seed(1)
+    main()

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/cli.py

@@ -0,0 +1,198 @@
+import os
+import argparse
+import logging
+import shutil
+import multiprocessing as mp
+from contextlib import closing
+from functools import partial
+
+import fontTools
+from .ufo import font_to_quadratic, fonts_to_quadratic
+
+ufo_module = None
+try:
+    import ufoLib2 as ufo_module
+except ImportError:
+    try:
+        import defcon as ufo_module
+    except ImportError as e:
+        pass
+
+
+logger = logging.getLogger("fontTools.cu2qu")
+
+
+def _cpu_count():
+    try:
+        return mp.cpu_count()
+    except NotImplementedError:  # pragma: no cover
+        return 1
+
+
+def open_ufo(path):
+    if hasattr(ufo_module.Font, "open"):  # ufoLib2
+        return ufo_module.Font.open(path)
+    return ufo_module.Font(path)  # defcon
+
+
+def _font_to_quadratic(input_path, output_path=None, **kwargs):
+    ufo = open_ufo(input_path)
+    logger.info("Converting curves for %s", input_path)
+    if font_to_quadratic(ufo, **kwargs):
+        logger.info("Saving %s", output_path)
+        if output_path:
+            ufo.save(output_path)
+        else:
+            ufo.save()  # save in-place
+    elif output_path:
+        _copytree(input_path, output_path)
+
+
+def _samepath(path1, path2):
+    # TODO on python3+, there's os.path.samefile
+    path1 = os.path.normcase(os.path.abspath(os.path.realpath(path1)))
+    path2 = os.path.normcase(os.path.abspath(os.path.realpath(path2)))
+    return path1 == path2
+
+
+def _copytree(input_path, output_path):
+    if _samepath(input_path, output_path):
+        logger.debug("input and output paths are the same file; skipped copy")
+        return
+    if os.path.exists(output_path):
+        shutil.rmtree(output_path)
+    shutil.copytree(input_path, output_path)
+
+
+def _main(args=None):
+    """Convert a UFO font from cubic to quadratic curves"""
+    parser = argparse.ArgumentParser(prog="cu2qu")
+    parser.add_argument("--version", action="version", version=fontTools.__version__)
+    parser.add_argument(
+        "infiles",
+        nargs="+",
+        metavar="INPUT",
+        help="one or more input UFO source file(s).",
+    )
+    parser.add_argument("-v", "--verbose", action="count", default=0)
+    parser.add_argument(
+        "-e",
+        "--conversion-error",
+        type=float,
+        metavar="ERROR",
+        default=None,
+        help="maxiumum approximation error measured in EM (default: 0.001)",
+    )
+    parser.add_argument(
+        "-m",
+        "--mixed",
+        default=False,
+        action="store_true",
+        help="whether to used mixed quadratic and cubic curves",
+    )
+    parser.add_argument(
+        "--keep-direction",
+        dest="reverse_direction",
+        action="store_false",
+        help="do not reverse the contour direction",
+    )
+
+    mode_parser = parser.add_mutually_exclusive_group()
+    mode_parser.add_argument(
+        "-i",
+        "--interpolatable",
+        action="store_true",
+        help="whether curve conversion should keep interpolation compatibility",
+    )
+    mode_parser.add_argument(
+        "-j",
+        "--jobs",
+        type=int,
+        nargs="?",
+        default=1,
+        const=_cpu_count(),
+        metavar="N",
+        help="Convert using N multiple processes (default: %(default)s)",
+    )
+
+    output_parser = parser.add_mutually_exclusive_group()
+    output_parser.add_argument(
+        "-o",
+        "--output-file",
+        default=None,
+        metavar="OUTPUT",
+        help=(
+            "output filename for the converted UFO. By default fonts are "
+            "modified in place. This only works with a single input."
+        ),
+    )
+    output_parser.add_argument(
+        "-d",
+        "--output-dir",
+        default=None,
+        metavar="DIRECTORY",
+        help="output directory where to save converted UFOs",
+    )
+
+    options = parser.parse_args(args)
+
+    if ufo_module is None:
+        parser.error("Either ufoLib2 or defcon are required to run this script.")
+
+    if not options.verbose:
+        level = "WARNING"
+    elif options.verbose == 1:
+        level = "INFO"
+    else:
+        level = "DEBUG"
+    logging.basicConfig(level=level)
+
+    if len(options.infiles) > 1 and options.output_file:
+        parser.error("-o/--output-file can't be used with multile inputs")
+
+    if options.output_dir:
+        output_dir = options.output_dir
+        if not os.path.exists(output_dir):
+            os.mkdir(output_dir)
+        elif not os.path.isdir(output_dir):
+            parser.error("'%s' is not a directory" % output_dir)
+        output_paths = [
+            os.path.join(output_dir, os.path.basename(p)) for p in options.infiles
+        ]
+    elif options.output_file:
+        output_paths = [options.output_file]
+    else:
+        # save in-place
+        output_paths = [None] * len(options.infiles)
+
+    kwargs = dict(
+        dump_stats=options.verbose > 0,
+        max_err_em=options.conversion_error,
+        reverse_direction=options.reverse_direction,
+        all_quadratic=False if options.mixed else True,
+    )
+
+    if options.interpolatable:
+        logger.info("Converting curves compatibly")
+        ufos = [open_ufo(infile) for infile in options.infiles]
+        if fonts_to_quadratic(ufos, **kwargs):
+            for ufo, output_path in zip(ufos, output_paths):
+                logger.info("Saving %s", output_path)
+                if output_path:
+                    ufo.save(output_path)
+                else:
+                    ufo.save()
+        else:
+            for input_path, output_path in zip(options.infiles, output_paths):
+                if output_path:
+                    _copytree(input_path, output_path)
+    else:
+        jobs = min(len(options.infiles), options.jobs) if options.jobs > 1 else 1
+        if jobs > 1:
+            func = partial(_font_to_quadratic, **kwargs)
+            logger.info("Running %d parallel processes", jobs)
+            with closing(mp.Pool(jobs)) as pool:
+                pool.starmap(func, zip(options.infiles, output_paths))
+        else:
+            for input_path, output_path in zip(options.infiles, output_paths):
+                _font_to_quadratic(input_path, output_path, **kwargs)

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/cu2qu.py

@@ -0,0 +1,531 @@
+# cython: language_level=3
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+
+# Copyright 2015 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+try:
+    import cython
+except (AttributeError, ImportError):
+    # if cython not installed, use mock module with no-op decorators and types
+    from fontTools.misc import cython
+COMPILED = cython.compiled
+
+import math
+
+from .errors import Error as Cu2QuError, ApproxNotFoundError
+
+
+__all__ = ["curve_to_quadratic", "curves_to_quadratic"]
+
+MAX_N = 100
+
+NAN = float("NaN")
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.double)
+@cython.locals(v1=cython.complex, v2=cython.complex)
+def dot(v1, v2):
+    """Return the dot product of two vectors.
+
+    Args:
+        v1 (complex): First vector.
+        v2 (complex): Second vector.
+
+    Returns:
+        double: Dot product.
+    """
+    return (v1 * v2.conjugate()).real
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+@cython.locals(
+    _1=cython.complex, _2=cython.complex, _3=cython.complex, _4=cython.complex
+)
+def calc_cubic_points(a, b, c, d):
+    _1 = d
+    _2 = (c / 3.0) + d
+    _3 = (b + c) / 3.0 + _2
+    _4 = a + d + c + b
+    return _1, _2, _3, _4
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex, p1=cython.complex, p2=cython.complex, p3=cython.complex
+)
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+def calc_cubic_parameters(p0, p1, p2, p3):
+    c = (p1 - p0) * 3.0
+    b = (p2 - p1) * 3.0 - c
+    d = p0
+    a = p3 - d - c - b
+    return a, b, c, d
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex, p1=cython.complex, p2=cython.complex, p3=cython.complex
+)
+def split_cubic_into_n_iter(p0, p1, p2, p3, n):
+    """Split a cubic Bezier into n equal parts.
+
+    Splits the curve into `n` equal parts by curve time.
+    (t=0..1/n, t=1/n..2/n, ...)
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        An iterator yielding the control points (four complex values) of the
+        subcurves.
+    """
+    # Hand-coded special-cases
+    if n == 2:
+        return iter(split_cubic_into_two(p0, p1, p2, p3))
+    if n == 3:
+        return iter(split_cubic_into_three(p0, p1, p2, p3))
+    if n == 4:
+        a, b = split_cubic_into_two(p0, p1, p2, p3)
+        return iter(
+            split_cubic_into_two(a[0], a[1], a[2], a[3])
+            + split_cubic_into_two(b[0], b[1], b[2], b[3])
+        )
+    if n == 6:
+        a, b = split_cubic_into_two(p0, p1, p2, p3)
+        return iter(
+            split_cubic_into_three(a[0], a[1], a[2], a[3])
+            + split_cubic_into_three(b[0], b[1], b[2], b[3])
+        )
+
+    return _split_cubic_into_n_gen(p0, p1, p2, p3, n)
+
+
+@cython.locals(
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+    n=cython.int,
+)
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+@cython.locals(
+    dt=cython.double, delta_2=cython.double, delta_3=cython.double, i=cython.int
+)
+@cython.locals(
+    a1=cython.complex, b1=cython.complex, c1=cython.complex, d1=cython.complex
+)
+def _split_cubic_into_n_gen(p0, p1, p2, p3, n):
+    a, b, c, d = calc_cubic_parameters(p0, p1, p2, p3)
+    dt = 1 / n
+    delta_2 = dt * dt
+    delta_3 = dt * delta_2
+    for i in range(n):
+        t1 = i * dt
+        t1_2 = t1 * t1
+        # calc new a, b, c and d
+        a1 = a * delta_3
+        b1 = (3 * a * t1 + b) * delta_2
+        c1 = (2 * b * t1 + c + 3 * a * t1_2) * dt
+        d1 = a * t1 * t1_2 + b * t1_2 + c * t1 + d
+        yield calc_cubic_points(a1, b1, c1, d1)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex, p1=cython.complex, p2=cython.complex, p3=cython.complex
+)
+@cython.locals(mid=cython.complex, deriv3=cython.complex)
+def split_cubic_into_two(p0, p1, p2, p3):
+    """Split a cubic Bezier into two equal parts.
+
+    Splits the curve into two equal parts at t = 0.5
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        tuple: Two cubic Beziers (each expressed as a tuple of four complex
+        values).
+    """
+    mid = (p0 + 3 * (p1 + p2) + p3) * 0.125
+    deriv3 = (p3 + p2 - p1 - p0) * 0.125
+    return (
+        (p0, (p0 + p1) * 0.5, mid - deriv3, mid),
+        (mid, mid + deriv3, (p2 + p3) * 0.5, p3),
+    )
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(
+    mid1=cython.complex,
+    deriv1=cython.complex,
+    mid2=cython.complex,
+    deriv2=cython.complex,
+)
+def split_cubic_into_three(p0, p1, p2, p3):
+    """Split a cubic Bezier into three equal parts.
+
+    Splits the curve into three equal parts at t = 1/3 and t = 2/3
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        tuple: Three cubic Beziers (each expressed as a tuple of four complex
+        values).
+    """
+    mid1 = (8 * p0 + 12 * p1 + 6 * p2 + p3) * (1 / 27)
+    deriv1 = (p3 + 3 * p2 - 4 * p0) * (1 / 27)
+    mid2 = (p0 + 6 * p1 + 12 * p2 + 8 * p3) * (1 / 27)
+    deriv2 = (4 * p3 - 3 * p1 - p0) * (1 / 27)
+    return (
+        (p0, (2 * p0 + p1) / 3.0, mid1 - deriv1, mid1),
+        (mid1, mid1 + deriv1, mid2 - deriv2, mid2),
+        (mid2, mid2 + deriv2, (p2 + 2 * p3) / 3.0, p3),
+    )
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.complex)
+@cython.locals(
+    t=cython.double,
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(_p1=cython.complex, _p2=cython.complex)
+def cubic_approx_control(t, p0, p1, p2, p3):
+    """Approximate a cubic Bezier using a quadratic one.
+
+    Args:
+        t (double): Position of control point.
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+
+    Returns:
+        complex: Location of candidate control point on quadratic curve.
+    """
+    _p1 = p0 + (p1 - p0) * 1.5
+    _p2 = p3 + (p2 - p3) * 1.5
+    return _p1 + (_p2 - _p1) * t
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.complex)
+@cython.locals(a=cython.complex, b=cython.complex, c=cython.complex, d=cython.complex)
+@cython.locals(ab=cython.complex, cd=cython.complex, p=cython.complex, h=cython.double)
+def calc_intersect(a, b, c, d):
+    """Calculate the intersection of two lines.
+
+    Args:
+        a (complex): Start point of first line.
+        b (complex): End point of first line.
+        c (complex): Start point of second line.
+        d (complex): End point of second line.
+
+    Returns:
+        complex: Location of intersection if one present, ``complex(NaN,NaN)``
+        if no intersection was found.
+    """
+    ab = b - a
+    cd = d - c
+    p = ab * 1j
+    try:
+        h = dot(p, a - c) / dot(p, cd)
+    except ZeroDivisionError:
+        return complex(NAN, NAN)
+    return c + cd * h
+
+
+@cython.cfunc
+@cython.returns(cython.int)
+@cython.locals(
+    tolerance=cython.double,
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(mid=cython.complex, deriv3=cython.complex)
+def cubic_farthest_fit_inside(p0, p1, p2, p3, tolerance):
+    """Check if a cubic Bezier lies within a given distance of the origin.
+
+    "Origin" means *the* origin (0,0), not the start of the curve. Note that no
+    checks are made on the start and end positions of the curve; this function
+    only checks the inside of the curve.
+
+    Args:
+        p0 (complex): Start point of curve.
+        p1 (complex): First handle of curve.
+        p2 (complex): Second handle of curve.
+        p3 (complex): End point of curve.
+        tolerance (double): Distance from origin.
+
+    Returns:
+        bool: True if the cubic Bezier ``p`` entirely lies within a distance
+        ``tolerance`` of the origin, False otherwise.
+    """
+    # First check p2 then p1, as p2 has higher error early on.
+    if abs(p2) <= tolerance and abs(p1) <= tolerance:
+        return True
+
+    # Split.
+    mid = (p0 + 3 * (p1 + p2) + p3) * 0.125
+    if abs(mid) > tolerance:
+        return False
+    deriv3 = (p3 + p2 - p1 - p0) * 0.125
+    return cubic_farthest_fit_inside(
+        p0, (p0 + p1) * 0.5, mid - deriv3, mid, tolerance
+    ) and cubic_farthest_fit_inside(mid, mid + deriv3, (p2 + p3) * 0.5, p3, tolerance)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(tolerance=cython.double)
+@cython.locals(
+    q1=cython.complex,
+    c0=cython.complex,
+    c1=cython.complex,
+    c2=cython.complex,
+    c3=cython.complex,
+)
+def cubic_approx_quadratic(cubic, tolerance):
+    """Approximate a cubic Bezier with a single quadratic within a given tolerance.
+
+    Args:
+        cubic (sequence): Four complex numbers representing control points of
+            the cubic Bezier curve.
+        tolerance (double): Permitted deviation from the original curve.
+
+    Returns:
+        Three complex numbers representing control points of the quadratic
+        curve if it fits within the given tolerance, or ``None`` if no suitable
+        curve could be calculated.
+    """
+
+    q1 = calc_intersect(cubic[0], cubic[1], cubic[2], cubic[3])
+    if math.isnan(q1.imag):
+        return None
+    c0 = cubic[0]
+    c3 = cubic[3]
+    c1 = c0 + (q1 - c0) * (2 / 3)
+    c2 = c3 + (q1 - c3) * (2 / 3)
+    if not cubic_farthest_fit_inside(0, c1 - cubic[1], c2 - cubic[2], 0, tolerance):
+        return None
+    return c0, q1, c3
+
+
+@cython.cfunc
+@cython.locals(n=cython.int, tolerance=cython.double)
+@cython.locals(i=cython.int)
+@cython.locals(all_quadratic=cython.int)
+@cython.locals(
+    c0=cython.complex, c1=cython.complex, c2=cython.complex, c3=cython.complex
+)
+@cython.locals(
+    q0=cython.complex,
+    q1=cython.complex,
+    next_q1=cython.complex,
+    q2=cython.complex,
+    d1=cython.complex,
+)
+def cubic_approx_spline(cubic, n, tolerance, all_quadratic):
+    """Approximate a cubic Bezier curve with a spline of n quadratics.
+
+    Args:
+        cubic (sequence): Four complex numbers representing control points of
+            the cubic Bezier curve.
+        n (int): Number of quadratic Bezier curves in the spline.
+        tolerance (double): Permitted deviation from the original curve.
+
+    Returns:
+        A list of ``n+2`` complex numbers, representing control points of the
+        quadratic spline if it fits within the given tolerance, or ``None`` if
+        no suitable spline could be calculated.
+    """
+
+    if n == 1:
+        return cubic_approx_quadratic(cubic, tolerance)
+    if n == 2 and all_quadratic == False:
+        return cubic
+
+    cubics = split_cubic_into_n_iter(cubic[0], cubic[1], cubic[2], cubic[3], n)
+
+    # calculate the spline of quadratics and check errors at the same time.
+    next_cubic = next(cubics)
+    next_q1 = cubic_approx_control(
+        0, next_cubic[0], next_cubic[1], next_cubic[2], next_cubic[3]
+    )
+    q2 = cubic[0]
+    d1 = 0j
+    spline = [cubic[0], next_q1]
+    for i in range(1, n + 1):
+        # Current cubic to convert
+        c0, c1, c2, c3 = next_cubic
+
+        # Current quadratic approximation of current cubic
+        q0 = q2
+        q1 = next_q1
+        if i < n:
+            next_cubic = next(cubics)
+            next_q1 = cubic_approx_control(
+                i / (n - 1), next_cubic[0], next_cubic[1], next_cubic[2], next_cubic[3]
+            )
+            spline.append(next_q1)
+            q2 = (q1 + next_q1) * 0.5
+        else:
+            q2 = c3
+
+        # End-point deltas
+        d0 = d1
+        d1 = q2 - c3
+
+        if abs(d1) > tolerance or not cubic_farthest_fit_inside(
+            d0,
+            q0 + (q1 - q0) * (2 / 3) - c1,
+            q2 + (q1 - q2) * (2 / 3) - c2,
+            d1,
+            tolerance,
+        ):
+            return None
+    spline.append(cubic[3])
+
+    return spline
+
+
+@cython.locals(max_err=cython.double)
+@cython.locals(n=cython.int)
+@cython.locals(all_quadratic=cython.int)
+def curve_to_quadratic(curve, max_err, all_quadratic=True):
+    """Approximate a cubic Bezier curve with a spline of n quadratics.
+
+    Args:
+        cubic (sequence): Four 2D tuples representing control points of
+            the cubic Bezier curve.
+        max_err (double): Permitted deviation from the original curve.
+        all_quadratic (bool): If True (default) returned value is a
+            quadratic spline. If False, it's either a single quadratic
+            curve or a single cubic curve.
+
+    Returns:
+        If all_quadratic is True: A list of 2D tuples, representing
+        control points of the quadratic spline if it fits within the
+        given tolerance, or ``None`` if no suitable spline could be
+        calculated.
+
+        If all_quadratic is False: Either a quadratic curve (if length
+        of output is 3), or a cubic curve (if length of output is 4).
+    """
+
+    curve = [complex(*p) for p in curve]
+
+    for n in range(1, MAX_N + 1):
+        spline = cubic_approx_spline(curve, n, max_err, all_quadratic)
+        if spline is not None:
+            # done. go home
+            return [(s.real, s.imag) for s in spline]
+
+    raise ApproxNotFoundError(curve)
+
+
+@cython.locals(l=cython.int, last_i=cython.int, i=cython.int)
+@cython.locals(all_quadratic=cython.int)
+def curves_to_quadratic(curves, max_errors, all_quadratic=True):
+    """Return quadratic Bezier splines approximating the input cubic Beziers.
+
+    Args:
+        curves: A sequence of *n* curves, each curve being a sequence of four
+            2D tuples.
+        max_errors: A sequence of *n* floats representing the maximum permissible
+            deviation from each of the cubic Bezier curves.
+        all_quadratic (bool): If True (default) returned values are a
+            quadratic spline. If False, they are either a single quadratic
+            curve or a single cubic curve.
+
+    Example::
+
+        >>> curves_to_quadratic( [
+        ...   [ (50,50), (100,100), (150,100), (200,50) ],
+        ...   [ (75,50), (120,100), (150,75),  (200,60) ]
+        ... ], [1,1] )
+        [[(50.0, 50.0), (75.0, 75.0), (125.0, 91.66666666666666), (175.0, 75.0), (200.0, 50.0)], [(75.0, 50.0), (97.5, 75.0), (135.41666666666666, 82.08333333333333), (175.0, 67.5), (200.0, 60.0)]]
+
+    The returned splines have "implied oncurve points" suitable for use in
+    TrueType ``glif`` outlines - i.e. in the first spline returned above,
+    the first quadratic segment runs from (50,50) to
+    ( (75 + 125)/2 , (120 + 91.666..)/2 ) = (100, 83.333...).
+
+    Returns:
+        If all_quadratic is True, a list of splines, each spline being a list
+        of 2D tuples.
+
+        If all_quadratic is False, a list of curves, each curve being a quadratic
+        (length 3), or cubic (length 4).
+
+    Raises:
+        fontTools.cu2qu.Errors.ApproxNotFoundError: if no suitable approximation
+        can be found for all curves with the given parameters.
+    """
+
+    curves = [[complex(*p) for p in curve] for curve in curves]
+    assert len(max_errors) == len(curves)
+
+    l = len(curves)
+    splines = [None] * l
+    last_i = i = 0
+    n = 1
+    while True:
+        spline = cubic_approx_spline(curves[i], n, max_errors[i], all_quadratic)
+        if spline is None:
+            if n == MAX_N:
+                break
+            n += 1
+            last_i = i
+            continue
+        splines[i] = spline
+        i = (i + 1) % l
+        if i == last_i:
+            # done. go home
+            return [[(s.real, s.imag) for s in spline] for spline in splines]
+
+    raise ApproxNotFoundError(curves)

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/errors.py

@@ -0,0 +1,77 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Error(Exception):
+    """Base Cu2Qu exception class for all other errors."""
+
+
+class ApproxNotFoundError(Error):
+    def __init__(self, curve):
+        message = "no approximation found: %s" % curve
+        super().__init__(message)
+        self.curve = curve
+
+
+class UnequalZipLengthsError(Error):
+    pass
+
+
+class IncompatibleGlyphsError(Error):
+    def __init__(self, glyphs):
+        assert len(glyphs) > 1
+        self.glyphs = glyphs
+        names = set(repr(g.name) for g in glyphs)
+        if len(names) > 1:
+            self.combined_name = "{%s}" % ", ".join(sorted(names))
+        else:
+            self.combined_name = names.pop()
+
+    def __repr__(self):
+        return "<%s %s>" % (type(self).__name__, self.combined_name)
+
+
+class IncompatibleSegmentNumberError(IncompatibleGlyphsError):
+    def __str__(self):
+        return "Glyphs named %s have different number of segments" % (
+            self.combined_name
+        )
+
+
+class IncompatibleSegmentTypesError(IncompatibleGlyphsError):
+    def __init__(self, glyphs, segments):
+        IncompatibleGlyphsError.__init__(self, glyphs)
+        self.segments = segments
+
+    def __str__(self):
+        lines = []
+        ndigits = len(str(max(self.segments)))
+        for i, tags in sorted(self.segments.items()):
+            lines.append(
+                "%s: (%s)" % (str(i).rjust(ndigits), ", ".join(repr(t) for t in tags))
+            )
+        return "Glyphs named %s have incompatible segment types:\n  %s" % (
+            self.combined_name,
+            "\n  ".join(lines),
+        )
+
+
+class IncompatibleFontsError(Error):
+    def __init__(self, glyph_errors):
+        self.glyph_errors = glyph_errors
+
+    def __str__(self):
+        return "fonts contains incompatible glyphs: %s" % (
+            ", ".join(repr(g) for g in sorted(self.glyph_errors.keys()))
+        )

infer_4_47_1/lib/python3.10/site-packages/fontTools/cu2qu/ufo.py

@@ -0,0 +1,349 @@
+# Copyright 2015 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Converts cubic bezier curves to quadratic splines.
+
+Conversion is performed such that the quadratic splines keep the same end-curve
+tangents as the original cubics. The approach is iterative, increasing the
+number of segments for a spline until the error gets below a bound.
+
+Respective curves from multiple fonts will be converted at once to ensure that
+the resulting splines are interpolation-compatible.
+"""
+
+import logging
+from fontTools.pens.basePen import AbstractPen
+from fontTools.pens.pointPen import PointToSegmentPen
+from fontTools.pens.reverseContourPen import ReverseContourPen
+
+from . import curves_to_quadratic
+from .errors import (
+    UnequalZipLengthsError,
+    IncompatibleSegmentNumberError,
+    IncompatibleSegmentTypesError,
+    IncompatibleGlyphsError,
+    IncompatibleFontsError,
+)
+
+
+__all__ = ["fonts_to_quadratic", "font_to_quadratic"]
+
+# The default approximation error below is a relative value (1/1000 of the EM square).
+# Later on, we convert it to absolute font units by multiplying it by a font's UPEM
+# (see fonts_to_quadratic).
+DEFAULT_MAX_ERR = 0.001
+CURVE_TYPE_LIB_KEY = "com.github.googlei18n.cu2qu.curve_type"
+
+logger = logging.getLogger(__name__)
+
+
+_zip = zip
+
+
+def zip(*args):
+    """Ensure each argument to zip has the same length. Also make sure a list is
+    returned for python 2/3 compatibility.
+    """
+
+    if len(set(len(a) for a in args)) != 1:
+        raise UnequalZipLengthsError(*args)
+    return list(_zip(*args))
+
+
+class GetSegmentsPen(AbstractPen):
+    """Pen to collect segments into lists of points for conversion.
+
+    Curves always include their initial on-curve point, so some points are
+    duplicated between segments.
+    """
+
+    def __init__(self):
+        self._last_pt = None
+        self.segments = []
+
+    def _add_segment(self, tag, *args):
+        if tag in ["move", "line", "qcurve", "curve"]:
+            self._last_pt = args[-1]
+        self.segments.append((tag, args))
+
+    def moveTo(self, pt):
+        self._add_segment("move", pt)
+
+    def lineTo(self, pt):
+        self._add_segment("line", pt)
+
+    def qCurveTo(self, *points):
+        self._add_segment("qcurve", self._last_pt, *points)
+
+    def curveTo(self, *points):
+        self._add_segment("curve", self._last_pt, *points)
+
+    def closePath(self):
+        self._add_segment("close")
+
+    def endPath(self):
+        self._add_segment("end")
+
+    def addComponent(self, glyphName, transformation):
+        pass
+
+
+def _get_segments(glyph):
+    """Get a glyph's segments as extracted by GetSegmentsPen."""
+
+    pen = GetSegmentsPen()
+    # glyph.draw(pen)
+    # We can't simply draw the glyph with the pen, but we must initialize the
+    # PointToSegmentPen explicitly with outputImpliedClosingLine=True.
+    # By default PointToSegmentPen does not outputImpliedClosingLine -- unless
+    # last and first point on closed contour are duplicated. Because we are
+    # converting multiple glyphs at the same time, we want to make sure
+    # this function returns the same number of segments, whether or not
+    # the last and first point overlap.
+    # https://github.com/googlefonts/fontmake/issues/572
+    # https://github.com/fonttools/fonttools/pull/1720
+    pointPen = PointToSegmentPen(pen, outputImpliedClosingLine=True)
+    glyph.drawPoints(pointPen)
+    return pen.segments
+
+
+def _set_segments(glyph, segments, reverse_direction):
+    """Draw segments as extracted by GetSegmentsPen back to a glyph."""
+
+    glyph.clearContours()
+    pen = glyph.getPen()
+    if reverse_direction:
+        pen = ReverseContourPen(pen)
+    for tag, args in segments:
+        if tag == "move":
+            pen.moveTo(*args)
+        elif tag == "line":
+            pen.lineTo(*args)
+        elif tag == "curve":
+            pen.curveTo(*args[1:])
+        elif tag == "qcurve":
+            pen.qCurveTo(*args[1:])
+        elif tag == "close":
+            pen.closePath()
+        elif tag == "end":
+            pen.endPath()
+        else:
+            raise AssertionError('Unhandled segment type "%s"' % tag)
+
+
+def _segments_to_quadratic(segments, max_err, stats, all_quadratic=True):
+    """Return quadratic approximations of cubic segments."""
+
+    assert all(s[0] == "curve" for s in segments), "Non-cubic given to convert"
+
+    new_points = curves_to_quadratic([s[1] for s in segments], max_err, all_quadratic)
+    n = len(new_points[0])
+    assert all(len(s) == n for s in new_points[1:]), "Converted incompatibly"
+
+    spline_length = str(n - 2)
+    stats[spline_length] = stats.get(spline_length, 0) + 1
+
+    if all_quadratic or n == 3:
+        return [("qcurve", p) for p in new_points]
+    else:
+        return [("curve", p) for p in new_points]
+
+
+def _glyphs_to_quadratic(glyphs, max_err, reverse_direction, stats, all_quadratic=True):
+    """Do the actual conversion of a set of compatible glyphs, after arguments
+    have been set up.
+
+    Return True if the glyphs were modified, else return False.
+    """
+
+    try:
+        segments_by_location = zip(*[_get_segments(g) for g in glyphs])
+    except UnequalZipLengthsError:
+        raise IncompatibleSegmentNumberError(glyphs)
+    if not any(segments_by_location):
+        return False
+
+    # always modify input glyphs if reverse_direction is True
+    glyphs_modified = reverse_direction
+
+    new_segments_by_location = []
+    incompatible = {}
+    for i, segments in enumerate(segments_by_location):
+        tag = segments[0][0]
+        if not all(s[0] == tag for s in segments[1:]):
+            incompatible[i] = [s[0] for s in segments]
+        elif tag == "curve":
+            new_segments = _segments_to_quadratic(
+                segments, max_err, stats, all_quadratic
+            )
+            if all_quadratic or new_segments != segments:
+                glyphs_modified = True
+            segments = new_segments
+        new_segments_by_location.append(segments)
+
+    if glyphs_modified:
+        new_segments_by_glyph = zip(*new_segments_by_location)
+        for glyph, new_segments in zip(glyphs, new_segments_by_glyph):
+            _set_segments(glyph, new_segments, reverse_direction)
+
+    if incompatible:
+        raise IncompatibleSegmentTypesError(glyphs, segments=incompatible)
+    return glyphs_modified
+
+
+def glyphs_to_quadratic(
+    glyphs, max_err=None, reverse_direction=False, stats=None, all_quadratic=True
+):
+    """Convert the curves of a set of compatible of glyphs to quadratic.
+
+    All curves will be converted to quadratic at once, ensuring interpolation
+    compatibility. If this is not required, calling glyphs_to_quadratic with one
+    glyph at a time may yield slightly more optimized results.
+
+    Return True if glyphs were modified, else return False.
+
+    Raises IncompatibleGlyphsError if glyphs have non-interpolatable outlines.
+    """
+    if stats is None:
+        stats = {}
+
+    if not max_err:
+        # assume 1000 is the default UPEM
+        max_err = DEFAULT_MAX_ERR * 1000
+
+    if isinstance(max_err, (list, tuple)):
+        max_errors = max_err
+    else:
+        max_errors = [max_err] * len(glyphs)
+    assert len(max_errors) == len(glyphs)
+
+    return _glyphs_to_quadratic(
+        glyphs, max_errors, reverse_direction, stats, all_quadratic
+    )
+
+
+def fonts_to_quadratic(
+    fonts,
+    max_err_em=None,
+    max_err=None,
+    reverse_direction=False,
+    stats=None,
+    dump_stats=False,
+    remember_curve_type=True,
+    all_quadratic=True,
+):
+    """Convert the curves of a collection of fonts to quadratic.
+
+    All curves will be converted to quadratic at once, ensuring interpolation
+    compatibility. If this is not required, calling fonts_to_quadratic with one
+    font at a time may yield slightly more optimized results.
+
+    Return the set of modified glyph names if any, else return an empty set.
+
+    By default, cu2qu stores the curve type in the fonts' lib, under a private
+    key "com.github.googlei18n.cu2qu.curve_type", and will not try to convert
+    them again if the curve type is already set to "quadratic".
+    Setting 'remember_curve_type' to False disables this optimization.
+
+    Raises IncompatibleFontsError if same-named glyphs from different fonts
+    have non-interpolatable outlines.
+    """
+
+    if remember_curve_type:
+        curve_types = {f.lib.get(CURVE_TYPE_LIB_KEY, "cubic") for f in fonts}
+        if len(curve_types) == 1:
+            curve_type = next(iter(curve_types))
+            if curve_type in ("quadratic", "mixed"):
+                logger.info("Curves already converted to quadratic")
+                return False
+            elif curve_type == "cubic":
+                pass  # keep converting
+            else:
+                raise NotImplementedError(curve_type)
+        elif len(curve_types) > 1:
+            # going to crash later if they do differ
+            logger.warning("fonts may contain different curve types")
+
+    if stats is None:
+        stats = {}
+
+    if max_err_em and max_err:
+        raise TypeError("Only one of max_err and max_err_em can be specified.")
+    if not (max_err_em or max_err):
+        max_err_em = DEFAULT_MAX_ERR
+
+    if isinstance(max_err, (list, tuple)):
+        assert len(max_err) == len(fonts)
+        max_errors = max_err
+    elif max_err:
+        max_errors = [max_err] * len(fonts)
+
+    if isinstance(max_err_em, (list, tuple)):
+        assert len(fonts) == len(max_err_em)
+        max_errors = [f.info.unitsPerEm * e for f, e in zip(fonts, max_err_em)]
+    elif max_err_em:
+        max_errors = [f.info.unitsPerEm * max_err_em for f in fonts]
+
+    modified = set()
+    glyph_errors = {}
+    for name in set().union(*(f.keys() for f in fonts)):
+        glyphs = []
+        cur_max_errors = []
+        for font, error in zip(fonts, max_errors):
+            if name in font:
+                glyphs.append(font[name])
+                cur_max_errors.append(error)
+        try:
+            if _glyphs_to_quadratic(
+                glyphs, cur_max_errors, reverse_direction, stats, all_quadratic
+            ):
+                modified.add(name)
+        except IncompatibleGlyphsError as exc:
+            logger.error(exc)
+            glyph_errors[name] = exc
+
+    if glyph_errors:
+        raise IncompatibleFontsError(glyph_errors)
+
+    if modified and dump_stats:
+        spline_lengths = sorted(stats.keys())
+        logger.info(
+            "New spline lengths: %s"
+            % (", ".join("%s: %d" % (l, stats[l]) for l in spline_lengths))
+        )
+
+    if remember_curve_type:
+        for font in fonts:
+            curve_type = font.lib.get(CURVE_TYPE_LIB_KEY, "cubic")
+            new_curve_type = "quadratic" if all_quadratic else "mixed"
+            if curve_type != new_curve_type:
+                font.lib[CURVE_TYPE_LIB_KEY] = new_curve_type
+    return modified
+
+
+def glyph_to_quadratic(glyph, **kwargs):
+    """Convenience wrapper around glyphs_to_quadratic, for just one glyph.
+    Return True if the glyph was modified, else return False.
+    """
+
+    return glyphs_to_quadratic([glyph], **kwargs)
+
+
+def font_to_quadratic(font, **kwargs):
+    """Convenience wrapper around fonts_to_quadratic, for just one font.
+    Return the set of modified glyph names if any, else return empty set.
+    """
+
+    return fonts_to_quadratic([font], **kwargs)

infer_4_47_1/lib/python3.10/site-packages/fontTools/designspaceLib/statNames.py

@@ -0,0 +1,253 @@
+"""Compute name information for a given location in user-space coordinates
+using STAT data. This can be used to fill-in automatically the names of an
+instance:
+
+.. code:: python
+
+    instance = doc.instances[0]
+    names = getStatNames(doc, instance.getFullUserLocation(doc))
+    print(names.styleNames)
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional, Tuple, Union
+import logging
+
+from fontTools.designspaceLib import (
+    AxisDescriptor,
+    AxisLabelDescriptor,
+    DesignSpaceDocument,
+    DesignSpaceDocumentError,
+    DiscreteAxisDescriptor,
+    SimpleLocationDict,
+    SourceDescriptor,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+# TODO(Python 3.8): use Literal
+# RibbiStyleName = Union[Literal["regular"], Literal["bold"], Literal["italic"], Literal["bold italic"]]
+RibbiStyle = str
+BOLD_ITALIC_TO_RIBBI_STYLE = {
+    (False, False): "regular",
+    (False, True): "italic",
+    (True, False): "bold",
+    (True, True): "bold italic",
+}
+
+
+@dataclass
+class StatNames:
+    """Name data generated from the STAT table information."""
+
+    familyNames: Dict[str, str]
+    styleNames: Dict[str, str]
+    postScriptFontName: Optional[str]
+    styleMapFamilyNames: Dict[str, str]
+    styleMapStyleName: Optional[RibbiStyle]
+
+
+def getStatNames(
+    doc: DesignSpaceDocument, userLocation: SimpleLocationDict
+) -> StatNames:
+    """Compute the family, style, PostScript names of the given ``userLocation``
+    using the document's STAT information.
+
+    Also computes localizations.
+
+    If not enough STAT data is available for a given name, either its dict of
+    localized names will be empty (family and style names), or the name will be
+    None (PostScript name).
+
+    .. versionadded:: 5.0
+    """
+    familyNames: Dict[str, str] = {}
+    defaultSource: Optional[SourceDescriptor] = doc.findDefault()
+    if defaultSource is None:
+        LOGGER.warning("Cannot determine default source to look up family name.")
+    elif defaultSource.familyName is None:
+        LOGGER.warning(
+            "Cannot look up family name, assign the 'familyname' attribute to the default source."
+        )
+    else:
+        familyNames = {
+            "en": defaultSource.familyName,
+            **defaultSource.localisedFamilyName,
+        }
+
+    styleNames: Dict[str, str] = {}
+    # If a free-standing label matches the location, use it for name generation.
+    label = doc.labelForUserLocation(userLocation)
+    if label is not None:
+        styleNames = {"en": label.name, **label.labelNames}
+    # Otherwise, scour the axis labels for matches.
+    else:
+        # Gather all languages in which at least one translation is provided
+        # Then build names for all these languages, but fallback to English
+        # whenever a translation is missing.
+        labels = _getAxisLabelsForUserLocation(doc.axes, userLocation)
+        if labels:
+            languages = set(
+                language for label in labels for language in label.labelNames
+            )
+            languages.add("en")
+            for language in languages:
+                styleName = " ".join(
+                    label.labelNames.get(language, label.defaultName)
+                    for label in labels
+                    if not label.elidable
+                )
+                if not styleName and doc.elidedFallbackName is not None:
+                    styleName = doc.elidedFallbackName
+                styleNames[language] = styleName
+
+    if "en" not in familyNames or "en" not in styleNames:
+        # Not enough information to compute PS names of styleMap names
+        return StatNames(
+            familyNames=familyNames,
+            styleNames=styleNames,
+            postScriptFontName=None,
+            styleMapFamilyNames={},
+            styleMapStyleName=None,
+        )
+
+    postScriptFontName = f"{familyNames['en']}-{styleNames['en']}".replace(" ", "")
+
+    styleMapStyleName, regularUserLocation = _getRibbiStyle(doc, userLocation)
+
+    styleNamesForStyleMap = styleNames
+    if regularUserLocation != userLocation:
+        regularStatNames = getStatNames(doc, regularUserLocation)
+        styleNamesForStyleMap = regularStatNames.styleNames
+
+    styleMapFamilyNames = {}
+    for language in set(familyNames).union(styleNames.keys()):
+        familyName = familyNames.get(language, familyNames["en"])
+        styleName = styleNamesForStyleMap.get(language, styleNamesForStyleMap["en"])
+        styleMapFamilyNames[language] = (familyName + " " + styleName).strip()
+
+    return StatNames(
+        familyNames=familyNames,
+        styleNames=styleNames,
+        postScriptFontName=postScriptFontName,
+        styleMapFamilyNames=styleMapFamilyNames,
+        styleMapStyleName=styleMapStyleName,
+    )
+
+
+def _getSortedAxisLabels(
+    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
+) -> Dict[str, list[AxisLabelDescriptor]]:
+    """Returns axis labels sorted by their ordering, with unordered ones appended as
+    they are listed."""
+
+    # First, get the axis labels with explicit ordering...
+    sortedAxes = sorted(
+        (axis for axis in axes if axis.axisOrdering is not None),
+        key=lambda a: a.axisOrdering,
+    )
+    sortedLabels: Dict[str, list[AxisLabelDescriptor]] = {
+        axis.name: axis.axisLabels for axis in sortedAxes
+    }
+
+    # ... then append the others in the order they appear.
+    # NOTE: This relies on Python 3.7+ dict's preserved insertion order.
+    for axis in axes:
+        if axis.axisOrdering is None:
+            sortedLabels[axis.name] = axis.axisLabels
+
+    return sortedLabels
+
+
+def _getAxisLabelsForUserLocation(
+    axes: list[Union[AxisDescriptor, DiscreteAxisDescriptor]],
+    userLocation: SimpleLocationDict,
+) -> list[AxisLabelDescriptor]:
+    labels: list[AxisLabelDescriptor] = []
+
+    allAxisLabels = _getSortedAxisLabels(axes)
+    if allAxisLabels.keys() != userLocation.keys():
+        LOGGER.warning(
+            f"Mismatch between user location '{userLocation.keys()}' and available "
+            f"labels for '{allAxisLabels.keys()}'."
+        )
+
+    for axisName, axisLabels in allAxisLabels.items():
+        userValue = userLocation[axisName]
+        label: Optional[AxisLabelDescriptor] = next(
+            (
+                l
+                for l in axisLabels
+                if l.userValue == userValue
+                or (
+                    l.userMinimum is not None
+                    and l.userMaximum is not None
+                    and l.userMinimum <= userValue <= l.userMaximum
+                )
+            ),
+            None,
+        )
+        if label is None:
+            LOGGER.debug(
+                f"Document needs a label for axis '{axisName}', user value '{userValue}'."
+            )
+        else:
+            labels.append(label)
+
+    return labels
+
+
+def _getRibbiStyle(
+    self: DesignSpaceDocument, userLocation: SimpleLocationDict
+) -> Tuple[RibbiStyle, SimpleLocationDict]:
+    """Compute the RIBBI style name of the given user location,
+    return the location of the matching Regular in the RIBBI group.
+
+    .. versionadded:: 5.0
+    """
+    regularUserLocation = {}
+    axes_by_tag = {axis.tag: axis for axis in self.axes}
+
+    bold: bool = False
+    italic: bool = False
+
+    axis = axes_by_tag.get("wght")
+    if axis is not None:
+        for regular_label in axis.axisLabels:
+            if (
+                regular_label.linkedUserValue == userLocation[axis.name]
+                # In the "recursive" case where both the Regular has
+                # linkedUserValue pointing the Bold, and the Bold has
+                # linkedUserValue pointing to the Regular, only consider the
+                # first case: Regular (e.g. 400) has linkedUserValue pointing to
+                # Bold (e.g. 700, higher than Regular)
+                and regular_label.userValue < regular_label.linkedUserValue
+            ):
+                regularUserLocation[axis.name] = regular_label.userValue
+                bold = True
+                break
+
+    axis = axes_by_tag.get("ital") or axes_by_tag.get("slnt")
+    if axis is not None:
+        for upright_label in axis.axisLabels:
+            if (
+                upright_label.linkedUserValue == userLocation[axis.name]
+                # In the "recursive" case where both the Upright has
+                # linkedUserValue pointing the Italic, and the Italic has
+                # linkedUserValue pointing to the Upright, only consider the
+                # first case: Upright (e.g. ital=0, slant=0) has
+                # linkedUserValue pointing to Italic (e.g ital=1, slant=-12 or
+                # slant=12 for backwards italics, in any case higher than
+                # Upright in absolute value, hence the abs() below.
+                and abs(upright_label.userValue) < abs(upright_label.linkedUserValue)
+            ):
+                regularUserLocation[axis.name] = upright_label.userValue
+                italic = True
+                break
+
+    return BOLD_ITALIC_TO_RIBBI_STYLE[bold, italic], {
+        **userLocation,
+        **regularUserLocation,
+    }

infer_4_47_1/lib/python3.10/site-packages/fontTools/encodings/MacRoman.py

@@ -0,0 +1,258 @@
+MacRoman = [
+    "NUL",
+    "Eth",
+    "eth",
+    "Lslash",
+    "lslash",
+    "Scaron",
+    "scaron",
+    "Yacute",
+    "yacute",
+    "HT",
+    "LF",
+    "Thorn",
+    "thorn",
+    "CR",
+    "Zcaron",
+    "zcaron",
+    "DLE",
+    "DC1",
+    "DC2",
+    "DC3",
+    "DC4",
+    "onehalf",
+    "onequarter",
+    "onesuperior",
+    "threequarters",
+    "threesuperior",
+    "twosuperior",
+    "brokenbar",
+    "minus",
+    "multiply",
+    "RS",
+    "US",
+    "space",
+    "exclam",
+    "quotedbl",
+    "numbersign",
+    "dollar",
+    "percent",
+    "ampersand",
+    "quotesingle",
+    "parenleft",
+    "parenright",
+    "asterisk",
+    "plus",
+    "comma",
+    "hyphen",
+    "period",
+    "slash",
+    "zero",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "colon",
+    "semicolon",
+    "less",
+    "equal",
+    "greater",
+    "question",
+    "at",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "bracketleft",
+    "backslash",
+    "bracketright",
+    "asciicircum",
+    "underscore",
+    "grave",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "braceleft",
+    "bar",
+    "braceright",
+    "asciitilde",
+    "DEL",
+    "Adieresis",
+    "Aring",
+    "Ccedilla",
+    "Eacute",
+    "Ntilde",
+    "Odieresis",
+    "Udieresis",
+    "aacute",
+    "agrave",
+    "acircumflex",
+    "adieresis",
+    "atilde",
+    "aring",
+    "ccedilla",
+    "eacute",
+    "egrave",
+    "ecircumflex",
+    "edieresis",
+    "iacute",
+    "igrave",
+    "icircumflex",
+    "idieresis",
+    "ntilde",
+    "oacute",
+    "ograve",
+    "ocircumflex",
+    "odieresis",
+    "otilde",
+    "uacute",
+    "ugrave",
+    "ucircumflex",
+    "udieresis",
+    "dagger",
+    "degree",
+    "cent",
+    "sterling",
+    "section",
+    "bullet",
+    "paragraph",
+    "germandbls",
+    "registered",
+    "copyright",
+    "trademark",
+    "acute",
+    "dieresis",
+    "notequal",
+    "AE",
+    "Oslash",
+    "infinity",
+    "plusminus",
+    "lessequal",
+    "greaterequal",
+    "yen",
+    "mu",
+    "partialdiff",
+    "summation",
+    "product",
+    "pi",
+    "integral",
+    "ordfeminine",
+    "ordmasculine",
+    "Omega",
+    "ae",
+    "oslash",
+    "questiondown",
+    "exclamdown",
+    "logicalnot",
+    "radical",
+    "florin",
+    "approxequal",
+    "Delta",
+    "guillemotleft",
+    "guillemotright",
+    "ellipsis",
+    "nbspace",
+    "Agrave",
+    "Atilde",
+    "Otilde",
+    "OE",
+    "oe",
+    "endash",
+    "emdash",
+    "quotedblleft",
+    "quotedblright",
+    "quoteleft",
+    "quoteright",
+    "divide",
+    "lozenge",
+    "ydieresis",
+    "Ydieresis",
+    "fraction",
+    "currency",
+    "guilsinglleft",
+    "guilsinglright",
+    "fi",
+    "fl",
+    "daggerdbl",
+    "periodcentered",
+    "quotesinglbase",
+    "quotedblbase",
+    "perthousand",
+    "Acircumflex",
+    "Ecircumflex",
+    "Aacute",
+    "Edieresis",
+    "Egrave",
+    "Iacute",
+    "Icircumflex",
+    "Idieresis",
+    "Igrave",
+    "Oacute",
+    "Ocircumflex",
+    "apple",
+    "Ograve",
+    "Uacute",
+    "Ucircumflex",
+    "Ugrave",
+    "dotlessi",
+    "circumflex",
+    "tilde",
+    "macron",
+    "breve",
+    "dotaccent",
+    "ring",
+    "cedilla",
+    "hungarumlaut",
+    "ogonek",
+    "caron",
+]

infer_4_47_1/lib/python3.10/site-packages/fontTools/encodings/StandardEncoding.py

@@ -0,0 +1,258 @@
+StandardEncoding = [
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    "space",
+    "exclam",
+    "quotedbl",
+    "numbersign",
+    "dollar",
+    "percent",
+    "ampersand",
+    "quoteright",
+    "parenleft",
+    "parenright",
+    "asterisk",
+    "plus",
+    "comma",
+    "hyphen",
+    "period",
+    "slash",
+    "zero",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "colon",
+    "semicolon",
+    "less",
+    "equal",
+    "greater",
+    "question",
+    "at",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    "bracketleft",
+    "backslash",
+    "bracketright",
+    "asciicircum",
+    "underscore",
+    "quoteleft",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "braceleft",
+    "bar",
+    "braceright",
+    "asciitilde",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    "exclamdown",
+    "cent",
+    "sterling",
+    "fraction",
+    "yen",
+    "florin",
+    "section",
+    "currency",
+    "quotesingle",
+    "quotedblleft",
+    "guillemotleft",
+    "guilsinglleft",
+    "guilsinglright",
+    "fi",
+    "fl",
+    ".notdef",
+    "endash",
+    "dagger",
+    "daggerdbl",
+    "periodcentered",
+    ".notdef",
+    "paragraph",
+    "bullet",
+    "quotesinglbase",
+    "quotedblbase",
+    "quotedblright",
+    "guillemotright",
+    "ellipsis",
+    "perthousand",
+    ".notdef",
+    "questiondown",
+    ".notdef",
+    "grave",
+    "acute",
+    "circumflex",
+    "tilde",
+    "macron",
+    "breve",
+    "dotaccent",
+    "dieresis",
+    ".notdef",
+    "ring",
+    "cedilla",
+    ".notdef",
+    "hungarumlaut",
+    "ogonek",
+    "caron",
+    "emdash",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    "AE",
+    ".notdef",
+    "ordfeminine",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    "Lslash",
+    "Oslash",
+    "OE",
+    "ordmasculine",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    "ae",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    "dotlessi",
+    ".notdef",
+    ".notdef",
+    "lslash",
+    "oslash",
+    "oe",
+    "germandbls",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+    ".notdef",
+]

infer_4_47_1/lib/python3.10/site-packages/fontTools/encodings/__init__.py

@@ -0,0 +1 @@
+"""Empty __init__.py file to signal Python this directory is a package."""

infer_4_47_1/lib/python3.10/site-packages/fontTools/encodings/codecs.py

@@ -0,0 +1,135 @@
+"""Extend the Python codecs module with a few encodings that are used in OpenType (name table)
+but missing from Python.  See https://github.com/fonttools/fonttools/issues/236 for details."""
+
+import codecs
+import encodings
+
+
+class ExtendCodec(codecs.Codec):
+    def __init__(self, name, base_encoding, mapping):
+        self.name = name
+        self.base_encoding = base_encoding
+        self.mapping = mapping
+        self.reverse = {v: k for k, v in mapping.items()}
+        self.max_len = max(len(v) for v in mapping.values())
+        self.info = codecs.CodecInfo(
+            name=self.name, encode=self.encode, decode=self.decode
+        )
+        codecs.register_error(name, self.error)
+
+    def _map(self, mapper, output_type, exc_type, input, errors):
+        base_error_handler = codecs.lookup_error(errors)
+        length = len(input)
+        out = output_type()
+        while input:
+            # first try to use self.error as the error handler
+            try:
+                part = mapper(input, self.base_encoding, errors=self.name)
+                out += part
+                break  # All converted
+            except exc_type as e:
+                # else convert the correct part, handle error as requested and continue
+                out += mapper(input[: e.start], self.base_encoding, self.name)
+                replacement, pos = base_error_handler(e)
+                out += replacement
+                input = input[pos:]
+        return out, length
+
+    def encode(self, input, errors="strict"):
+        return self._map(codecs.encode, bytes, UnicodeEncodeError, input, errors)
+
+    def decode(self, input, errors="strict"):
+        return self._map(codecs.decode, str, UnicodeDecodeError, input, errors)
+
+    def error(self, e):
+        if isinstance(e, UnicodeDecodeError):
+            for end in range(e.start + 1, e.end + 1):
+                s = e.object[e.start : end]
+                if s in self.mapping:
+                    return self.mapping[s], end
+        elif isinstance(e, UnicodeEncodeError):
+            for end in range(e.start + 1, e.start + self.max_len + 1):
+                s = e.object[e.start : end]
+                if s in self.reverse:
+                    return self.reverse[s], end
+        e.encoding = self.name
+        raise e
+
+
+_extended_encodings = {
+    "x_mac_japanese_ttx": (
+        "shift_jis",
+        {
+            b"\xFC": chr(0x007C),
+            b"\x7E": chr(0x007E),
+            b"\x80": chr(0x005C),
+            b"\xA0": chr(0x00A0),
+            b"\xFD": chr(0x00A9),
+            b"\xFE": chr(0x2122),
+            b"\xFF": chr(0x2026),
+        },
+    ),
+    "x_mac_trad_chinese_ttx": (
+        "big5",
+        {
+            b"\x80": chr(0x005C),
+            b"\xA0": chr(0x00A0),
+            b"\xFD": chr(0x00A9),
+            b"\xFE": chr(0x2122),
+            b"\xFF": chr(0x2026),
+        },
+    ),
+    "x_mac_korean_ttx": (
+        "euc_kr",
+        {
+            b"\x80": chr(0x00A0),
+            b"\x81": chr(0x20A9),
+            b"\x82": chr(0x2014),
+            b"\x83": chr(0x00A9),
+            b"\xFE": chr(0x2122),
+            b"\xFF": chr(0x2026),
+        },
+    ),
+    "x_mac_simp_chinese_ttx": (
+        "gb2312",
+        {
+            b"\x80": chr(0x00FC),
+            b"\xA0": chr(0x00A0),
+            b"\xFD": chr(0x00A9),
+            b"\xFE": chr(0x2122),
+            b"\xFF": chr(0x2026),
+        },
+    ),
+}
+
+_cache = {}
+
+
+def search_function(name):
+    name = encodings.normalize_encoding(name)  # Rather undocumented...
+    if name in _extended_encodings:
+        if name not in _cache:
+            base_encoding, mapping = _extended_encodings[name]
+            assert name[-4:] == "_ttx"
+            # Python 2 didn't have any of the encodings that we are implementing
+            # in this file.  Python 3 added aliases for the East Asian ones, mapping
+            # them "temporarily" to the same base encoding as us, with a comment
+            # suggesting that full implementation will appear some time later.
+            # As such, try the Python version of the x_mac_... first, if that is found,
+            # use *that* as our base encoding.  This would make our encoding upgrade
+            # to the full encoding when and if Python finally implements that.
+            # http://bugs.python.org/issue24041
+            base_encodings = [name[:-4], base_encoding]
+            for base_encoding in base_encodings:
+                try:
+                    codecs.lookup(base_encoding)
+                except LookupError:
+                    continue
+                _cache[name] = ExtendCodec(name, base_encoding, mapping)
+                break
+        return _cache[name].info
+
+    return None
+
+
+codecs.register(search_function)

infer_4_47_1/lib/python3.10/site-packages/fontTools/mtiLib/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from fontTools.mtiLib import main
+
+if __name__ == "__main__":
+    sys.exit(main())

infer_4_47_1/lib/python3.10/site-packages/fontTools/otlLib/__init__.py

@@ -0,0 +1 @@
+"""OpenType Layout-related functionality."""

infer_4_47_1/lib/python3.10/site-packages/fontTools/otlLib/error.py

@@ -0,0 +1,11 @@
+class OpenTypeLibError(Exception):
+    def __init__(self, message, location):
+        Exception.__init__(self, message)
+        self.location = location
+
+    def __str__(self):
+        message = Exception.__str__(self)
+        if self.location:
+            return f"{self.location}: {message}"
+        else:
+            return message

infer_4_47_1/lib/python3.10/site-packages/fontTools/otlLib/maxContextCalc.py

@@ -0,0 +1,96 @@
+__all__ = ["maxCtxFont"]
+
+
+def maxCtxFont(font):
+    """Calculate the usMaxContext value for an entire font."""
+
+    maxCtx = 0
+    for tag in ("GSUB", "GPOS"):
+        if tag not in font:
+            continue
+        table = font[tag].table
+        if not table.LookupList:
+            continue
+        for lookup in table.LookupList.Lookup:
+            for st in lookup.SubTable:
+                maxCtx = maxCtxSubtable(maxCtx, tag, lookup.LookupType, st)
+    return maxCtx
+
+
+def maxCtxSubtable(maxCtx, tag, lookupType, st):
+    """Calculate usMaxContext based on a single lookup table (and an existing
+    max value).
+    """
+
+    # single positioning, single / multiple substitution
+    if (tag == "GPOS" and lookupType == 1) or (
+        tag == "GSUB" and lookupType in (1, 2, 3)
+    ):
+        maxCtx = max(maxCtx, 1)
+
+    # pair positioning
+    elif tag == "GPOS" and lookupType == 2:
+        maxCtx = max(maxCtx, 2)
+
+    # ligatures
+    elif tag == "GSUB" and lookupType == 4:
+        for ligatures in st.ligatures.values():
+            for ligature in ligatures:
+                maxCtx = max(maxCtx, ligature.CompCount)
+
+    # context
+    elif (tag == "GPOS" and lookupType == 7) or (tag == "GSUB" and lookupType == 5):
+        maxCtx = maxCtxContextualSubtable(maxCtx, st, "Pos" if tag == "GPOS" else "Sub")
+
+    # chained context
+    elif (tag == "GPOS" and lookupType == 8) or (tag == "GSUB" and lookupType == 6):
+        maxCtx = maxCtxContextualSubtable(
+            maxCtx, st, "Pos" if tag == "GPOS" else "Sub", "Chain"
+        )
+
+    # extensions
+    elif (tag == "GPOS" and lookupType == 9) or (tag == "GSUB" and lookupType == 7):
+        maxCtx = maxCtxSubtable(maxCtx, tag, st.ExtensionLookupType, st.ExtSubTable)
+
+    # reverse-chained context
+    elif tag == "GSUB" and lookupType == 8:
+        maxCtx = maxCtxContextualRule(maxCtx, st, "Reverse")
+
+    return maxCtx
+
+
+def maxCtxContextualSubtable(maxCtx, st, ruleType, chain=""):
+    """Calculate usMaxContext based on a contextual feature subtable."""
+
+    if st.Format == 1:
+        for ruleset in getattr(st, "%s%sRuleSet" % (chain, ruleType)):
+            if ruleset is None:
+                continue
+            for rule in getattr(ruleset, "%s%sRule" % (chain, ruleType)):
+                if rule is None:
+                    continue
+                maxCtx = maxCtxContextualRule(maxCtx, rule, chain)
+
+    elif st.Format == 2:
+        for ruleset in getattr(st, "%s%sClassSet" % (chain, ruleType)):
+            if ruleset is None:
+                continue
+            for rule in getattr(ruleset, "%s%sClassRule" % (chain, ruleType)):
+                if rule is None:
+                    continue
+                maxCtx = maxCtxContextualRule(maxCtx, rule, chain)
+
+    elif st.Format == 3:
+        maxCtx = maxCtxContextualRule(maxCtx, st, chain)
+
+    return maxCtx
+
+
+def maxCtxContextualRule(maxCtx, st, chain):
+    """Calculate usMaxContext based on a contextual feature rule."""
+
+    if not chain:
+        return max(maxCtx, st.GlyphCount)
+    elif chain == "Reverse":
+        return max(maxCtx, 1 + st.LookAheadGlyphCount)
+    return max(maxCtx, st.InputGlyphCount + st.LookAheadGlyphCount)

infer_4_47_1/lib/python3.10/site-packages/fontTools/otlLib/optimize/__init__.py

@@ -0,0 +1,53 @@
+from argparse import RawTextHelpFormatter
+from fontTools.otlLib.optimize.gpos import COMPRESSION_LEVEL, compact
+from fontTools.ttLib import TTFont
+
+
+def main(args=None):
+    """Optimize the layout tables of an existing font"""
+    from argparse import ArgumentParser
+
+    from fontTools import configLogger
+
+    parser = ArgumentParser(
+        prog="otlLib.optimize",
+        description=main.__doc__,
+        formatter_class=RawTextHelpFormatter,
+    )
+    parser.add_argument("font")
+    parser.add_argument(
+        "-o", metavar="OUTPUTFILE", dest="outfile", default=None, help="output file"
+    )
+    parser.add_argument(
+        "--gpos-compression-level",
+        help=COMPRESSION_LEVEL.help,
+        default=COMPRESSION_LEVEL.default,
+        choices=list(range(10)),
+        type=int,
+    )
+    logging_group = parser.add_mutually_exclusive_group(required=False)
+    logging_group.add_argument(
+        "-v", "--verbose", action="store_true", help="Run more verbosely."
+    )
+    logging_group.add_argument(
+        "-q", "--quiet", action="store_true", help="Turn verbosity off."
+    )
+    options = parser.parse_args(args)
+
+    configLogger(
+        level=("DEBUG" if options.verbose else "ERROR" if options.quiet else "INFO")
+    )
+
+    font = TTFont(options.font)
+    compact(font, options.gpos_compression_level)
+    font.save(options.outfile or options.font)
+
+
+if __name__ == "__main__":
+    import sys
+
+    if len(sys.argv) > 1:
+        sys.exit(main())
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

infer_4_47_1/lib/python3.10/site-packages/fontTools/otlLib/optimize/__main__.py

@@ -0,0 +1,6 @@
+import sys
+from fontTools.otlLib.optimize import main
+
+
+if __name__ == "__main__":
+    sys.exit(main())