Add files using upload-large-folder tool

.gitattributes

@@ -280,3 +280,4 @@ evalkit_tf437/lib/python3.10/site-packages/sklearn/neighbors/_ball_tree.cpython-
 evalkit_tf437/lib/python3.10/site-packages/gradio/templates/node/build/client/_app/immutable/chunks/Index.DMrntMgy.js.br filter=lfs diff=lfs merge=lfs -text
 evalkit_tf437/lib/python3.10/site-packages/PIL/_imagingmath.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 evalkit_tf437/lib/python3.10/site-packages/sklearn/metrics/_dist_metrics.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+evalkit_tf437/lib/python3.10/site-packages/fontTools/feaLib/lexer.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,187 @@
+"""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, isCFF2=True)
+    for item in cff.topDictIndex:
+        # Iterate over, such that all are decompiled
+        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)
+
+
+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:]))

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

@@ -0,0 +1,847 @@
+# -*- 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:]]
+            lenBlendStack += numBlends + len(stack) - 1
+            lastBlendIndex = len(stack)
+            # 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"""
+    if len(el) % n != 0:
+        raise ValueError(el)
+    for i in range(0, len(el), 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):
+        if len(args) < 4 or len(args) % 4 > 1:
+            raise ValueError(args)
+        if len(args) % 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):
+        if len(args) < 4 or len(args) % 4 > 1:
+            raise ValueError(args)
+        if len(args) % 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):
+        if len(args) < 4 or len(args) % 8 not in {0, 1, 4, 5}:
+            raise ValueError(args)
+        last_args = None
+        if len(args) % 2 == 1:
+            lastStraight = len(args) % 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):
+        if len(args) < 4 or len(args) % 8 not in {0, 1, 4, 5}:
+            raise ValueError(args)
+        last_args = None
+        if len(args) % 2 == 1:
+            lastStraight = len(args) % 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):
+        if len(args) < 8 or len(args) % 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):
+        if len(args) < 8 or len(args) % 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]
+
+    numRegions = len(args) // numBlends - 1
+    if not (numBlends * (numRegions + 1) == len(args)):
+        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 not func:
+            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]
+        if not isinstance(arg, list):
+            new_args.append(arg)
+            i += 1
+            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]
+            i += 1
+            stack_use += 1 + num_sources  # 1 for the num_blends arg
+            while (i < num_args) and isinstance(args[i], list):
+                blendlist.append(args[i])
+                i += 1
+                stack_use += num_sources
+                if stack_use + num_sources > maxStackLimit:
+                    # 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.
+                    break
+            # 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 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.
+    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:
+                if op2 == "rrcurveto" and len(args2) == 6:
+                    new_op = "rlinecurve"
+                elif len(args2) == 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.
+        if new_op and len(args1) + len(args2) < maxstack:
+            commands[i - 1] = (new_op, args1 + args2)
+            del commands[i]
+
+    # 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"}:
+            op0, op1 = op[:2]
+            if (op0 == "r") ^ (op1 == "r"):
+                assert len(args) % 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 len(args) % 2:
+                if op0 != op1:  # vhcurveto / hvcurveto
+                    if (op0 == "h") ^ (len(args) % 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.",
+    )
+
+    options = parser.parse_args(sys.argv[1:])
+
+    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)))

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

@@ -0,0 +1,483 @@
+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
+                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

evalkit_tf437/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())

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

@@ -0,0 +1,534 @@
+# 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
+
+    COMPILED = cython.compiled
+except (AttributeError, ImportError):
+    # if cython not installed, use mock module with no-op decorators and types
+    from fontTools.misc import cython
+
+    COMPILED = False
+
+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)

evalkit_tf437/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()))
+        )

evalkit_tf437/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)

evalkit_tf437/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",
+]

evalkit_tf437/lib/python3.10/site-packages/fontTools/feaLib/ast.py

@@ -0,0 +1,2134 @@
+from fontTools.feaLib.error import FeatureLibError
+from fontTools.feaLib.location import FeatureLibLocation
+from fontTools.misc.encodingTools import getEncoding
+from fontTools.misc.textTools import byteord, tobytes
+from collections import OrderedDict
+import itertools
+
+SHIFT = " " * 4
+
+__all__ = [
+    "Element",
+    "FeatureFile",
+    "Comment",
+    "GlyphName",
+    "GlyphClass",
+    "GlyphClassName",
+    "MarkClassName",
+    "AnonymousBlock",
+    "Block",
+    "FeatureBlock",
+    "NestedBlock",
+    "LookupBlock",
+    "GlyphClassDefinition",
+    "GlyphClassDefStatement",
+    "MarkClass",
+    "MarkClassDefinition",
+    "AlternateSubstStatement",
+    "Anchor",
+    "AnchorDefinition",
+    "AttachStatement",
+    "AxisValueLocationStatement",
+    "BaseAxis",
+    "CVParametersNameStatement",
+    "ChainContextPosStatement",
+    "ChainContextSubstStatement",
+    "CharacterStatement",
+    "ConditionsetStatement",
+    "CursivePosStatement",
+    "ElidedFallbackName",
+    "ElidedFallbackNameID",
+    "Expression",
+    "FeatureNameStatement",
+    "FeatureReferenceStatement",
+    "FontRevisionStatement",
+    "HheaField",
+    "IgnorePosStatement",
+    "IgnoreSubstStatement",
+    "IncludeStatement",
+    "LanguageStatement",
+    "LanguageSystemStatement",
+    "LigatureCaretByIndexStatement",
+    "LigatureCaretByPosStatement",
+    "LigatureSubstStatement",
+    "LookupFlagStatement",
+    "LookupReferenceStatement",
+    "MarkBasePosStatement",
+    "MarkLigPosStatement",
+    "MarkMarkPosStatement",
+    "MultipleSubstStatement",
+    "NameRecord",
+    "OS2Field",
+    "PairPosStatement",
+    "ReverseChainSingleSubstStatement",
+    "ScriptStatement",
+    "SinglePosStatement",
+    "SingleSubstStatement",
+    "SizeParameters",
+    "Statement",
+    "STATAxisValueStatement",
+    "STATDesignAxisStatement",
+    "STATNameStatement",
+    "SubtableStatement",
+    "TableBlock",
+    "ValueRecord",
+    "ValueRecordDefinition",
+    "VheaField",
+]
+
+
+def deviceToString(device):
+    if device is None:
+        return "<device NULL>"
+    else:
+        return "<device %s>" % ", ".join("%d %d" % t for t in device)
+
+
+fea_keywords = set(
+    [
+        "anchor",
+        "anchordef",
+        "anon",
+        "anonymous",
+        "by",
+        "contour",
+        "cursive",
+        "device",
+        "enum",
+        "enumerate",
+        "excludedflt",
+        "exclude_dflt",
+        "feature",
+        "from",
+        "ignore",
+        "ignorebaseglyphs",
+        "ignoreligatures",
+        "ignoremarks",
+        "include",
+        "includedflt",
+        "include_dflt",
+        "language",
+        "languagesystem",
+        "lookup",
+        "lookupflag",
+        "mark",
+        "markattachmenttype",
+        "markclass",
+        "nameid",
+        "null",
+        "parameters",
+        "pos",
+        "position",
+        "required",
+        "righttoleft",
+        "reversesub",
+        "rsub",
+        "script",
+        "sub",
+        "substitute",
+        "subtable",
+        "table",
+        "usemarkfilteringset",
+        "useextension",
+        "valuerecorddef",
+        "base",
+        "gdef",
+        "head",
+        "hhea",
+        "name",
+        "vhea",
+        "vmtx",
+    ]
+)
+
+
+def asFea(g):
+    if hasattr(g, "asFea"):
+        return g.asFea()
+    elif isinstance(g, tuple) and len(g) == 2:
+        return asFea(g[0]) + " - " + asFea(g[1])  # a range
+    elif g.lower() in fea_keywords:
+        return "\\" + g
+    else:
+        return g
+
+
+class Element(object):
+    """A base class representing "something" in a feature file."""
+
+    def __init__(self, location=None):
+        #: location of this element as a `FeatureLibLocation` object.
+        if location and not isinstance(location, FeatureLibLocation):
+            location = FeatureLibLocation(*location)
+        self.location = location
+
+    def build(self, builder):
+        pass
+
+    def asFea(self, indent=""):
+        """Returns this element as a string of feature code. For block-type
+        elements (such as :class:`FeatureBlock`), the `indent` string is
+        added to the start of each line in the output."""
+        raise NotImplementedError
+
+    def __str__(self):
+        return self.asFea()
+
+
+class Statement(Element):
+    pass
+
+
+class Expression(Element):
+    pass
+
+
+class Comment(Element):
+    """A comment in a feature file."""
+
+    def __init__(self, text, location=None):
+        super(Comment, self).__init__(location)
+        #: Text of the comment
+        self.text = text
+
+    def asFea(self, indent=""):
+        return self.text
+
+
+class NullGlyph(Expression):
+    """The NULL glyph, used in glyph deletion substitutions."""
+
+    def __init__(self, location=None):
+        Expression.__init__(self, location)
+        #: The name itself as a string
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return ()
+
+    def asFea(self, indent=""):
+        return "NULL"
+
+
+class GlyphName(Expression):
+    """A single glyph name, such as ``cedilla``."""
+
+    def __init__(self, glyph, location=None):
+        Expression.__init__(self, location)
+        #: The name itself as a string
+        self.glyph = glyph
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return (self.glyph,)
+
+    def asFea(self, indent=""):
+        return asFea(self.glyph)
+
+
+class GlyphClass(Expression):
+    """A glyph class, such as ``[acute cedilla grave]``."""
+
+    def __init__(self, glyphs=None, location=None):
+        Expression.__init__(self, location)
+        #: The list of glyphs in this class, as :class:`GlyphName` objects.
+        self.glyphs = glyphs if glyphs is not None else []
+        self.original = []
+        self.curr = 0
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return tuple(self.glyphs)
+
+    def asFea(self, indent=""):
+        if len(self.original):
+            if self.curr < len(self.glyphs):
+                self.original.extend(self.glyphs[self.curr :])
+                self.curr = len(self.glyphs)
+            return "[" + " ".join(map(asFea, self.original)) + "]"
+        else:
+            return "[" + " ".join(map(asFea, self.glyphs)) + "]"
+
+    def extend(self, glyphs):
+        """Add a list of :class:`GlyphName` objects to the class."""
+        self.glyphs.extend(glyphs)
+
+    def append(self, glyph):
+        """Add a single :class:`GlyphName` object to the class."""
+        self.glyphs.append(glyph)
+
+    def add_range(self, start, end, glyphs):
+        """Add a range (e.g. ``A-Z``) to the class. ``start`` and ``end``
+        are either :class:`GlyphName` objects or strings representing the
+        start and end glyphs in the class, and ``glyphs`` is the full list of
+        :class:`GlyphName` objects in the range."""
+        if self.curr < len(self.glyphs):
+            self.original.extend(self.glyphs[self.curr :])
+        self.original.append((start, end))
+        self.glyphs.extend(glyphs)
+        self.curr = len(self.glyphs)
+
+    def add_cid_range(self, start, end, glyphs):
+        """Add a range to the class by glyph ID. ``start`` and ``end`` are the
+        initial and final IDs, and ``glyphs`` is the full list of
+        :class:`GlyphName` objects in the range."""
+        if self.curr < len(self.glyphs):
+            self.original.extend(self.glyphs[self.curr :])
+        self.original.append(("\\{}".format(start), "\\{}".format(end)))
+        self.glyphs.extend(glyphs)
+        self.curr = len(self.glyphs)
+
+    def add_class(self, gc):
+        """Add glyphs from the given :class:`GlyphClassName` object to the
+        class."""
+        if self.curr < len(self.glyphs):
+            self.original.extend(self.glyphs[self.curr :])
+        self.original.append(gc)
+        self.glyphs.extend(gc.glyphSet())
+        self.curr = len(self.glyphs)
+
+
+class GlyphClassName(Expression):
+    """A glyph class name, such as ``@FRENCH_MARKS``. This must be instantiated
+    with a :class:`GlyphClassDefinition` object."""
+
+    def __init__(self, glyphclass, location=None):
+        Expression.__init__(self, location)
+        assert isinstance(glyphclass, GlyphClassDefinition)
+        self.glyphclass = glyphclass
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return tuple(self.glyphclass.glyphSet())
+
+    def asFea(self, indent=""):
+        return "@" + self.glyphclass.name
+
+
+class MarkClassName(Expression):
+    """A mark class name, such as ``@FRENCH_MARKS`` defined with ``markClass``.
+    This must be instantiated with a :class:`MarkClass` object."""
+
+    def __init__(self, markClass, location=None):
+        Expression.__init__(self, location)
+        assert isinstance(markClass, MarkClass)
+        self.markClass = markClass
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return self.markClass.glyphSet()
+
+    def asFea(self, indent=""):
+        return "@" + self.markClass.name
+
+
+class AnonymousBlock(Statement):
+    """An anonymous data block."""
+
+    def __init__(self, tag, content, location=None):
+        Statement.__init__(self, location)
+        self.tag = tag  #: string containing the block's "tag"
+        self.content = content  #: block data as string
+
+    def asFea(self, indent=""):
+        res = "anon {} {{\n".format(self.tag)
+        res += self.content
+        res += "}} {};\n\n".format(self.tag)
+        return res
+
+
+class Block(Statement):
+    """A block of statements: feature, lookup, etc."""
+
+    def __init__(self, location=None):
+        Statement.__init__(self, location)
+        self.statements = []  #: Statements contained in the block
+
+    def build(self, builder):
+        """When handed a 'builder' object of comparable interface to
+        :class:`fontTools.feaLib.builder`, walks the statements in this
+        block, calling the builder callbacks."""
+        for s in self.statements:
+            s.build(builder)
+
+    def asFea(self, indent=""):
+        indent += SHIFT
+        return (
+            indent
+            + ("\n" + indent).join([s.asFea(indent=indent) for s in self.statements])
+            + "\n"
+        )
+
+
+class FeatureFile(Block):
+    """The top-level element of the syntax tree, containing the whole feature
+    file in its ``statements`` attribute."""
+
+    def __init__(self):
+        Block.__init__(self, location=None)
+        self.markClasses = {}  # name --> ast.MarkClass
+
+    def asFea(self, indent=""):
+        return "\n".join(s.asFea(indent=indent) for s in self.statements)
+
+
+class FeatureBlock(Block):
+    """A named feature block."""
+
+    def __init__(self, name, use_extension=False, location=None):
+        Block.__init__(self, location)
+        self.name, self.use_extension = name, use_extension
+
+    def build(self, builder):
+        """Call the ``start_feature`` callback on the builder object, visit
+        all the statements in this feature, and then call ``end_feature``."""
+        # TODO(sascha): Handle use_extension.
+        builder.start_feature(self.location, self.name)
+        # language exclude_dflt statements modify builder.features_
+        # limit them to this block with temporary builder.features_
+        features = builder.features_
+        builder.features_ = {}
+        Block.build(self, builder)
+        for key, value in builder.features_.items():
+            features.setdefault(key, []).extend(value)
+        builder.features_ = features
+        builder.end_feature()
+
+    def asFea(self, indent=""):
+        res = indent + "feature %s " % self.name.strip()
+        if self.use_extension:
+            res += "useExtension "
+        res += "{\n"
+        res += Block.asFea(self, indent=indent)
+        res += indent + "} %s;\n" % self.name.strip()
+        return res
+
+
+class NestedBlock(Block):
+    """A block inside another block, for example when found inside a
+    ``cvParameters`` block."""
+
+    def __init__(self, tag, block_name, location=None):
+        Block.__init__(self, location)
+        self.tag = tag
+        self.block_name = block_name
+
+    def build(self, builder):
+        Block.build(self, builder)
+        if self.block_name == "ParamUILabelNameID":
+            builder.add_to_cv_num_named_params(self.tag)
+
+    def asFea(self, indent=""):
+        res = "{}{} {{\n".format(indent, self.block_name)
+        res += Block.asFea(self, indent=indent)
+        res += "{}}};\n".format(indent)
+        return res
+
+
+class LookupBlock(Block):
+    """A named lookup, containing ``statements``."""
+
+    def __init__(self, name, use_extension=False, location=None):
+        Block.__init__(self, location)
+        self.name, self.use_extension = name, use_extension
+
+    def build(self, builder):
+        # TODO(sascha): Handle use_extension.
+        builder.start_lookup_block(self.location, self.name)
+        Block.build(self, builder)
+        builder.end_lookup_block()
+
+    def asFea(self, indent=""):
+        res = "lookup {} ".format(self.name)
+        if self.use_extension:
+            res += "useExtension "
+        res += "{\n"
+        res += Block.asFea(self, indent=indent)
+        res += "{}}} {};\n".format(indent, self.name)
+        return res
+
+
+class TableBlock(Block):
+    """A ``table ... { }`` block."""
+
+    def __init__(self, name, location=None):
+        Block.__init__(self, location)
+        self.name = name
+
+    def asFea(self, indent=""):
+        res = "table {} {{\n".format(self.name.strip())
+        res += super(TableBlock, self).asFea(indent=indent)
+        res += "}} {};\n".format(self.name.strip())
+        return res
+
+
+class GlyphClassDefinition(Statement):
+    """Example: ``@UPPERCASE = [A-Z];``."""
+
+    def __init__(self, name, glyphs, location=None):
+        Statement.__init__(self, location)
+        self.name = name  #: class name as a string, without initial ``@``
+        self.glyphs = glyphs  #: a :class:`GlyphClass` object
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return tuple(self.glyphs.glyphSet())
+
+    def asFea(self, indent=""):
+        return "@" + self.name + " = " + self.glyphs.asFea() + ";"
+
+
+class GlyphClassDefStatement(Statement):
+    """Example: ``GlyphClassDef @UPPERCASE, [B], [C], [D];``. The parameters
+    must be either :class:`GlyphClass` or :class:`GlyphClassName` objects, or
+    ``None``."""
+
+    def __init__(
+        self, baseGlyphs, markGlyphs, ligatureGlyphs, componentGlyphs, location=None
+    ):
+        Statement.__init__(self, location)
+        self.baseGlyphs, self.markGlyphs = (baseGlyphs, markGlyphs)
+        self.ligatureGlyphs = ligatureGlyphs
+        self.componentGlyphs = componentGlyphs
+
+    def build(self, builder):
+        """Calls the builder's ``add_glyphClassDef`` callback."""
+        base = self.baseGlyphs.glyphSet() if self.baseGlyphs else tuple()
+        liga = self.ligatureGlyphs.glyphSet() if self.ligatureGlyphs else tuple()
+        mark = self.markGlyphs.glyphSet() if self.markGlyphs else tuple()
+        comp = self.componentGlyphs.glyphSet() if self.componentGlyphs else tuple()
+        builder.add_glyphClassDef(self.location, base, liga, mark, comp)
+
+    def asFea(self, indent=""):
+        return "GlyphClassDef {}, {}, {}, {};".format(
+            self.baseGlyphs.asFea() if self.baseGlyphs else "",
+            self.ligatureGlyphs.asFea() if self.ligatureGlyphs else "",
+            self.markGlyphs.asFea() if self.markGlyphs else "",
+            self.componentGlyphs.asFea() if self.componentGlyphs else "",
+        )
+
+
+class MarkClass(object):
+    """One `or more` ``markClass`` statements for the same mark class.
+
+    While glyph classes can be defined only once, the feature file format
+    allows expanding mark classes with multiple definitions, each using
+    different glyphs and anchors. The following are two ``MarkClassDefinitions``
+    for the same ``MarkClass``::
+
+        markClass [acute grave] <anchor 350 800> @FRENCH_ACCENTS;
+        markClass [cedilla] <anchor 350 -200> @FRENCH_ACCENTS;
+
+    The ``MarkClass`` object is therefore just a container for a list of
+    :class:`MarkClassDefinition` statements.
+    """
+
+    def __init__(self, name):
+        self.name = name
+        self.definitions = []
+        self.glyphs = OrderedDict()  # glyph --> ast.MarkClassDefinitions
+
+    def addDefinition(self, definition):
+        """Add a :class:`MarkClassDefinition` statement to this mark class."""
+        assert isinstance(definition, MarkClassDefinition)
+        self.definitions.append(definition)
+        for glyph in definition.glyphSet():
+            if glyph in self.glyphs:
+                otherLoc = self.glyphs[glyph].location
+                if otherLoc is None:
+                    end = ""
+                else:
+                    end = f" at {otherLoc}"
+                raise FeatureLibError(
+                    "Glyph %s already defined%s" % (glyph, end), definition.location
+                )
+            self.glyphs[glyph] = definition
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return tuple(self.glyphs.keys())
+
+    def asFea(self, indent=""):
+        res = "\n".join(d.asFea() for d in self.definitions)
+        return res
+
+
+class MarkClassDefinition(Statement):
+    """A single ``markClass`` statement. The ``markClass`` should be a
+    :class:`MarkClass` object, the ``anchor`` an :class:`Anchor` object,
+    and the ``glyphs`` parameter should be a `glyph-containing object`_ .
+
+    Example:
+
+        .. code:: python
+
+            mc = MarkClass("FRENCH_ACCENTS")
+            mc.addDefinition( MarkClassDefinition(mc, Anchor(350, 800),
+                GlyphClass([ GlyphName("acute"), GlyphName("grave") ])
+            ) )
+            mc.addDefinition( MarkClassDefinition(mc, Anchor(350, -200),
+                GlyphClass([ GlyphName("cedilla") ])
+            ) )
+
+            mc.asFea()
+            # markClass [acute grave] <anchor 350 800> @FRENCH_ACCENTS;
+            # markClass [cedilla] <anchor 350 -200> @FRENCH_ACCENTS;
+
+    """
+
+    def __init__(self, markClass, anchor, glyphs, location=None):
+        Statement.__init__(self, location)
+        assert isinstance(markClass, MarkClass)
+        assert isinstance(anchor, Anchor) and isinstance(glyphs, Expression)
+        self.markClass, self.anchor, self.glyphs = markClass, anchor, glyphs
+
+    def glyphSet(self):
+        """The glyphs in this class as a tuple of :class:`GlyphName` objects."""
+        return self.glyphs.glyphSet()
+
+    def asFea(self, indent=""):
+        return "markClass {} {} @{};".format(
+            self.glyphs.asFea(), self.anchor.asFea(), self.markClass.name
+        )
+
+
+class AlternateSubstStatement(Statement):
+    """A ``sub ... from ...`` statement.
+
+    ``prefix``, ``glyph``, ``suffix`` and ``replacement`` should be lists of
+    `glyph-containing objects`_. ``glyph`` should be a `one element list`."""
+
+    def __init__(self, prefix, glyph, suffix, replacement, location=None):
+        Statement.__init__(self, location)
+        self.prefix, self.glyph, self.suffix = (prefix, glyph, suffix)
+        self.replacement = replacement
+
+    def build(self, builder):
+        """Calls the builder's ``add_alternate_subst`` callback."""
+        glyph = self.glyph.glyphSet()
+        assert len(glyph) == 1, glyph
+        glyph = list(glyph)[0]
+        prefix = [p.glyphSet() for p in self.prefix]
+        suffix = [s.glyphSet() for s in self.suffix]
+        replacement = self.replacement.glyphSet()
+        builder.add_alternate_subst(self.location, prefix, glyph, suffix, replacement)
+
+    def asFea(self, indent=""):
+        res = "sub "
+        if len(self.prefix) or len(self.suffix):
+            if len(self.prefix):
+                res += " ".join(map(asFea, self.prefix)) + " "
+            res += asFea(self.glyph) + "'"  # even though we really only use 1
+            if len(self.suffix):
+                res += " " + " ".join(map(asFea, self.suffix))
+        else:
+            res += asFea(self.glyph)
+        res += " from "
+        res += asFea(self.replacement)
+        res += ";"
+        return res
+
+
+class Anchor(Expression):
+    """An ``Anchor`` element, used inside a ``pos`` rule.
+
+    If a ``name`` is given, this will be used in preference to the coordinates.
+    Other values should be integer.
+    """
+
+    def __init__(
+        self,
+        x,
+        y,
+        name=None,
+        contourpoint=None,
+        xDeviceTable=None,
+        yDeviceTable=None,
+        location=None,
+    ):
+        Expression.__init__(self, location)
+        self.name = name
+        self.x, self.y, self.contourpoint = x, y, contourpoint
+        self.xDeviceTable, self.yDeviceTable = xDeviceTable, yDeviceTable
+
+    def asFea(self, indent=""):
+        if self.name is not None:
+            return "<anchor {}>".format(self.name)
+        res = "<anchor {} {}".format(self.x, self.y)
+        if self.contourpoint:
+            res += " contourpoint {}".format(self.contourpoint)
+        if self.xDeviceTable or self.yDeviceTable:
+            res += " "
+            res += deviceToString(self.xDeviceTable)
+            res += " "
+            res += deviceToString(self.yDeviceTable)
+        res += ">"
+        return res
+
+
+class AnchorDefinition(Statement):
+    """A named anchor definition. (2.e.viii). ``name`` should be a string."""
+
+    def __init__(self, name, x, y, contourpoint=None, location=None):
+        Statement.__init__(self, location)
+        self.name, self.x, self.y, self.contourpoint = name, x, y, contourpoint
+
+    def asFea(self, indent=""):
+        res = "anchorDef {} {}".format(self.x, self.y)
+        if self.contourpoint:
+            res += " contourpoint {}".format(self.contourpoint)
+        res += " {};".format(self.name)
+        return res
+
+
+class AttachStatement(Statement):
+    """A ``GDEF`` table ``Attach`` statement."""
+
+    def __init__(self, glyphs, contourPoints, location=None):
+        Statement.__init__(self, location)
+        self.glyphs = glyphs  #: A `glyph-containing object`_
+        self.contourPoints = contourPoints  #: A list of integer contour points
+
+    def build(self, builder):
+        """Calls the builder's ``add_attach_points`` callback."""
+        glyphs = self.glyphs.glyphSet()
+        builder.add_attach_points(self.location, glyphs, self.contourPoints)
+
+    def asFea(self, indent=""):
+        return "Attach {} {};".format(
+            self.glyphs.asFea(), " ".join(str(c) for c in self.contourPoints)
+        )
+
+
+class ChainContextPosStatement(Statement):
+    r"""A chained contextual positioning statement.
+
+    ``prefix``, ``glyphs``, and ``suffix`` should be lists of
+    `glyph-containing objects`_ .
+
+    ``lookups`` should be a list of elements representing what lookups
+    to apply at each glyph position. Each element should be a
+    :class:`LookupBlock` to apply a single chaining lookup at the given
+    position, a list of :class:`LookupBlock`\ s to apply multiple
+    lookups, or ``None`` to apply no lookup. The length of the outer
+    list should equal the length of ``glyphs``; the inner lists can be
+    of variable length."""
+
+    def __init__(self, prefix, glyphs, suffix, lookups, location=None):
+        Statement.__init__(self, location)
+        self.prefix, self.glyphs, self.suffix = prefix, glyphs, suffix
+        self.lookups = list(lookups)
+        for i, lookup in enumerate(lookups):
+            if lookup:
+                try:
+                    (_ for _ in lookup)
+                except TypeError:
+                    self.lookups[i] = [lookup]
+
+    def build(self, builder):
+        """Calls the builder's ``add_chain_context_pos`` callback."""
+        prefix = [p.glyphSet() for p in self.prefix]
+        glyphs = [g.glyphSet() for g in self.glyphs]
+        suffix = [s.glyphSet() for s in self.suffix]
+        builder.add_chain_context_pos(
+            self.location, prefix, glyphs, suffix, self.lookups
+        )
+
+    def asFea(self, indent=""):
+        res = "pos "
+        if (
+            len(self.prefix)
+            or len(self.suffix)
+            or any([x is not None for x in self.lookups])
+        ):
+            if len(self.prefix):
+                res += " ".join(g.asFea() for g in self.prefix) + " "
+            for i, g in enumerate(self.glyphs):
+                res += g.asFea() + "'"
+                if self.lookups[i]:
+                    for lu in self.lookups[i]:
+                        res += " lookup " + lu.name
+                if i < len(self.glyphs) - 1:
+                    res += " "
+            if len(self.suffix):
+                res += " " + " ".join(map(asFea, self.suffix))
+        else:
+            res += " ".join(map(asFea, self.glyph))
+        res += ";"
+        return res
+
+
+class ChainContextSubstStatement(Statement):
+    r"""A chained contextual substitution statement.
+
+    ``prefix``, ``glyphs``, and ``suffix`` should be lists of
+    `glyph-containing objects`_ .
+
+    ``lookups`` should be a list of elements representing what lookups
+    to apply at each glyph position. Each element should be a
+    :class:`LookupBlock` to apply a single chaining lookup at the given
+    position, a list of :class:`LookupBlock`\ s to apply multiple
+    lookups, or ``None`` to apply no lookup. The length of the outer
+    list should equal the length of ``glyphs``; the inner lists can be
+    of variable length."""
+
+    def __init__(self, prefix, glyphs, suffix, lookups, location=None):
+        Statement.__init__(self, location)
+        self.prefix, self.glyphs, self.suffix = prefix, glyphs, suffix
+        self.lookups = list(lookups)
+        for i, lookup in enumerate(lookups):
+            if lookup:
+                try:
+                    (_ for _ in lookup)
+                except TypeError:
+                    self.lookups[i] = [lookup]
+
+    def build(self, builder):
+        """Calls the builder's ``add_chain_context_subst`` callback."""
+        prefix = [p.glyphSet() for p in self.prefix]
+        glyphs = [g.glyphSet() for g in self.glyphs]
+        suffix = [s.glyphSet() for s in self.suffix]
+        builder.add_chain_context_subst(
+            self.location, prefix, glyphs, suffix, self.lookups
+        )
+
+    def asFea(self, indent=""):
+        res = "sub "
+        if (
+            len(self.prefix)
+            or len(self.suffix)
+            or any([x is not None for x in self.lookups])
+        ):
+            if len(self.prefix):
+                res += " ".join(g.asFea() for g in self.prefix) + " "
+            for i, g in enumerate(self.glyphs):
+                res += g.asFea() + "'"
+                if self.lookups[i]:
+                    for lu in self.lookups[i]:
+                        res += " lookup " + lu.name
+                if i < len(self.glyphs) - 1:
+                    res += " "
+            if len(self.suffix):
+                res += " " + " ".join(map(asFea, self.suffix))
+        else:
+            res += " ".join(map(asFea, self.glyph))
+        res += ";"
+        return res
+
+
+class CursivePosStatement(Statement):
+    """A cursive positioning statement. Entry and exit anchors can either
+    be :class:`Anchor` objects or ``None``."""
+
+    def __init__(self, glyphclass, entryAnchor, exitAnchor, location=None):
+        Statement.__init__(self, location)
+        self.glyphclass = glyphclass
+        self.entryAnchor, self.exitAnchor = entryAnchor, exitAnchor
+
+    def build(self, builder):
+        """Calls the builder object's ``add_cursive_pos`` callback."""
+        builder.add_cursive_pos(
+            self.location, self.glyphclass.glyphSet(), self.entryAnchor, self.exitAnchor
+        )
+
+    def asFea(self, indent=""):
+        entry = self.entryAnchor.asFea() if self.entryAnchor else "<anchor NULL>"
+        exit = self.exitAnchor.asFea() if self.exitAnchor else "<anchor NULL>"
+        return "pos cursive {} {} {};".format(self.glyphclass.asFea(), entry, exit)
+
+
+class FeatureReferenceStatement(Statement):
+    """Example: ``feature salt;``"""
+
+    def __init__(self, featureName, location=None):
+        Statement.__init__(self, location)
+        self.location, self.featureName = (location, featureName)
+
+    def build(self, builder):
+        """Calls the builder object's ``add_feature_reference`` callback."""
+        builder.add_feature_reference(self.location, self.featureName)
+
+    def asFea(self, indent=""):
+        return "feature {};".format(self.featureName)
+
+
+class IgnorePosStatement(Statement):
+    """An ``ignore pos`` statement, containing `one or more` contexts to ignore.
+
+    ``chainContexts`` should be a list of ``(prefix, glyphs, suffix)`` tuples,
+    with each of ``prefix``, ``glyphs`` and ``suffix`` being
+    `glyph-containing objects`_ ."""
+
+    def __init__(self, chainContexts, location=None):
+        Statement.__init__(self, location)
+        self.chainContexts = chainContexts
+
+    def build(self, builder):
+        """Calls the builder object's ``add_chain_context_pos`` callback on each
+        rule context."""
+        for prefix, glyphs, suffix in self.chainContexts:
+            prefix = [p.glyphSet() for p in prefix]
+            glyphs = [g.glyphSet() for g in glyphs]
+            suffix = [s.glyphSet() for s in suffix]
+            builder.add_chain_context_pos(self.location, prefix, glyphs, suffix, [])
+
+    def asFea(self, indent=""):
+        contexts = []
+        for prefix, glyphs, suffix in self.chainContexts:
+            res = ""
+            if len(prefix) or len(suffix):
+                if len(prefix):
+                    res += " ".join(map(asFea, prefix)) + " "
+                res += " ".join(g.asFea() + "'" for g in glyphs)
+                if len(suffix):
+                    res += " " + " ".join(map(asFea, suffix))
+            else:
+                res += " ".join(map(asFea, glyphs))
+            contexts.append(res)
+        return "ignore pos " + ", ".join(contexts) + ";"
+
+
+class IgnoreSubstStatement(Statement):
+    """An ``ignore sub`` statement, containing `one or more` contexts to ignore.
+
+    ``chainContexts`` should be a list of ``(prefix, glyphs, suffix)`` tuples,
+    with each of ``prefix``, ``glyphs`` and ``suffix`` being
+    `glyph-containing objects`_ ."""
+
+    def __init__(self, chainContexts, location=None):
+        Statement.__init__(self, location)
+        self.chainContexts = chainContexts
+
+    def build(self, builder):
+        """Calls the builder object's ``add_chain_context_subst`` callback on
+        each rule context."""
+        for prefix, glyphs, suffix in self.chainContexts:
+            prefix = [p.glyphSet() for p in prefix]
+            glyphs = [g.glyphSet() for g in glyphs]
+            suffix = [s.glyphSet() for s in suffix]
+            builder.add_chain_context_subst(self.location, prefix, glyphs, suffix, [])
+
+    def asFea(self, indent=""):
+        contexts = []
+        for prefix, glyphs, suffix in self.chainContexts:
+            res = ""
+            if len(prefix):
+                res += " ".join(map(asFea, prefix)) + " "
+            res += " ".join(g.asFea() + "'" for g in glyphs)
+            if len(suffix):
+                res += " " + " ".join(map(asFea, suffix))
+            contexts.append(res)
+        return "ignore sub " + ", ".join(contexts) + ";"
+
+
+class IncludeStatement(Statement):
+    """An ``include()`` statement."""
+
+    def __init__(self, filename, location=None):
+        super(IncludeStatement, self).__init__(location)
+        self.filename = filename  #: String containing name of file to include
+
+    def build(self):
+        # TODO: consider lazy-loading the including parser/lexer?
+        raise FeatureLibError(
+            "Building an include statement is not implemented yet. "
+            "Instead, use Parser(..., followIncludes=True) for building.",
+            self.location,
+        )
+
+    def asFea(self, indent=""):
+        return indent + "include(%s);" % self.filename
+
+
+class LanguageStatement(Statement):
+    """A ``language`` statement within a feature."""
+
+    def __init__(self, language, include_default=True, required=False, location=None):
+        Statement.__init__(self, location)
+        assert len(language) == 4
+        self.language = language  #: A four-character language tag
+        self.include_default = include_default  #: If false, "exclude_dflt"
+        self.required = required
+
+    def build(self, builder):
+        """Call the builder object's ``set_language`` callback."""
+        builder.set_language(
+            location=self.location,
+            language=self.language,
+            include_default=self.include_default,
+            required=self.required,
+        )
+
+    def asFea(self, indent=""):
+        res = "language {}".format(self.language.strip())
+        if not self.include_default:
+            res += " exclude_dflt"
+        if self.required:
+            res += " required"
+        res += ";"
+        return res
+
+
+class LanguageSystemStatement(Statement):
+    """A top-level ``languagesystem`` statement."""
+
+    def __init__(self, script, language, location=None):
+        Statement.__init__(self, location)
+        self.script, self.language = (script, language)
+
+    def build(self, builder):
+        """Calls the builder object's ``add_language_system`` callback."""
+        builder.add_language_system(self.location, self.script, self.language)
+
+    def asFea(self, indent=""):
+        return "languagesystem {} {};".format(self.script, self.language.strip())
+
+
+class FontRevisionStatement(Statement):
+    """A ``head`` table ``FontRevision`` statement. ``revision`` should be a
+    number, and will be formatted to three significant decimal places."""
+
+    def __init__(self, revision, location=None):
+        Statement.__init__(self, location)
+        self.revision = revision
+
+    def build(self, builder):
+        builder.set_font_revision(self.location, self.revision)
+
+    def asFea(self, indent=""):
+        return "FontRevision {:.3f};".format(self.revision)
+
+
+class LigatureCaretByIndexStatement(Statement):
+    """A ``GDEF`` table ``LigatureCaretByIndex`` statement. ``glyphs`` should be
+    a `glyph-containing object`_, and ``carets`` should be a list of integers."""
+
+    def __init__(self, glyphs, carets, location=None):
+        Statement.__init__(self, location)
+        self.glyphs, self.carets = (glyphs, carets)
+
+    def build(self, builder):
+        """Calls the builder object's ``add_ligatureCaretByIndex_`` callback."""
+        glyphs = self.glyphs.glyphSet()
+        builder.add_ligatureCaretByIndex_(self.location, glyphs, set(self.carets))
+
+    def asFea(self, indent=""):
+        return "LigatureCaretByIndex {} {};".format(
+            self.glyphs.asFea(), " ".join(str(x) for x in self.carets)
+        )
+
+
+class LigatureCaretByPosStatement(Statement):
+    """A ``GDEF`` table ``LigatureCaretByPos`` statement. ``glyphs`` should be
+    a `glyph-containing object`_, and ``carets`` should be a list of integers."""
+
+    def __init__(self, glyphs, carets, location=None):
+        Statement.__init__(self, location)
+        self.glyphs, self.carets = (glyphs, carets)
+
+    def build(self, builder):
+        """Calls the builder object's ``add_ligatureCaretByPos_`` callback."""
+        glyphs = self.glyphs.glyphSet()
+        builder.add_ligatureCaretByPos_(self.location, glyphs, set(self.carets))
+
+    def asFea(self, indent=""):
+        return "LigatureCaretByPos {} {};".format(
+            self.glyphs.asFea(), " ".join(str(x) for x in self.carets)
+        )
+
+
+class LigatureSubstStatement(Statement):
+    """A chained contextual substitution statement.
+
+    ``prefix``, ``glyphs``, and ``suffix`` should be lists of
+    `glyph-containing objects`_; ``replacement`` should be a single
+    `glyph-containing object`_.
+
+    If ``forceChain`` is True, this is expressed as a chaining rule
+    (e.g. ``sub f' i' by f_i``) even when no context is given."""
+
+    def __init__(self, prefix, glyphs, suffix, replacement, forceChain, location=None):
+        Statement.__init__(self, location)
+        self.prefix, self.glyphs, self.suffix = (prefix, glyphs, suffix)
+        self.replacement, self.forceChain = replacement, forceChain
+
+    def build(self, builder):
+        prefix = [p.glyphSet() for p in self.prefix]
+        glyphs = [g.glyphSet() for g in self.glyphs]
+        suffix = [s.glyphSet() for s in self.suffix]
+        builder.add_ligature_subst(
+            self.location, prefix, glyphs, suffix, self.replacement, self.forceChain
+        )
+
+    def asFea(self, indent=""):
+        res = "sub "
+        if len(self.prefix) or len(self.suffix) or self.forceChain:
+            if len(self.prefix):
+                res += " ".join(g.asFea() for g in self.prefix) + " "
+            res += " ".join(g.asFea() + "'" for g in self.glyphs)
+            if len(self.suffix):
+                res += " " + " ".join(g.asFea() for g in self.suffix)
+        else:
+            res += " ".join(g.asFea() for g in self.glyphs)
+        res += " by "
+        res += asFea(self.replacement)
+        res += ";"
+        return res
+
+
+class LookupFlagStatement(Statement):
+    """A ``lookupflag`` statement. The ``value`` should be an integer value
+    representing the flags in use, but not including the ``markAttachment``
+    class and ``markFilteringSet`` values, which must be specified as
+    glyph-containing objects."""
+
+    def __init__(
+        self, value=0, markAttachment=None, markFilteringSet=None, location=None
+    ):
+        Statement.__init__(self, location)
+        self.value = value
+        self.markAttachment = markAttachment
+        self.markFilteringSet = markFilteringSet
+
+    def build(self, builder):
+        """Calls the builder object's ``set_lookup_flag`` callback."""
+        markAttach = None
+        if self.markAttachment is not None:
+            markAttach = self.markAttachment.glyphSet()
+        markFilter = None
+        if self.markFilteringSet is not None:
+            markFilter = self.markFilteringSet.glyphSet()
+        builder.set_lookup_flag(self.location, self.value, markAttach, markFilter)
+
+    def asFea(self, indent=""):
+        res = []
+        flags = ["RightToLeft", "IgnoreBaseGlyphs", "IgnoreLigatures", "IgnoreMarks"]
+        curr = 1
+        for i in range(len(flags)):
+            if self.value & curr != 0:
+                res.append(flags[i])
+            curr = curr << 1
+        if self.markAttachment is not None:
+            res.append("MarkAttachmentType {}".format(self.markAttachment.asFea()))
+        if self.markFilteringSet is not None:
+            res.append("UseMarkFilteringSet {}".format(self.markFilteringSet.asFea()))
+        if not res:
+            res = ["0"]
+        return "lookupflag {};".format(" ".join(res))
+
+
+class LookupReferenceStatement(Statement):
+    """Represents a ``lookup ...;`` statement to include a lookup in a feature.
+
+    The ``lookup`` should be a :class:`LookupBlock` object."""
+
+    def __init__(self, lookup, location=None):
+        Statement.__init__(self, location)
+        self.location, self.lookup = (location, lookup)
+
+    def build(self, builder):
+        """Calls the builder object's ``add_lookup_call`` callback."""
+        builder.add_lookup_call(self.lookup.name)
+
+    def asFea(self, indent=""):
+        return "lookup {};".format(self.lookup.name)
+
+
+class MarkBasePosStatement(Statement):
+    """A mark-to-base positioning rule. The ``base`` should be a
+    `glyph-containing object`_. The ``marks`` should be a list of
+    (:class:`Anchor`, :class:`MarkClass`) tuples."""
+
+    def __init__(self, base, marks, location=None):
+        Statement.__init__(self, location)
+        self.base, self.marks = base, marks
+
+    def build(self, builder):
+        """Calls the builder object's ``add_mark_base_pos`` callback."""
+        builder.add_mark_base_pos(self.location, self.base.glyphSet(), self.marks)
+
+    def asFea(self, indent=""):
+        res = "pos base {}".format(self.base.asFea())
+        for a, m in self.marks:
+            res += "\n" + indent + SHIFT + "{} mark @{}".format(a.asFea(), m.name)
+        res += ";"
+        return res
+
+
+class MarkLigPosStatement(Statement):
+    """A mark-to-ligature positioning rule. The ``ligatures`` must be a
+    `glyph-containing object`_. The ``marks`` should be a list of lists: each
+    element in the top-level list represents a component glyph, and is made
+    up of a list of (:class:`Anchor`, :class:`MarkClass`) tuples representing
+    mark attachment points for that position.
+
+    Example::
+
+        m1 = MarkClass("TOP_MARKS")
+        m2 = MarkClass("BOTTOM_MARKS")
+        # ... add definitions to mark classes...
+
+        glyph = GlyphName("lam_meem_jeem")
+        marks = [
+            [ (Anchor(625,1800), m1) ], # Attachments on 1st component (lam)
+            [ (Anchor(376,-378), m2) ], # Attachments on 2nd component (meem)
+            [ ]                         # No attachments on the jeem
+        ]
+        mlp = MarkLigPosStatement(glyph, marks)
+
+        mlp.asFea()
+        # pos ligature lam_meem_jeem <anchor 625 1800> mark @TOP_MARKS
+        # ligComponent <anchor 376 -378> mark @BOTTOM_MARKS;
+
+    """
+
+    def __init__(self, ligatures, marks, location=None):
+        Statement.__init__(self, location)
+        self.ligatures, self.marks = ligatures, marks
+
+    def build(self, builder):
+        """Calls the builder object's ``add_mark_lig_pos`` callback."""
+        builder.add_mark_lig_pos(self.location, self.ligatures.glyphSet(), self.marks)
+
+    def asFea(self, indent=""):
+        res = "pos ligature {}".format(self.ligatures.asFea())
+        ligs = []
+        for l in self.marks:
+            temp = ""
+            if l is None or not len(l):
+                temp = "\n" + indent + SHIFT * 2 + "<anchor NULL>"
+            else:
+                for a, m in l:
+                    temp += (
+                        "\n"
+                        + indent
+                        + SHIFT * 2
+                        + "{} mark @{}".format(a.asFea(), m.name)
+                    )
+            ligs.append(temp)
+        res += ("\n" + indent + SHIFT + "ligComponent").join(ligs)
+        res += ";"
+        return res
+
+
+class MarkMarkPosStatement(Statement):
+    """A mark-to-mark positioning rule. The ``baseMarks`` must be a
+    `glyph-containing object`_. The ``marks`` should be a list of
+    (:class:`Anchor`, :class:`MarkClass`) tuples."""
+
+    def __init__(self, baseMarks, marks, location=None):
+        Statement.__init__(self, location)
+        self.baseMarks, self.marks = baseMarks, marks
+
+    def build(self, builder):
+        """Calls the builder object's ``add_mark_mark_pos`` callback."""
+        builder.add_mark_mark_pos(self.location, self.baseMarks.glyphSet(), self.marks)
+
+    def asFea(self, indent=""):
+        res = "pos mark {}".format(self.baseMarks.asFea())
+        for a, m in self.marks:
+            res += "\n" + indent + SHIFT + "{} mark @{}".format(a.asFea(), m.name)
+        res += ";"
+        return res
+
+
+class MultipleSubstStatement(Statement):
+    """A multiple substitution statement.
+
+    Args:
+        prefix: a list of `glyph-containing objects`_.
+        glyph: a single glyph-containing object.
+        suffix: a list of glyph-containing objects.
+        replacement: a list of glyph-containing objects.
+        forceChain: If true, the statement is expressed as a chaining rule
+            (e.g. ``sub f' i' by f_i``) even when no context is given.
+    """
+
+    def __init__(
+        self, prefix, glyph, suffix, replacement, forceChain=False, location=None
+    ):
+        Statement.__init__(self, location)
+        self.prefix, self.glyph, self.suffix = prefix, glyph, suffix
+        self.replacement = replacement
+        self.forceChain = forceChain
+
+    def build(self, builder):
+        """Calls the builder object's ``add_multiple_subst`` callback."""
+        prefix = [p.glyphSet() for p in self.prefix]
+        suffix = [s.glyphSet() for s in self.suffix]
+        if hasattr(self.glyph, "glyphSet"):
+            originals = self.glyph.glyphSet()
+        else:
+            originals = [self.glyph]
+        count = len(originals)
+        replaces = []
+        for r in self.replacement:
+            if hasattr(r, "glyphSet"):
+                replace = r.glyphSet()
+            else:
+                replace = [r]
+            if len(replace) == 1 and len(replace) != count:
+                replace = replace * count
+            replaces.append(replace)
+        replaces = list(zip(*replaces))
+
+        seen_originals = set()
+        for i, original in enumerate(originals):
+            if original not in seen_originals:
+                seen_originals.add(original)
+                builder.add_multiple_subst(
+                    self.location,
+                    prefix,
+                    original,
+                    suffix,
+                    replaces and replaces[i] or (),
+                    self.forceChain,
+                )
+
+    def asFea(self, indent=""):
+        res = "sub "
+        if len(self.prefix) or len(self.suffix) or self.forceChain:
+            if len(self.prefix):
+                res += " ".join(map(asFea, self.prefix)) + " "
+            res += asFea(self.glyph) + "'"
+            if len(self.suffix):
+                res += " " + " ".join(map(asFea, self.suffix))
+        else:
+            res += asFea(self.glyph)
+        replacement = self.replacement or [NullGlyph()]
+        res += " by "
+        res += " ".join(map(asFea, replacement))
+        res += ";"
+        return res
+
+
+class PairPosStatement(Statement):
+    """A pair positioning statement.
+
+    ``glyphs1`` and ``glyphs2`` should be `glyph-containing objects`_.
+    ``valuerecord1`` should be a :class:`ValueRecord` object;
+    ``valuerecord2`` should be either a :class:`ValueRecord` object or ``None``.
+    If ``enumerated`` is true, then this is expressed as an
+    `enumerated pair <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#6.b.ii>`_.
+    """
+
+    def __init__(
+        self,
+        glyphs1,
+        valuerecord1,
+        glyphs2,
+        valuerecord2,
+        enumerated=False,
+        location=None,
+    ):
+        Statement.__init__(self, location)
+        self.enumerated = enumerated
+        self.glyphs1, self.valuerecord1 = glyphs1, valuerecord1
+        self.glyphs2, self.valuerecord2 = glyphs2, valuerecord2
+
+    def build(self, builder):
+        """Calls a callback on the builder object:
+
+        * If the rule is enumerated, calls ``add_specific_pair_pos`` on each
+          combination of first and second glyphs.
+        * If the glyphs are both single :class:`GlyphName` objects, calls
+          ``add_specific_pair_pos``.
+        * Else, calls ``add_class_pair_pos``.
+        """
+        if self.enumerated:
+            g = [self.glyphs1.glyphSet(), self.glyphs2.glyphSet()]
+            seen_pair = False
+            for glyph1, glyph2 in itertools.product(*g):
+                seen_pair = True
+                builder.add_specific_pair_pos(
+                    self.location, glyph1, self.valuerecord1, glyph2, self.valuerecord2
+                )
+            if not seen_pair:
+                raise FeatureLibError(
+                    "Empty glyph class in positioning rule", self.location
+                )
+            return
+
+        is_specific = isinstance(self.glyphs1, GlyphName) and isinstance(
+            self.glyphs2, GlyphName
+        )
+        if is_specific:
+            builder.add_specific_pair_pos(
+                self.location,
+                self.glyphs1.glyph,
+                self.valuerecord1,
+                self.glyphs2.glyph,
+                self.valuerecord2,
+            )
+        else:
+            builder.add_class_pair_pos(
+                self.location,
+                self.glyphs1.glyphSet(),
+                self.valuerecord1,
+                self.glyphs2.glyphSet(),
+                self.valuerecord2,
+            )
+
+    def asFea(self, indent=""):
+        res = "enum " if self.enumerated else ""
+        if self.valuerecord2:
+            res += "pos {} {} {} {};".format(
+                self.glyphs1.asFea(),
+                self.valuerecord1.asFea(),
+                self.glyphs2.asFea(),
+                self.valuerecord2.asFea(),
+            )
+        else:
+            res += "pos {} {} {};".format(
+                self.glyphs1.asFea(), self.glyphs2.asFea(), self.valuerecord1.asFea()
+            )
+        return res
+
+
+class ReverseChainSingleSubstStatement(Statement):
+    """A reverse chaining substitution statement. You don't see those every day.
+
+    Note the unusual argument order: ``suffix`` comes `before` ``glyphs``.
+    ``old_prefix``, ``old_suffix``, ``glyphs`` and ``replacements`` should be
+    lists of `glyph-containing objects`_. ``glyphs`` and ``replacements`` should
+    be one-item lists.
+    """
+
+    def __init__(self, old_prefix, old_suffix, glyphs, replacements, location=None):
+        Statement.__init__(self, location)
+        self.old_prefix, self.old_suffix = old_prefix, old_suffix
+        self.glyphs = glyphs
+        self.replacements = replacements
+
+    def build(self, builder):
+        prefix = [p.glyphSet() for p in self.old_prefix]
+        suffix = [s.glyphSet() for s in self.old_suffix]
+        originals = self.glyphs[0].glyphSet()
+        replaces = self.replacements[0].glyphSet()
+        if len(replaces) == 1:
+            replaces = replaces * len(originals)
+        builder.add_reverse_chain_single_subst(
+            self.location, prefix, suffix, dict(zip(originals, replaces))
+        )
+
+    def asFea(self, indent=""):
+        res = "rsub "
+        if len(self.old_prefix) or len(self.old_suffix):
+            if len(self.old_prefix):
+                res += " ".join(asFea(g) for g in self.old_prefix) + " "
+            res += " ".join(asFea(g) + "'" for g in self.glyphs)
+            if len(self.old_suffix):
+                res += " " + " ".join(asFea(g) for g in self.old_suffix)
+        else:
+            res += " ".join(map(asFea, self.glyphs))
+        res += " by {};".format(" ".join(asFea(g) for g in self.replacements))
+        return res
+
+
+class SingleSubstStatement(Statement):
+    """A single substitution statement.
+
+    Note the unusual argument order: ``prefix`` and suffix come `after`
+    the replacement ``glyphs``. ``prefix``, ``suffix``, ``glyphs`` and
+    ``replace`` should be lists of `glyph-containing objects`_. ``glyphs`` and
+    ``replace`` should be one-item lists.
+    """
+
+    def __init__(self, glyphs, replace, prefix, suffix, forceChain, location=None):
+        Statement.__init__(self, location)
+        self.prefix, self.suffix = prefix, suffix
+        self.forceChain = forceChain
+        self.glyphs = glyphs
+        self.replacements = replace
+
+    def build(self, builder):
+        """Calls the builder object's ``add_single_subst`` callback."""
+        prefix = [p.glyphSet() for p in self.prefix]
+        suffix = [s.glyphSet() for s in self.suffix]
+        originals = self.glyphs[0].glyphSet()
+        replaces = self.replacements[0].glyphSet()
+        if len(replaces) == 1:
+            replaces = replaces * len(originals)
+        builder.add_single_subst(
+            self.location,
+            prefix,
+            suffix,
+            OrderedDict(zip(originals, replaces)),
+            self.forceChain,
+        )
+
+    def asFea(self, indent=""):
+        res = "sub "
+        if len(self.prefix) or len(self.suffix) or self.forceChain:
+            if len(self.prefix):
+                res += " ".join(asFea(g) for g in self.prefix) + " "
+            res += " ".join(asFea(g) + "'" for g in self.glyphs)
+            if len(self.suffix):
+                res += " " + " ".join(asFea(g) for g in self.suffix)
+        else:
+            res += " ".join(asFea(g) for g in self.glyphs)
+        res += " by {};".format(" ".join(asFea(g) for g in self.replacements))
+        return res
+
+
+class ScriptStatement(Statement):
+    """A ``script`` statement."""
+
+    def __init__(self, script, location=None):
+        Statement.__init__(self, location)
+        self.script = script  #: the script code
+
+    def build(self, builder):
+        """Calls the builder's ``set_script`` callback."""
+        builder.set_script(self.location, self.script)
+
+    def asFea(self, indent=""):
+        return "script {};".format(self.script.strip())
+
+
+class SinglePosStatement(Statement):
+    """A single position statement. ``prefix`` and ``suffix`` should be
+    lists of `glyph-containing objects`_.
+
+    ``pos`` should be a one-element list containing a (`glyph-containing object`_,
+    :class:`ValueRecord`) tuple."""
+
+    def __init__(self, pos, prefix, suffix, forceChain, location=None):
+        Statement.__init__(self, location)
+        self.pos, self.prefix, self.suffix = pos, prefix, suffix
+        self.forceChain = forceChain
+
+    def build(self, builder):
+        """Calls the builder object's ``add_single_pos`` callback."""
+        prefix = [p.glyphSet() for p in self.prefix]
+        suffix = [s.glyphSet() for s in self.suffix]
+        pos = [(g.glyphSet(), value) for g, value in self.pos]
+        builder.add_single_pos(self.location, prefix, suffix, pos, self.forceChain)
+
+    def asFea(self, indent=""):
+        res = "pos "
+        if len(self.prefix) or len(self.suffix) or self.forceChain:
+            if len(self.prefix):
+                res += " ".join(map(asFea, self.prefix)) + " "
+            res += " ".join(
+                [
+                    asFea(x[0]) + "'" + ((" " + x[1].asFea()) if x[1] else "")
+                    for x in self.pos
+                ]
+            )
+            if len(self.suffix):
+                res += " " + " ".join(map(asFea, self.suffix))
+        else:
+            res += " ".join(
+                [asFea(x[0]) + " " + (x[1].asFea() if x[1] else "") for x in self.pos]
+            )
+        res += ";"
+        return res
+
+
+class SubtableStatement(Statement):
+    """Represents a subtable break."""
+
+    def __init__(self, location=None):
+        Statement.__init__(self, location)
+
+    def build(self, builder):
+        """Calls the builder objects's ``add_subtable_break`` callback."""
+        builder.add_subtable_break(self.location)
+
+    def asFea(self, indent=""):
+        return "subtable;"
+
+
+class ValueRecord(Expression):
+    """Represents a value record."""
+
+    def __init__(
+        self,
+        xPlacement=None,
+        yPlacement=None,
+        xAdvance=None,
+        yAdvance=None,
+        xPlaDevice=None,
+        yPlaDevice=None,
+        xAdvDevice=None,
+        yAdvDevice=None,
+        vertical=False,
+        location=None,
+    ):
+        Expression.__init__(self, location)
+        self.xPlacement, self.yPlacement = (xPlacement, yPlacement)
+        self.xAdvance, self.yAdvance = (xAdvance, yAdvance)
+        self.xPlaDevice, self.yPlaDevice = (xPlaDevice, yPlaDevice)
+        self.xAdvDevice, self.yAdvDevice = (xAdvDevice, yAdvDevice)
+        self.vertical = vertical
+
+    def __eq__(self, other):
+        return (
+            self.xPlacement == other.xPlacement
+            and self.yPlacement == other.yPlacement
+            and self.xAdvance == other.xAdvance
+            and self.yAdvance == other.yAdvance
+            and self.xPlaDevice == other.xPlaDevice
+            and self.xAdvDevice == other.xAdvDevice
+        )
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __hash__(self):
+        return (
+            hash(self.xPlacement)
+            ^ hash(self.yPlacement)
+            ^ hash(self.xAdvance)
+            ^ hash(self.yAdvance)
+            ^ hash(self.xPlaDevice)
+            ^ hash(self.yPlaDevice)
+            ^ hash(self.xAdvDevice)
+            ^ hash(self.yAdvDevice)
+        )
+
+    def asFea(self, indent=""):
+        if not self:
+            return "<NULL>"
+
+        x, y = self.xPlacement, self.yPlacement
+        xAdvance, yAdvance = self.xAdvance, self.yAdvance
+        xPlaDevice, yPlaDevice = self.xPlaDevice, self.yPlaDevice
+        xAdvDevice, yAdvDevice = self.xAdvDevice, self.yAdvDevice
+        vertical = self.vertical
+
+        # Try format A, if possible.
+        if x is None and y is None:
+            if xAdvance is None and vertical:
+                return str(yAdvance)
+            elif yAdvance is None and not vertical:
+                return str(xAdvance)
+
+        # Make any remaining None value 0 to avoid generating invalid records.
+        x = x or 0
+        y = y or 0
+        xAdvance = xAdvance or 0
+        yAdvance = yAdvance or 0
+
+        # Try format B, if possible.
+        if (
+            xPlaDevice is None
+            and yPlaDevice is None
+            and xAdvDevice is None
+            and yAdvDevice is None
+        ):
+            return "<%s %s %s %s>" % (x, y, xAdvance, yAdvance)
+
+        # Last resort is format C.
+        return "<%s %s %s %s %s %s %s %s>" % (
+            x,
+            y,
+            xAdvance,
+            yAdvance,
+            deviceToString(xPlaDevice),
+            deviceToString(yPlaDevice),
+            deviceToString(xAdvDevice),
+            deviceToString(yAdvDevice),
+        )
+
+    def __bool__(self):
+        return any(
+            getattr(self, v) is not None
+            for v in [
+                "xPlacement",
+                "yPlacement",
+                "xAdvance",
+                "yAdvance",
+                "xPlaDevice",
+                "yPlaDevice",
+                "xAdvDevice",
+                "yAdvDevice",
+            ]
+        )
+
+    __nonzero__ = __bool__
+
+
+class ValueRecordDefinition(Statement):
+    """Represents a named value record definition."""
+
+    def __init__(self, name, value, location=None):
+        Statement.__init__(self, location)
+        self.name = name  #: Value record name as string
+        self.value = value  #: :class:`ValueRecord` object
+
+    def asFea(self, indent=""):
+        return "valueRecordDef {} {};".format(self.value.asFea(), self.name)
+
+
+def simplify_name_attributes(pid, eid, lid):
+    if pid == 3 and eid == 1 and lid == 1033:
+        return ""
+    elif pid == 1 and eid == 0 and lid == 0:
+        return "1"
+    else:
+        return "{} {} {}".format(pid, eid, lid)
+
+
+class NameRecord(Statement):
+    """Represents a name record. (`Section 9.e. <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.e>`_)"""
+
+    def __init__(self, nameID, platformID, platEncID, langID, string, location=None):
+        Statement.__init__(self, location)
+        self.nameID = nameID  #: Name ID as integer (e.g. 9 for designer's name)
+        self.platformID = platformID  #: Platform ID as integer
+        self.platEncID = platEncID  #: Platform encoding ID as integer
+        self.langID = langID  #: Language ID as integer
+        self.string = string  #: Name record value
+
+    def build(self, builder):
+        """Calls the builder object's ``add_name_record`` callback."""
+        builder.add_name_record(
+            self.location,
+            self.nameID,
+            self.platformID,
+            self.platEncID,
+            self.langID,
+            self.string,
+        )
+
+    def asFea(self, indent=""):
+        def escape(c, escape_pattern):
+            # Also escape U+0022 QUOTATION MARK and U+005C REVERSE SOLIDUS
+            if c >= 0x20 and c <= 0x7E and c not in (0x22, 0x5C):
+                return chr(c)
+            else:
+                return escape_pattern % c
+
+        encoding = getEncoding(self.platformID, self.platEncID, self.langID)
+        if encoding is None:
+            raise FeatureLibError("Unsupported encoding", self.location)
+        s = tobytes(self.string, encoding=encoding)
+        if encoding == "utf_16_be":
+            escaped_string = "".join(
+                [
+                    escape(byteord(s[i]) * 256 + byteord(s[i + 1]), r"\%04x")
+                    for i in range(0, len(s), 2)
+                ]
+            )
+        else:
+            escaped_string = "".join([escape(byteord(b), r"\%02x") for b in s])
+        plat = simplify_name_attributes(self.platformID, self.platEncID, self.langID)
+        if plat != "":
+            plat += " "
+        return 'nameid {} {}"{}";'.format(self.nameID, plat, escaped_string)
+
+
+class FeatureNameStatement(NameRecord):
+    """Represents a ``sizemenuname`` or ``name`` statement."""
+
+    def build(self, builder):
+        """Calls the builder object's ``add_featureName`` callback."""
+        NameRecord.build(self, builder)
+        builder.add_featureName(self.nameID)
+
+    def asFea(self, indent=""):
+        if self.nameID == "size":
+            tag = "sizemenuname"
+        else:
+            tag = "name"
+        plat = simplify_name_attributes(self.platformID, self.platEncID, self.langID)
+        if plat != "":
+            plat += " "
+        return '{} {}"{}";'.format(tag, plat, self.string)
+
+
+class STATNameStatement(NameRecord):
+    """Represents a STAT table ``name`` statement."""
+
+    def asFea(self, indent=""):
+        plat = simplify_name_attributes(self.platformID, self.platEncID, self.langID)
+        if plat != "":
+            plat += " "
+        return 'name {}"{}";'.format(plat, self.string)
+
+
+class SizeParameters(Statement):
+    """A ``parameters`` statement."""
+
+    def __init__(self, DesignSize, SubfamilyID, RangeStart, RangeEnd, location=None):
+        Statement.__init__(self, location)
+        self.DesignSize = DesignSize
+        self.SubfamilyID = SubfamilyID
+        self.RangeStart = RangeStart
+        self.RangeEnd = RangeEnd
+
+    def build(self, builder):
+        """Calls the builder object's ``set_size_parameters`` callback."""
+        builder.set_size_parameters(
+            self.location,
+            self.DesignSize,
+            self.SubfamilyID,
+            self.RangeStart,
+            self.RangeEnd,
+        )
+
+    def asFea(self, indent=""):
+        res = "parameters {:.1f} {}".format(self.DesignSize, self.SubfamilyID)
+        if self.RangeStart != 0 or self.RangeEnd != 0:
+            res += " {} {}".format(int(self.RangeStart * 10), int(self.RangeEnd * 10))
+        return res + ";"
+
+
+class CVParametersNameStatement(NameRecord):
+    """Represent a name statement inside a ``cvParameters`` block."""
+
+    def __init__(
+        self, nameID, platformID, platEncID, langID, string, block_name, location=None
+    ):
+        NameRecord.__init__(
+            self, nameID, platformID, platEncID, langID, string, location=location
+        )
+        self.block_name = block_name
+
+    def build(self, builder):
+        """Calls the builder object's ``add_cv_parameter`` callback."""
+        item = ""
+        if self.block_name == "ParamUILabelNameID":
+            item = "_{}".format(builder.cv_num_named_params_.get(self.nameID, 0))
+        builder.add_cv_parameter(self.nameID)
+        self.nameID = (self.nameID, self.block_name + item)
+        NameRecord.build(self, builder)
+
+    def asFea(self, indent=""):
+        plat = simplify_name_attributes(self.platformID, self.platEncID, self.langID)
+        if plat != "":
+            plat += " "
+        return 'name {}"{}";'.format(plat, self.string)
+
+
+class CharacterStatement(Statement):
+    """
+    Statement used in cvParameters blocks of Character Variant features (cvXX).
+    The Unicode value may be written with either decimal or hexadecimal
+    notation. The value must be preceded by '0x' if it is a hexadecimal value.
+    The largest Unicode value allowed is 0xFFFFFF.
+    """
+
+    def __init__(self, character, tag, location=None):
+        Statement.__init__(self, location)
+        self.character = character
+        self.tag = tag
+
+    def build(self, builder):
+        """Calls the builder object's ``add_cv_character`` callback."""
+        builder.add_cv_character(self.character, self.tag)
+
+    def asFea(self, indent=""):
+        return "Character {:#x};".format(self.character)
+
+
+class BaseAxis(Statement):
+    """An axis definition, being either a ``VertAxis.BaseTagList/BaseScriptList``
+    pair or a ``HorizAxis.BaseTagList/BaseScriptList`` pair."""
+
+    def __init__(self, bases, scripts, vertical, location=None):
+        Statement.__init__(self, location)
+        self.bases = bases  #: A list of baseline tag names as strings
+        self.scripts = scripts  #: A list of script record tuplets (script tag, default baseline tag, base coordinate)
+        self.vertical = vertical  #: Boolean; VertAxis if True, HorizAxis if False
+
+    def build(self, builder):
+        """Calls the builder object's ``set_base_axis`` callback."""
+        builder.set_base_axis(self.bases, self.scripts, self.vertical)
+
+    def asFea(self, indent=""):
+        direction = "Vert" if self.vertical else "Horiz"
+        scripts = [
+            "{} {} {}".format(a[0], a[1], " ".join(map(str, a[2])))
+            for a in self.scripts
+        ]
+        return "{}Axis.BaseTagList {};\n{}{}Axis.BaseScriptList {};".format(
+            direction, " ".join(self.bases), indent, direction, ", ".join(scripts)
+        )
+
+
+class OS2Field(Statement):
+    """An entry in the ``OS/2`` table. Most ``values`` should be numbers or
+    strings, apart from when the key is ``UnicodeRange``, ``CodePageRange``
+    or ``Panose``, in which case it should be an array of integers."""
+
+    def __init__(self, key, value, location=None):
+        Statement.__init__(self, location)
+        self.key = key
+        self.value = value
+
+    def build(self, builder):
+        """Calls the builder object's ``add_os2_field`` callback."""
+        builder.add_os2_field(self.key, self.value)
+
+    def asFea(self, indent=""):
+        def intarr2str(x):
+            return " ".join(map(str, x))
+
+        numbers = (
+            "FSType",
+            "TypoAscender",
+            "TypoDescender",
+            "TypoLineGap",
+            "winAscent",
+            "winDescent",
+            "XHeight",
+            "CapHeight",
+            "WeightClass",
+            "WidthClass",
+            "LowerOpSize",
+            "UpperOpSize",
+        )
+        ranges = ("UnicodeRange", "CodePageRange")
+        keywords = dict([(x.lower(), [x, str]) for x in numbers])
+        keywords.update([(x.lower(), [x, intarr2str]) for x in ranges])
+        keywords["panose"] = ["Panose", intarr2str]
+        keywords["vendor"] = ["Vendor", lambda y: '"{}"'.format(y)]
+        if self.key in keywords:
+            return "{} {};".format(
+                keywords[self.key][0], keywords[self.key][1](self.value)
+            )
+        return ""  # should raise exception
+
+
+class HheaField(Statement):
+    """An entry in the ``hhea`` table."""
+
+    def __init__(self, key, value, location=None):
+        Statement.__init__(self, location)
+        self.key = key
+        self.value = value
+
+    def build(self, builder):
+        """Calls the builder object's ``add_hhea_field`` callback."""
+        builder.add_hhea_field(self.key, self.value)
+
+    def asFea(self, indent=""):
+        fields = ("CaretOffset", "Ascender", "Descender", "LineGap")
+        keywords = dict([(x.lower(), x) for x in fields])
+        return "{} {};".format(keywords[self.key], self.value)
+
+
+class VheaField(Statement):
+    """An entry in the ``vhea`` table."""
+
+    def __init__(self, key, value, location=None):
+        Statement.__init__(self, location)
+        self.key = key
+        self.value = value
+
+    def build(self, builder):
+        """Calls the builder object's ``add_vhea_field`` callback."""
+        builder.add_vhea_field(self.key, self.value)
+
+    def asFea(self, indent=""):
+        fields = ("VertTypoAscender", "VertTypoDescender", "VertTypoLineGap")
+        keywords = dict([(x.lower(), x) for x in fields])
+        return "{} {};".format(keywords[self.key], self.value)
+
+
+class STATDesignAxisStatement(Statement):
+    """A STAT table Design Axis
+
+    Args:
+        tag (str): a 4 letter axis tag
+        axisOrder (int): an int
+        names (list): a list of :class:`STATNameStatement` objects
+    """
+
+    def __init__(self, tag, axisOrder, names, location=None):
+        Statement.__init__(self, location)
+        self.tag = tag
+        self.axisOrder = axisOrder
+        self.names = names
+        self.location = location
+
+    def build(self, builder):
+        builder.addDesignAxis(self, self.location)
+
+    def asFea(self, indent=""):
+        indent += SHIFT
+        res = f"DesignAxis {self.tag} {self.axisOrder} {{ \n"
+        res += ("\n" + indent).join([s.asFea(indent=indent) for s in self.names]) + "\n"
+        res += "};"
+        return res
+
+
+class ElidedFallbackName(Statement):
+    """STAT table ElidedFallbackName
+
+    Args:
+        names: a list of :class:`STATNameStatement` objects
+    """
+
+    def __init__(self, names, location=None):
+        Statement.__init__(self, location)
+        self.names = names
+        self.location = location
+
+    def build(self, builder):
+        builder.setElidedFallbackName(self.names, self.location)
+
+    def asFea(self, indent=""):
+        indent += SHIFT
+        res = "ElidedFallbackName { \n"
+        res += ("\n" + indent).join([s.asFea(indent=indent) for s in self.names]) + "\n"
+        res += "};"
+        return res
+
+
+class ElidedFallbackNameID(Statement):
+    """STAT table ElidedFallbackNameID
+
+    Args:
+        value: an int pointing to an existing name table name ID
+    """
+
+    def __init__(self, value, location=None):
+        Statement.__init__(self, location)
+        self.value = value
+        self.location = location
+
+    def build(self, builder):
+        builder.setElidedFallbackName(self.value, self.location)
+
+    def asFea(self, indent=""):
+        return f"ElidedFallbackNameID {self.value};"
+
+
+class STATAxisValueStatement(Statement):
+    """A STAT table Axis Value Record
+
+    Args:
+        names (list): a list of :class:`STATNameStatement` objects
+        locations (list): a list of :class:`AxisValueLocationStatement` objects
+        flags (int): an int
+    """
+
+    def __init__(self, names, locations, flags, location=None):
+        Statement.__init__(self, location)
+        self.names = names
+        self.locations = locations
+        self.flags = flags
+
+    def build(self, builder):
+        builder.addAxisValueRecord(self, self.location)
+
+    def asFea(self, indent=""):
+        res = "AxisValue {\n"
+        for location in self.locations:
+            res += location.asFea()
+
+        for nameRecord in self.names:
+            res += nameRecord.asFea()
+            res += "\n"
+
+        if self.flags:
+            flags = ["OlderSiblingFontAttribute", "ElidableAxisValueName"]
+            flagStrings = []
+            curr = 1
+            for i in range(len(flags)):
+                if self.flags & curr != 0:
+                    flagStrings.append(flags[i])
+                curr = curr << 1
+            res += f"flag {' '.join(flagStrings)};\n"
+        res += "};"
+        return res
+
+
+class AxisValueLocationStatement(Statement):
+    """
+    A STAT table Axis Value Location
+
+    Args:
+        tag (str): a 4 letter axis tag
+        values (list): a list of ints and/or floats
+    """
+
+    def __init__(self, tag, values, location=None):
+        Statement.__init__(self, location)
+        self.tag = tag
+        self.values = values
+
+    def asFea(self, res=""):
+        res += f"location {self.tag} "
+        res += f"{' '.join(str(i) for i in self.values)};\n"
+        return res
+
+
+class ConditionsetStatement(Statement):
+    """
+    A variable layout conditionset
+
+    Args:
+        name (str): the name of this conditionset
+        conditions (dict): a dictionary mapping axis tags to a
+            tuple of (min,max) userspace coordinates.
+    """
+
+    def __init__(self, name, conditions, location=None):
+        Statement.__init__(self, location)
+        self.name = name
+        self.conditions = conditions
+
+    def build(self, builder):
+        builder.add_conditionset(self.location, self.name, self.conditions)
+
+    def asFea(self, res="", indent=""):
+        res += indent + f"conditionset {self.name} " + "{\n"
+        for tag, (minvalue, maxvalue) in self.conditions.items():
+            res += indent + SHIFT + f"{tag} {minvalue} {maxvalue};\n"
+        res += indent + "}" + f" {self.name};\n"
+        return res
+
+
+class VariationBlock(Block):
+    """A variation feature block, applicable in a given set of conditions."""
+
+    def __init__(self, name, conditionset, use_extension=False, location=None):
+        Block.__init__(self, location)
+        self.name, self.conditionset, self.use_extension = (
+            name,
+            conditionset,
+            use_extension,
+        )
+
+    def build(self, builder):
+        """Call the ``start_feature`` callback on the builder object, visit
+        all the statements in this feature, and then call ``end_feature``."""
+        builder.start_feature(self.location, self.name)
+        if (
+            self.conditionset != "NULL"
+            and self.conditionset not in builder.conditionsets_
+        ):
+            raise FeatureLibError(
+                f"variation block used undefined conditionset {self.conditionset}",
+                self.location,
+            )
+
+        # language exclude_dflt statements modify builder.features_
+        # limit them to this block with temporary builder.features_
+        features = builder.features_
+        builder.features_ = {}
+        Block.build(self, builder)
+        for key, value in builder.features_.items():
+            items = builder.feature_variations_.setdefault(key, {}).setdefault(
+                self.conditionset, []
+            )
+            items.extend(value)
+            if key not in features:
+                features[key] = []  # Ensure we make a feature record
+        builder.features_ = features
+        builder.end_feature()
+
+    def asFea(self, indent=""):
+        res = indent + "variation %s " % self.name.strip()
+        res += self.conditionset + " "
+        if self.use_extension:
+            res += "useExtension "
+        res += "{\n"
+        res += Block.asFea(self, indent=indent)
+        res += indent + "} %s;\n" % self.name.strip()
+        return res

evalkit_tf437/lib/python3.10/site-packages/fontTools/feaLib/builder.py

@@ -0,0 +1,1729 @@
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import Tag, tostr, binary2num, safeEval
+from fontTools.feaLib.error import FeatureLibError
+from fontTools.feaLib.lookupDebugInfo import (
+    LookupDebugInfo,
+    LOOKUP_DEBUG_INFO_KEY,
+    LOOKUP_DEBUG_ENV_VAR,
+)
+from fontTools.feaLib.parser import Parser
+from fontTools.feaLib.ast import FeatureFile
+from fontTools.feaLib.variableScalar import VariableScalar
+from fontTools.otlLib import builder as otl
+from fontTools.otlLib.maxContextCalc import maxCtxFont
+from fontTools.ttLib import newTable, getTableModule
+from fontTools.ttLib.tables import otBase, otTables
+from fontTools.otlLib.builder import (
+    AlternateSubstBuilder,
+    ChainContextPosBuilder,
+    ChainContextSubstBuilder,
+    LigatureSubstBuilder,
+    MultipleSubstBuilder,
+    CursivePosBuilder,
+    MarkBasePosBuilder,
+    MarkLigPosBuilder,
+    MarkMarkPosBuilder,
+    ReverseChainSingleSubstBuilder,
+    SingleSubstBuilder,
+    ClassPairPosSubtableBuilder,
+    PairPosBuilder,
+    SinglePosBuilder,
+    ChainContextualRule,
+)
+from fontTools.otlLib.error import OpenTypeLibError
+from fontTools.varLib.varStore import OnlineVarStoreBuilder
+from fontTools.varLib.builder import buildVarDevTable
+from fontTools.varLib.featureVars import addFeatureVariationsRaw
+from fontTools.varLib.models import normalizeValue, piecewiseLinearMap
+from collections import defaultdict
+import copy
+import itertools
+from io import StringIO
+import logging
+import warnings
+import os
+
+
+log = logging.getLogger(__name__)
+
+
+def addOpenTypeFeatures(font, featurefile, tables=None, debug=False):
+    """Add features from a file to a font. Note that this replaces any features
+    currently present.
+
+    Args:
+        font (feaLib.ttLib.TTFont): The font object.
+        featurefile: Either a path or file object (in which case we
+            parse it into an AST), or a pre-parsed AST instance.
+        tables: If passed, restrict the set of affected tables to those in the
+            list.
+        debug: Whether to add source debugging information to the font in the
+            ``Debg`` table
+
+    """
+    builder = Builder(font, featurefile)
+    builder.build(tables=tables, debug=debug)
+
+
+def addOpenTypeFeaturesFromString(
+    font, features, filename=None, tables=None, debug=False
+):
+    """Add features from a string to a font. Note that this replaces any
+    features currently present.
+
+    Args:
+        font (feaLib.ttLib.TTFont): The font object.
+        features: A string containing feature code.
+        filename: The directory containing ``filename`` is used as the root of
+            relative ``include()`` paths; if ``None`` is provided, the current
+            directory is assumed.
+        tables: If passed, restrict the set of affected tables to those in the
+            list.
+        debug: Whether to add source debugging information to the font in the
+            ``Debg`` table
+
+    """
+
+    featurefile = StringIO(tostr(features))
+    if filename:
+        featurefile.name = filename
+    addOpenTypeFeatures(font, featurefile, tables=tables, debug=debug)
+
+
+class Builder(object):
+    supportedTables = frozenset(
+        Tag(tag)
+        for tag in [
+            "BASE",
+            "GDEF",
+            "GPOS",
+            "GSUB",
+            "OS/2",
+            "head",
+            "hhea",
+            "name",
+            "vhea",
+            "STAT",
+        ]
+    )
+
+    def __init__(self, font, featurefile):
+        self.font = font
+        # 'featurefile' can be either a path or file object (in which case we
+        # parse it into an AST), or a pre-parsed AST instance
+        if isinstance(featurefile, FeatureFile):
+            self.parseTree, self.file = featurefile, None
+        else:
+            self.parseTree, self.file = None, featurefile
+        self.glyphMap = font.getReverseGlyphMap()
+        self.varstorebuilder = None
+        if "fvar" in font:
+            self.axes = font["fvar"].axes
+            self.varstorebuilder = OnlineVarStoreBuilder(
+                [ax.axisTag for ax in self.axes]
+            )
+        self.default_language_systems_ = set()
+        self.script_ = None
+        self.lookupflag_ = 0
+        self.lookupflag_markFilterSet_ = None
+        self.language_systems = set()
+        self.seen_non_DFLT_script_ = False
+        self.named_lookups_ = {}
+        self.cur_lookup_ = None
+        self.cur_lookup_name_ = None
+        self.cur_feature_name_ = None
+        self.lookups_ = []
+        self.lookup_locations = {"GSUB": {}, "GPOS": {}}
+        self.features_ = {}  # ('latn', 'DEU ', 'smcp') --> [LookupBuilder*]
+        self.required_features_ = {}  # ('latn', 'DEU ') --> 'scmp'
+        self.feature_variations_ = {}
+        # for feature 'aalt'
+        self.aalt_features_ = []  # [(location, featureName)*], for 'aalt'
+        self.aalt_location_ = None
+        self.aalt_alternates_ = {}
+        # for 'featureNames'
+        self.featureNames_ = set()
+        self.featureNames_ids_ = {}
+        # for 'cvParameters'
+        self.cv_parameters_ = set()
+        self.cv_parameters_ids_ = {}
+        self.cv_num_named_params_ = {}
+        self.cv_characters_ = defaultdict(list)
+        # for feature 'size'
+        self.size_parameters_ = None
+        # for table 'head'
+        self.fontRevision_ = None  # 2.71
+        # for table 'name'
+        self.names_ = []
+        # for table 'BASE'
+        self.base_horiz_axis_ = None
+        self.base_vert_axis_ = None
+        # for table 'GDEF'
+        self.attachPoints_ = {}  # "a" --> {3, 7}
+        self.ligCaretCoords_ = {}  # "f_f_i" --> {300, 600}
+        self.ligCaretPoints_ = {}  # "f_f_i" --> {3, 7}
+        self.glyphClassDefs_ = {}  # "fi" --> (2, (file, line, column))
+        self.markAttach_ = {}  # "acute" --> (4, (file, line, column))
+        self.markAttachClassID_ = {}  # frozenset({"acute", "grave"}) --> 4
+        self.markFilterSets_ = {}  # frozenset({"acute", "grave"}) --> 4
+        # for table 'OS/2'
+        self.os2_ = {}
+        # for table 'hhea'
+        self.hhea_ = {}
+        # for table 'vhea'
+        self.vhea_ = {}
+        # for table 'STAT'
+        self.stat_ = {}
+        # for conditionsets
+        self.conditionsets_ = {}
+        # We will often use exactly the same locations (i.e. the font's masters)
+        # for a large number of variable scalars. Instead of creating a model
+        # for each, let's share the models.
+        self.model_cache = {}
+
+    def build(self, tables=None, debug=False):
+        if self.parseTree is None:
+            self.parseTree = Parser(self.file, self.glyphMap).parse()
+        self.parseTree.build(self)
+        # by default, build all the supported tables
+        if tables is None:
+            tables = self.supportedTables
+        else:
+            tables = frozenset(tables)
+            unsupported = tables - self.supportedTables
+            if unsupported:
+                unsupported_string = ", ".join(sorted(unsupported))
+                raise NotImplementedError(
+                    "The following tables were requested but are unsupported: "
+                    f"{unsupported_string}."
+                )
+        if "GSUB" in tables:
+            self.build_feature_aalt_()
+        if "head" in tables:
+            self.build_head()
+        if "hhea" in tables:
+            self.build_hhea()
+        if "vhea" in tables:
+            self.build_vhea()
+        if "name" in tables:
+            self.build_name()
+        if "OS/2" in tables:
+            self.build_OS_2()
+        if "STAT" in tables:
+            self.build_STAT()
+        for tag in ("GPOS", "GSUB"):
+            if tag not in tables:
+                continue
+            table = self.makeTable(tag)
+            if self.feature_variations_:
+                self.makeFeatureVariations(table, tag)
+            if (
+                table.ScriptList.ScriptCount > 0
+                or table.FeatureList.FeatureCount > 0
+                or table.LookupList.LookupCount > 0
+            ):
+                fontTable = self.font[tag] = newTable(tag)
+                fontTable.table = table
+            elif tag in self.font:
+                del self.font[tag]
+        if any(tag in self.font for tag in ("GPOS", "GSUB")) and "OS/2" in self.font:
+            self.font["OS/2"].usMaxContext = maxCtxFont(self.font)
+        if "GDEF" in tables:
+            gdef = self.buildGDEF()
+            if gdef:
+                self.font["GDEF"] = gdef
+            elif "GDEF" in self.font:
+                del self.font["GDEF"]
+        if "BASE" in tables:
+            base = self.buildBASE()
+            if base:
+                self.font["BASE"] = base
+            elif "BASE" in self.font:
+                del self.font["BASE"]
+        if debug or os.environ.get(LOOKUP_DEBUG_ENV_VAR):
+            self.buildDebg()
+
+    def get_chained_lookup_(self, location, builder_class):
+        result = builder_class(self.font, location)
+        result.lookupflag = self.lookupflag_
+        result.markFilterSet = self.lookupflag_markFilterSet_
+        self.lookups_.append(result)
+        return result
+
+    def add_lookup_to_feature_(self, lookup, feature_name):
+        for script, lang in self.language_systems:
+            key = (script, lang, feature_name)
+            self.features_.setdefault(key, []).append(lookup)
+
+    def get_lookup_(self, location, builder_class):
+        if (
+            self.cur_lookup_
+            and type(self.cur_lookup_) == builder_class
+            and self.cur_lookup_.lookupflag == self.lookupflag_
+            and self.cur_lookup_.markFilterSet == self.lookupflag_markFilterSet_
+        ):
+            return self.cur_lookup_
+        if self.cur_lookup_name_ and self.cur_lookup_:
+            raise FeatureLibError(
+                "Within a named lookup block, all rules must be of "
+                "the same lookup type and flag",
+                location,
+            )
+        self.cur_lookup_ = builder_class(self.font, location)
+        self.cur_lookup_.lookupflag = self.lookupflag_
+        self.cur_lookup_.markFilterSet = self.lookupflag_markFilterSet_
+        self.lookups_.append(self.cur_lookup_)
+        if self.cur_lookup_name_:
+            # We are starting a lookup rule inside a named lookup block.
+            self.named_lookups_[self.cur_lookup_name_] = self.cur_lookup_
+        if self.cur_feature_name_:
+            # We are starting a lookup rule inside a feature. This includes
+            # lookup rules inside named lookups inside features.
+            self.add_lookup_to_feature_(self.cur_lookup_, self.cur_feature_name_)
+        return self.cur_lookup_
+
+    def build_feature_aalt_(self):
+        if not self.aalt_features_ and not self.aalt_alternates_:
+            return
+        # > alternate glyphs will be sorted in the order that the source features
+        # > are named in the aalt definition, not the order of the feature definitions
+        # > in the file. Alternates defined explicitly ... will precede all others.
+        # https://github.com/fonttools/fonttools/issues/836
+        alternates = {g: list(a) for g, a in self.aalt_alternates_.items()}
+        for location, name in self.aalt_features_ + [(None, "aalt")]:
+            feature = [
+                (script, lang, feature, lookups)
+                for (script, lang, feature), lookups in self.features_.items()
+                if feature == name
+            ]
+            # "aalt" does not have to specify its own lookups, but it might.
+            if not feature and name != "aalt":
+                warnings.warn("%s: Feature %s has not been defined" % (location, name))
+                continue
+            for script, lang, feature, lookups in feature:
+                for lookuplist in lookups:
+                    if not isinstance(lookuplist, list):
+                        lookuplist = [lookuplist]
+                    for lookup in lookuplist:
+                        for glyph, alts in lookup.getAlternateGlyphs().items():
+                            alts_for_glyph = alternates.setdefault(glyph, [])
+                            alts_for_glyph.extend(
+                                g for g in alts if g not in alts_for_glyph
+                            )
+        single = {
+            glyph: repl[0] for glyph, repl in alternates.items() if len(repl) == 1
+        }
+        multi = {glyph: repl for glyph, repl in alternates.items() if len(repl) > 1}
+        if not single and not multi:
+            return
+        self.features_ = {
+            (script, lang, feature): lookups
+            for (script, lang, feature), lookups in self.features_.items()
+            if feature != "aalt"
+        }
+        old_lookups = self.lookups_
+        self.lookups_ = []
+        self.start_feature(self.aalt_location_, "aalt")
+        if single:
+            single_lookup = self.get_lookup_(location, SingleSubstBuilder)
+            single_lookup.mapping = single
+        if multi:
+            multi_lookup = self.get_lookup_(location, AlternateSubstBuilder)
+            multi_lookup.alternates = multi
+        self.end_feature()
+        self.lookups_.extend(old_lookups)
+
+    def build_head(self):
+        if not self.fontRevision_:
+            return
+        table = self.font.get("head")
+        if not table:  # this only happens for unit tests
+            table = self.font["head"] = newTable("head")
+            table.decompile(b"\0" * 54, self.font)
+            table.tableVersion = 1.0
+            table.created = table.modified = 3406620153  # 2011-12-13 11:22:33
+        table.fontRevision = self.fontRevision_
+
+    def build_hhea(self):
+        if not self.hhea_:
+            return
+        table = self.font.get("hhea")
+        if not table:  # this only happens for unit tests
+            table = self.font["hhea"] = newTable("hhea")
+            table.decompile(b"\0" * 36, self.font)
+            table.tableVersion = 0x00010000
+        if "caretoffset" in self.hhea_:
+            table.caretOffset = self.hhea_["caretoffset"]
+        if "ascender" in self.hhea_:
+            table.ascent = self.hhea_["ascender"]
+        if "descender" in self.hhea_:
+            table.descent = self.hhea_["descender"]
+        if "linegap" in self.hhea_:
+            table.lineGap = self.hhea_["linegap"]
+
+    def build_vhea(self):
+        if not self.vhea_:
+            return
+        table = self.font.get("vhea")
+        if not table:  # this only happens for unit tests
+            table = self.font["vhea"] = newTable("vhea")
+            table.decompile(b"\0" * 36, self.font)
+            table.tableVersion = 0x00011000
+        if "verttypoascender" in self.vhea_:
+            table.ascent = self.vhea_["verttypoascender"]
+        if "verttypodescender" in self.vhea_:
+            table.descent = self.vhea_["verttypodescender"]
+        if "verttypolinegap" in self.vhea_:
+            table.lineGap = self.vhea_["verttypolinegap"]
+
+    def get_user_name_id(self, table):
+        # Try to find first unused font-specific name id
+        nameIDs = [name.nameID for name in table.names]
+        for user_name_id in range(256, 32767):
+            if user_name_id not in nameIDs:
+                return user_name_id
+
+    def buildFeatureParams(self, tag):
+        params = None
+        if tag == "size":
+            params = otTables.FeatureParamsSize()
+            (
+                params.DesignSize,
+                params.SubfamilyID,
+                params.RangeStart,
+                params.RangeEnd,
+            ) = self.size_parameters_
+            if tag in self.featureNames_ids_:
+                params.SubfamilyNameID = self.featureNames_ids_[tag]
+            else:
+                params.SubfamilyNameID = 0
+        elif tag in self.featureNames_:
+            if not self.featureNames_ids_:
+                # name table wasn't selected among the tables to build; skip
+                pass
+            else:
+                assert tag in self.featureNames_ids_
+                params = otTables.FeatureParamsStylisticSet()
+                params.Version = 0
+                params.UINameID = self.featureNames_ids_[tag]
+        elif tag in self.cv_parameters_:
+            params = otTables.FeatureParamsCharacterVariants()
+            params.Format = 0
+            params.FeatUILabelNameID = self.cv_parameters_ids_.get(
+                (tag, "FeatUILabelNameID"), 0
+            )
+            params.FeatUITooltipTextNameID = self.cv_parameters_ids_.get(
+                (tag, "FeatUITooltipTextNameID"), 0
+            )
+            params.SampleTextNameID = self.cv_parameters_ids_.get(
+                (tag, "SampleTextNameID"), 0
+            )
+            params.NumNamedParameters = self.cv_num_named_params_.get(tag, 0)
+            params.FirstParamUILabelNameID = self.cv_parameters_ids_.get(
+                (tag, "ParamUILabelNameID_0"), 0
+            )
+            params.CharCount = len(self.cv_characters_[tag])
+            params.Character = self.cv_characters_[tag]
+        return params
+
+    def build_name(self):
+        if not self.names_:
+            return
+        table = self.font.get("name")
+        if not table:  # this only happens for unit tests
+            table = self.font["name"] = newTable("name")
+            table.names = []
+        for name in self.names_:
+            nameID, platformID, platEncID, langID, string = name
+            # For featureNames block, nameID is 'feature tag'
+            # For cvParameters blocks, nameID is ('feature tag', 'block name')
+            if not isinstance(nameID, int):
+                tag = nameID
+                if tag in self.featureNames_:
+                    if tag not in self.featureNames_ids_:
+                        self.featureNames_ids_[tag] = self.get_user_name_id(table)
+                        assert self.featureNames_ids_[tag] is not None
+                    nameID = self.featureNames_ids_[tag]
+                elif tag[0] in self.cv_parameters_:
+                    if tag not in self.cv_parameters_ids_:
+                        self.cv_parameters_ids_[tag] = self.get_user_name_id(table)
+                        assert self.cv_parameters_ids_[tag] is not None
+                    nameID = self.cv_parameters_ids_[tag]
+            table.setName(string, nameID, platformID, platEncID, langID)
+        table.names.sort()
+
+    def build_OS_2(self):
+        if not self.os2_:
+            return
+        table = self.font.get("OS/2")
+        if not table:  # this only happens for unit tests
+            table = self.font["OS/2"] = newTable("OS/2")
+            data = b"\0" * sstruct.calcsize(getTableModule("OS/2").OS2_format_0)
+            table.decompile(data, self.font)
+        version = 0
+        if "fstype" in self.os2_:
+            table.fsType = self.os2_["fstype"]
+        if "panose" in self.os2_:
+            panose = getTableModule("OS/2").Panose()
+            (
+                panose.bFamilyType,
+                panose.bSerifStyle,
+                panose.bWeight,
+                panose.bProportion,
+                panose.bContrast,
+                panose.bStrokeVariation,
+                panose.bArmStyle,
+                panose.bLetterForm,
+                panose.bMidline,
+                panose.bXHeight,
+            ) = self.os2_["panose"]
+            table.panose = panose
+        if "typoascender" in self.os2_:
+            table.sTypoAscender = self.os2_["typoascender"]
+        if "typodescender" in self.os2_:
+            table.sTypoDescender = self.os2_["typodescender"]
+        if "typolinegap" in self.os2_:
+            table.sTypoLineGap = self.os2_["typolinegap"]
+        if "winascent" in self.os2_:
+            table.usWinAscent = self.os2_["winascent"]
+        if "windescent" in self.os2_:
+            table.usWinDescent = self.os2_["windescent"]
+        if "vendor" in self.os2_:
+            table.achVendID = safeEval("'''" + self.os2_["vendor"] + "'''")
+        if "weightclass" in self.os2_:
+            table.usWeightClass = self.os2_["weightclass"]
+        if "widthclass" in self.os2_:
+            table.usWidthClass = self.os2_["widthclass"]
+        if "unicoderange" in self.os2_:
+            table.setUnicodeRanges(self.os2_["unicoderange"])
+        if "codepagerange" in self.os2_:
+            pages = self.build_codepages_(self.os2_["codepagerange"])
+            table.ulCodePageRange1, table.ulCodePageRange2 = pages
+            version = 1
+        if "xheight" in self.os2_:
+            table.sxHeight = self.os2_["xheight"]
+            version = 2
+        if "capheight" in self.os2_:
+            table.sCapHeight = self.os2_["capheight"]
+            version = 2
+        if "loweropsize" in self.os2_:
+            table.usLowerOpticalPointSize = self.os2_["loweropsize"]
+            version = 5
+        if "upperopsize" in self.os2_:
+            table.usUpperOpticalPointSize = self.os2_["upperopsize"]
+            version = 5
+
+        def checkattr(table, attrs):
+            for attr in attrs:
+                if not hasattr(table, attr):
+                    setattr(table, attr, 0)
+
+        table.version = max(version, table.version)
+        # this only happens for unit tests
+        if version >= 1:
+            checkattr(table, ("ulCodePageRange1", "ulCodePageRange2"))
+        if version >= 2:
+            checkattr(
+                table,
+                (
+                    "sxHeight",
+                    "sCapHeight",
+                    "usDefaultChar",
+                    "usBreakChar",
+                    "usMaxContext",
+                ),
+            )
+        if version >= 5:
+            checkattr(table, ("usLowerOpticalPointSize", "usUpperOpticalPointSize"))
+
+    def setElidedFallbackName(self, value, location):
+        # ElidedFallbackName is a convenience method for setting
+        # ElidedFallbackNameID so only one can be allowed
+        for token in ("ElidedFallbackName", "ElidedFallbackNameID"):
+            if token in self.stat_:
+                raise FeatureLibError(
+                    f"{token} is already set.",
+                    location,
+                )
+        if isinstance(value, int):
+            self.stat_["ElidedFallbackNameID"] = value
+        elif isinstance(value, list):
+            self.stat_["ElidedFallbackName"] = value
+        else:
+            raise AssertionError(value)
+
+    def addDesignAxis(self, designAxis, location):
+        if "DesignAxes" not in self.stat_:
+            self.stat_["DesignAxes"] = []
+        if designAxis.tag in (r.tag for r in self.stat_["DesignAxes"]):
+            raise FeatureLibError(
+                f'DesignAxis already defined for tag "{designAxis.tag}".',
+                location,
+            )
+        if designAxis.axisOrder in (r.axisOrder for r in self.stat_["DesignAxes"]):
+            raise FeatureLibError(
+                f"DesignAxis already defined for axis number {designAxis.axisOrder}.",
+                location,
+            )
+        self.stat_["DesignAxes"].append(designAxis)
+
+    def addAxisValueRecord(self, axisValueRecord, location):
+        if "AxisValueRecords" not in self.stat_:
+            self.stat_["AxisValueRecords"] = []
+        # Check for duplicate AxisValueRecords
+        for record_ in self.stat_["AxisValueRecords"]:
+            if (
+                {n.asFea() for n in record_.names}
+                == {n.asFea() for n in axisValueRecord.names}
+                and {n.asFea() for n in record_.locations}
+                == {n.asFea() for n in axisValueRecord.locations}
+                and record_.flags == axisValueRecord.flags
+            ):
+                raise FeatureLibError(
+                    "An AxisValueRecord with these values is already defined.",
+                    location,
+                )
+        self.stat_["AxisValueRecords"].append(axisValueRecord)
+
+    def build_STAT(self):
+        if not self.stat_:
+            return
+
+        axes = self.stat_.get("DesignAxes")
+        if not axes:
+            raise FeatureLibError("DesignAxes not defined", None)
+        axisValueRecords = self.stat_.get("AxisValueRecords")
+        axisValues = {}
+        format4_locations = []
+        for tag in axes:
+            axisValues[tag.tag] = []
+        if axisValueRecords is not None:
+            for avr in axisValueRecords:
+                valuesDict = {}
+                if avr.flags > 0:
+                    valuesDict["flags"] = avr.flags
+                if len(avr.locations) == 1:
+                    location = avr.locations[0]
+                    values = location.values
+                    if len(values) == 1:  # format1
+                        valuesDict.update({"value": values[0], "name": avr.names})
+                    if len(values) == 2:  # format3
+                        valuesDict.update(
+                            {
+                                "value": values[0],
+                                "linkedValue": values[1],
+                                "name": avr.names,
+                            }
+                        )
+                    if len(values) == 3:  # format2
+                        nominal, minVal, maxVal = values
+                        valuesDict.update(
+                            {
+                                "nominalValue": nominal,
+                                "rangeMinValue": minVal,
+                                "rangeMaxValue": maxVal,
+                                "name": avr.names,
+                            }
+                        )
+                    axisValues[location.tag].append(valuesDict)
+                else:
+                    valuesDict.update(
+                        {
+                            "location": {i.tag: i.values[0] for i in avr.locations},
+                            "name": avr.names,
+                        }
+                    )
+                    format4_locations.append(valuesDict)
+
+        designAxes = [
+            {
+                "ordering": a.axisOrder,
+                "tag": a.tag,
+                "name": a.names,
+                "values": axisValues[a.tag],
+            }
+            for a in axes
+        ]
+
+        nameTable = self.font.get("name")
+        if not nameTable:  # this only happens for unit tests
+            nameTable = self.font["name"] = newTable("name")
+            nameTable.names = []
+
+        if "ElidedFallbackNameID" in self.stat_:
+            nameID = self.stat_["ElidedFallbackNameID"]
+            name = nameTable.getDebugName(nameID)
+            if not name:
+                raise FeatureLibError(
+                    f"ElidedFallbackNameID {nameID} points "
+                    "to a nameID that does not exist in the "
+                    '"name" table',
+                    None,
+                )
+        elif "ElidedFallbackName" in self.stat_:
+            nameID = self.stat_["ElidedFallbackName"]
+
+        otl.buildStatTable(
+            self.font,
+            designAxes,
+            locations=format4_locations,
+            elidedFallbackName=nameID,
+        )
+
+    def build_codepages_(self, pages):
+        pages2bits = {
+            1252: 0,
+            1250: 1,
+            1251: 2,
+            1253: 3,
+            1254: 4,
+            1255: 5,
+            1256: 6,
+            1257: 7,
+            1258: 8,
+            874: 16,
+            932: 17,
+            936: 18,
+            949: 19,
+            950: 20,
+            1361: 21,
+            869: 48,
+            866: 49,
+            865: 50,
+            864: 51,
+            863: 52,
+            862: 53,
+            861: 54,
+            860: 55,
+            857: 56,
+            855: 57,
+            852: 58,
+            775: 59,
+            737: 60,
+            708: 61,
+            850: 62,
+            437: 63,
+        }
+        bits = [pages2bits[p] for p in pages if p in pages2bits]
+        pages = []
+        for i in range(2):
+            pages.append("")
+            for j in range(i * 32, (i + 1) * 32):
+                if j in bits:
+                    pages[i] += "1"
+                else:
+                    pages[i] += "0"
+        return [binary2num(p[::-1]) for p in pages]
+
+    def buildBASE(self):
+        if not self.base_horiz_axis_ and not self.base_vert_axis_:
+            return None
+        base = otTables.BASE()
+        base.Version = 0x00010000
+        base.HorizAxis = self.buildBASEAxis(self.base_horiz_axis_)
+        base.VertAxis = self.buildBASEAxis(self.base_vert_axis_)
+
+        result = newTable("BASE")
+        result.table = base
+        return result
+
+    def buildBASEAxis(self, axis):
+        if not axis:
+            return
+        bases, scripts = axis
+        axis = otTables.Axis()
+        axis.BaseTagList = otTables.BaseTagList()
+        axis.BaseTagList.BaselineTag = bases
+        axis.BaseTagList.BaseTagCount = len(bases)
+        axis.BaseScriptList = otTables.BaseScriptList()
+        axis.BaseScriptList.BaseScriptRecord = []
+        axis.BaseScriptList.BaseScriptCount = len(scripts)
+        for script in sorted(scripts):
+            record = otTables.BaseScriptRecord()
+            record.BaseScriptTag = script[0]
+            record.BaseScript = otTables.BaseScript()
+            record.BaseScript.BaseLangSysCount = 0
+            record.BaseScript.BaseValues = otTables.BaseValues()
+            record.BaseScript.BaseValues.DefaultIndex = bases.index(script[1])
+            record.BaseScript.BaseValues.BaseCoord = []
+            record.BaseScript.BaseValues.BaseCoordCount = len(script[2])
+            for c in script[2]:
+                coord = otTables.BaseCoord()
+                coord.Format = 1
+                coord.Coordinate = c
+                record.BaseScript.BaseValues.BaseCoord.append(coord)
+            axis.BaseScriptList.BaseScriptRecord.append(record)
+        return axis
+
+    def buildGDEF(self):
+        gdef = otTables.GDEF()
+        gdef.GlyphClassDef = self.buildGDEFGlyphClassDef_()
+        gdef.AttachList = otl.buildAttachList(self.attachPoints_, self.glyphMap)
+        gdef.LigCaretList = otl.buildLigCaretList(
+            self.ligCaretCoords_, self.ligCaretPoints_, self.glyphMap
+        )
+        gdef.MarkAttachClassDef = self.buildGDEFMarkAttachClassDef_()
+        gdef.MarkGlyphSetsDef = self.buildGDEFMarkGlyphSetsDef_()
+        gdef.Version = 0x00010002 if gdef.MarkGlyphSetsDef else 0x00010000
+        if self.varstorebuilder:
+            store = self.varstorebuilder.finish()
+            if store:
+                gdef.Version = 0x00010003
+                gdef.VarStore = store
+                varidx_map = store.optimize()
+
+                gdef.remap_device_varidxes(varidx_map)
+                if "GPOS" in self.font:
+                    self.font["GPOS"].table.remap_device_varidxes(varidx_map)
+            self.model_cache.clear()
+        if any(
+            (
+                gdef.GlyphClassDef,
+                gdef.AttachList,
+                gdef.LigCaretList,
+                gdef.MarkAttachClassDef,
+                gdef.MarkGlyphSetsDef,
+            )
+        ) or hasattr(gdef, "VarStore"):
+            result = newTable("GDEF")
+            result.table = gdef
+            return result
+        else:
+            return None
+
+    def buildGDEFGlyphClassDef_(self):
+        if self.glyphClassDefs_:
+            classes = {g: c for (g, (c, _)) in self.glyphClassDefs_.items()}
+        else:
+            classes = {}
+            for lookup in self.lookups_:
+                classes.update(lookup.inferGlyphClasses())
+            for markClass in self.parseTree.markClasses.values():
+                for markClassDef in markClass.definitions:
+                    for glyph in markClassDef.glyphSet():
+                        classes[glyph] = 3
+        if classes:
+            result = otTables.GlyphClassDef()
+            result.classDefs = classes
+            return result
+        else:
+            return None
+
+    def buildGDEFMarkAttachClassDef_(self):
+        classDefs = {g: c for g, (c, _) in self.markAttach_.items()}
+        if not classDefs:
+            return None
+        result = otTables.MarkAttachClassDef()
+        result.classDefs = classDefs
+        return result
+
+    def buildGDEFMarkGlyphSetsDef_(self):
+        sets = []
+        for glyphs, id_ in sorted(
+            self.markFilterSets_.items(), key=lambda item: item[1]
+        ):
+            sets.append(glyphs)
+        return otl.buildMarkGlyphSetsDef(sets, self.glyphMap)
+
+    def buildDebg(self):
+        if "Debg" not in self.font:
+            self.font["Debg"] = newTable("Debg")
+            self.font["Debg"].data = {}
+        self.font["Debg"].data[LOOKUP_DEBUG_INFO_KEY] = self.lookup_locations
+
+    def buildLookups_(self, tag):
+        assert tag in ("GPOS", "GSUB"), tag
+        for lookup in self.lookups_:
+            lookup.lookup_index = None
+        lookups = []
+        for lookup in self.lookups_:
+            if lookup.table != tag:
+                continue
+            lookup.lookup_index = len(lookups)
+            self.lookup_locations[tag][str(lookup.lookup_index)] = LookupDebugInfo(
+                location=str(lookup.location),
+                name=self.get_lookup_name_(lookup),
+                feature=None,
+            )
+            lookups.append(lookup)
+        otLookups = []
+        for l in lookups:
+            try:
+                otLookups.append(l.build())
+            except OpenTypeLibError as e:
+                raise FeatureLibError(str(e), e.location) from e
+            except Exception as e:
+                location = self.lookup_locations[tag][str(l.lookup_index)].location
+                raise FeatureLibError(str(e), location) from e
+        return otLookups
+
+    def makeTable(self, tag):
+        table = getattr(otTables, tag, None)()
+        table.Version = 0x00010000
+        table.ScriptList = otTables.ScriptList()
+        table.ScriptList.ScriptRecord = []
+        table.FeatureList = otTables.FeatureList()
+        table.FeatureList.FeatureRecord = []
+        table.LookupList = otTables.LookupList()
+        table.LookupList.Lookup = self.buildLookups_(tag)
+
+        # Build a table for mapping (tag, lookup_indices) to feature_index.
+        # For example, ('liga', (2,3,7)) --> 23.
+        feature_indices = {}
+        required_feature_indices = {}  # ('latn', 'DEU') --> 23
+        scripts = {}  # 'latn' --> {'DEU': [23, 24]} for feature #23,24
+        # Sort the feature table by feature tag:
+        # https://github.com/fonttools/fonttools/issues/568
+        sortFeatureTag = lambda f: (f[0][2], f[0][1], f[0][0], f[1])
+        for key, lookups in sorted(self.features_.items(), key=sortFeatureTag):
+            script, lang, feature_tag = key
+            # l.lookup_index will be None when a lookup is not needed
+            # for the table under construction. For example, substitution
+            # rules will have no lookup_index while building GPOS tables.
+            # We also deduplicate lookup indices, as they only get applied once
+            # within a given feature:
+            # https://github.com/fonttools/fonttools/issues/2946
+            lookup_indices = tuple(
+                dict.fromkeys(
+                    l.lookup_index for l in lookups if l.lookup_index is not None
+                )
+            )
+
+            size_feature = tag == "GPOS" and feature_tag == "size"
+            force_feature = self.any_feature_variations(feature_tag, tag)
+            if len(lookup_indices) == 0 and not size_feature and not force_feature:
+                continue
+
+            for ix in lookup_indices:
+                try:
+                    self.lookup_locations[tag][str(ix)] = self.lookup_locations[tag][
+                        str(ix)
+                    ]._replace(feature=key)
+                except KeyError:
+                    warnings.warn(
+                        "feaLib.Builder subclass needs upgrading to "
+                        "stash debug information. See fonttools#2065."
+                    )
+
+            feature_key = (feature_tag, lookup_indices)
+            feature_index = feature_indices.get(feature_key)
+            if feature_index is None:
+                feature_index = len(table.FeatureList.FeatureRecord)
+                frec = otTables.FeatureRecord()
+                frec.FeatureTag = feature_tag
+                frec.Feature = otTables.Feature()
+                frec.Feature.FeatureParams = self.buildFeatureParams(feature_tag)
+                frec.Feature.LookupListIndex = list(lookup_indices)
+                frec.Feature.LookupCount = len(lookup_indices)
+                table.FeatureList.FeatureRecord.append(frec)
+                feature_indices[feature_key] = feature_index
+            scripts.setdefault(script, {}).setdefault(lang, []).append(feature_index)
+            if self.required_features_.get((script, lang)) == feature_tag:
+                required_feature_indices[(script, lang)] = feature_index
+
+        # Build ScriptList.
+        for script, lang_features in sorted(scripts.items()):
+            srec = otTables.ScriptRecord()
+            srec.ScriptTag = script
+            srec.Script = otTables.Script()
+            srec.Script.DefaultLangSys = None
+            srec.Script.LangSysRecord = []
+            for lang, feature_indices in sorted(lang_features.items()):
+                langrec = otTables.LangSysRecord()
+                langrec.LangSys = otTables.LangSys()
+                langrec.LangSys.LookupOrder = None
+
+                req_feature_index = required_feature_indices.get((script, lang))
+                if req_feature_index is None:
+                    langrec.LangSys.ReqFeatureIndex = 0xFFFF
+                else:
+                    langrec.LangSys.ReqFeatureIndex = req_feature_index
+
+                langrec.LangSys.FeatureIndex = [
+                    i for i in feature_indices if i != req_feature_index
+                ]
+                langrec.LangSys.FeatureCount = len(langrec.LangSys.FeatureIndex)
+
+                if lang == "dflt":
+                    srec.Script.DefaultLangSys = langrec.LangSys
+                else:
+                    langrec.LangSysTag = lang
+                    srec.Script.LangSysRecord.append(langrec)
+            srec.Script.LangSysCount = len(srec.Script.LangSysRecord)
+            table.ScriptList.ScriptRecord.append(srec)
+
+        table.ScriptList.ScriptCount = len(table.ScriptList.ScriptRecord)
+        table.FeatureList.FeatureCount = len(table.FeatureList.FeatureRecord)
+        table.LookupList.LookupCount = len(table.LookupList.Lookup)
+        return table
+
+    def makeFeatureVariations(self, table, table_tag):
+        feature_vars = {}
+        has_any_variations = False
+        # Sort out which lookups to build, gather their indices
+        for (_, _, feature_tag), variations in self.feature_variations_.items():
+            feature_vars[feature_tag] = []
+            for conditionset, builders in variations.items():
+                raw_conditionset = self.conditionsets_[conditionset]
+                indices = []
+                for b in builders:
+                    if b.table != table_tag:
+                        continue
+                    assert b.lookup_index is not None
+                    indices.append(b.lookup_index)
+                    has_any_variations = True
+                feature_vars[feature_tag].append((raw_conditionset, indices))
+
+        if has_any_variations:
+            for feature_tag, conditions_and_lookups in feature_vars.items():
+                addFeatureVariationsRaw(
+                    self.font, table, conditions_and_lookups, feature_tag
+                )
+
+    def any_feature_variations(self, feature_tag, table_tag):
+        for (_, _, feature), variations in self.feature_variations_.items():
+            if feature != feature_tag:
+                continue
+            for conditionset, builders in variations.items():
+                if any(b.table == table_tag for b in builders):
+                    return True
+        return False
+
+    def get_lookup_name_(self, lookup):
+        rev = {v: k for k, v in self.named_lookups_.items()}
+        if lookup in rev:
+            return rev[lookup]
+        return None
+
+    def add_language_system(self, location, script, language):
+        # OpenType Feature File Specification, section 4.b.i
+        if script == "DFLT" and language == "dflt" and self.default_language_systems_:
+            raise FeatureLibError(
+                'If "languagesystem DFLT dflt" is present, it must be '
+                "the first of the languagesystem statements",
+                location,
+            )
+        if script == "DFLT":
+            if self.seen_non_DFLT_script_:
+                raise FeatureLibError(
+                    'languagesystems using the "DFLT" script tag must '
+                    "precede all other languagesystems",
+                    location,
+                )
+        else:
+            self.seen_non_DFLT_script_ = True
+        if (script, language) in self.default_language_systems_:
+            raise FeatureLibError(
+                '"languagesystem %s %s" has already been specified'
+                % (script.strip(), language.strip()),
+                location,
+            )
+        self.default_language_systems_.add((script, language))
+
+    def get_default_language_systems_(self):
+        # OpenType Feature File specification, 4.b.i. languagesystem:
+        # If no "languagesystem" statement is present, then the
+        # implementation must behave exactly as though the following
+        # statement were present at the beginning of the feature file:
+        # languagesystem DFLT dflt;
+        if self.default_language_systems_:
+            return frozenset(self.default_language_systems_)
+        else:
+            return frozenset({("DFLT", "dflt")})
+
+    def start_feature(self, location, name):
+        self.language_systems = self.get_default_language_systems_()
+        self.script_ = "DFLT"
+        self.cur_lookup_ = None
+        self.cur_feature_name_ = name
+        self.lookupflag_ = 0
+        self.lookupflag_markFilterSet_ = None
+        if name == "aalt":
+            self.aalt_location_ = location
+
+    def end_feature(self):
+        assert self.cur_feature_name_ is not None
+        self.cur_feature_name_ = None
+        self.language_systems = None
+        self.cur_lookup_ = None
+        self.lookupflag_ = 0
+        self.lookupflag_markFilterSet_ = None
+
+    def start_lookup_block(self, location, name):
+        if name in self.named_lookups_:
+            raise FeatureLibError(
+                'Lookup "%s" has already been defined' % name, location
+            )
+        if self.cur_feature_name_ == "aalt":
+            raise FeatureLibError(
+                "Lookup blocks cannot be placed inside 'aalt' features; "
+                "move it out, and then refer to it with a lookup statement",
+                location,
+            )
+        self.cur_lookup_name_ = name
+        self.named_lookups_[name] = None
+        self.cur_lookup_ = None
+        if self.cur_feature_name_ is None:
+            self.lookupflag_ = 0
+            self.lookupflag_markFilterSet_ = None
+
+    def end_lookup_block(self):
+        assert self.cur_lookup_name_ is not None
+        self.cur_lookup_name_ = None
+        self.cur_lookup_ = None
+        if self.cur_feature_name_ is None:
+            self.lookupflag_ = 0
+            self.lookupflag_markFilterSet_ = None
+
+    def add_lookup_call(self, lookup_name):
+        assert lookup_name in self.named_lookups_, lookup_name
+        self.cur_lookup_ = None
+        lookup = self.named_lookups_[lookup_name]
+        if lookup is not None:  # skip empty named lookup
+            self.add_lookup_to_feature_(lookup, self.cur_feature_name_)
+
+    def set_font_revision(self, location, revision):
+        self.fontRevision_ = revision
+
+    def set_language(self, location, language, include_default, required):
+        assert len(language) == 4
+        if self.cur_feature_name_ in ("aalt", "size"):
+            raise FeatureLibError(
+                "Language statements are not allowed "
+                'within "feature %s"' % self.cur_feature_name_,
+                location,
+            )
+        if self.cur_feature_name_ is None:
+            raise FeatureLibError(
+                "Language statements are not allowed "
+                "within standalone lookup blocks",
+                location,
+            )
+        self.cur_lookup_ = None
+
+        key = (self.script_, language, self.cur_feature_name_)
+        lookups = self.features_.get((key[0], "dflt", key[2]))
+        if (language == "dflt" or include_default) and lookups:
+            self.features_[key] = lookups[:]
+        else:
+            self.features_[key] = []
+        self.language_systems = frozenset([(self.script_, language)])
+
+        if required:
+            key = (self.script_, language)
+            if key in self.required_features_:
+                raise FeatureLibError(
+                    "Language %s (script %s) has already "
+                    "specified feature %s as its required feature"
+                    % (
+                        language.strip(),
+                        self.script_.strip(),
+                        self.required_features_[key].strip(),
+                    ),
+                    location,
+                )
+            self.required_features_[key] = self.cur_feature_name_
+
+    def getMarkAttachClass_(self, location, glyphs):
+        glyphs = frozenset(glyphs)
+        id_ = self.markAttachClassID_.get(glyphs)
+        if id_ is not None:
+            return id_
+        id_ = len(self.markAttachClassID_) + 1
+        self.markAttachClassID_[glyphs] = id_
+        for glyph in glyphs:
+            if glyph in self.markAttach_:
+                _, loc = self.markAttach_[glyph]
+                raise FeatureLibError(
+                    "Glyph %s already has been assigned "
+                    "a MarkAttachmentType at %s" % (glyph, loc),
+                    location,
+                )
+            self.markAttach_[glyph] = (id_, location)
+        return id_
+
+    def getMarkFilterSet_(self, location, glyphs):
+        glyphs = frozenset(glyphs)
+        id_ = self.markFilterSets_.get(glyphs)
+        if id_ is not None:
+            return id_
+        id_ = len(self.markFilterSets_)
+        self.markFilterSets_[glyphs] = id_
+        return id_
+
+    def set_lookup_flag(self, location, value, markAttach, markFilter):
+        value = value & 0xFF
+        if markAttach:
+            markAttachClass = self.getMarkAttachClass_(location, markAttach)
+            value = value | (markAttachClass << 8)
+        if markFilter:
+            markFilterSet = self.getMarkFilterSet_(location, markFilter)
+            value = value | 0x10
+            self.lookupflag_markFilterSet_ = markFilterSet
+        else:
+            self.lookupflag_markFilterSet_ = None
+        self.lookupflag_ = value
+
+    def set_script(self, location, script):
+        if self.cur_feature_name_ in ("aalt", "size"):
+            raise FeatureLibError(
+                "Script statements are not allowed "
+                'within "feature %s"' % self.cur_feature_name_,
+                location,
+            )
+        if self.cur_feature_name_ is None:
+            raise FeatureLibError(
+                "Script statements are not allowed " "within standalone lookup blocks",
+                location,
+            )
+        if self.language_systems == {(script, "dflt")}:
+            # Nothing to do.
+            return
+        self.cur_lookup_ = None
+        self.script_ = script
+        self.lookupflag_ = 0
+        self.lookupflag_markFilterSet_ = None
+        self.set_language(location, "dflt", include_default=True, required=False)
+
+    def find_lookup_builders_(self, lookups):
+        """Helper for building chain contextual substitutions
+
+        Given a list of lookup names, finds the LookupBuilder for each name.
+        If an input name is None, it gets mapped to a None LookupBuilder.
+        """
+        lookup_builders = []
+        for lookuplist in lookups:
+            if lookuplist is not None:
+                lookup_builders.append(
+                    [self.named_lookups_.get(l.name) for l in lookuplist]
+                )
+            else:
+                lookup_builders.append(None)
+        return lookup_builders
+
+    def add_attach_points(self, location, glyphs, contourPoints):
+        for glyph in glyphs:
+            self.attachPoints_.setdefault(glyph, set()).update(contourPoints)
+
+    def add_feature_reference(self, location, featureName):
+        if self.cur_feature_name_ != "aalt":
+            raise FeatureLibError(
+                'Feature references are only allowed inside "feature aalt"', location
+            )
+        self.aalt_features_.append((location, featureName))
+
+    def add_featureName(self, tag):
+        self.featureNames_.add(tag)
+
+    def add_cv_parameter(self, tag):
+        self.cv_parameters_.add(tag)
+
+    def add_to_cv_num_named_params(self, tag):
+        """Adds new items to ``self.cv_num_named_params_``
+        or increments the count of existing items."""
+        if tag in self.cv_num_named_params_:
+            self.cv_num_named_params_[tag] += 1
+        else:
+            self.cv_num_named_params_[tag] = 1
+
+    def add_cv_character(self, character, tag):
+        self.cv_characters_[tag].append(character)
+
+    def set_base_axis(self, bases, scripts, vertical):
+        if vertical:
+            self.base_vert_axis_ = (bases, scripts)
+        else:
+            self.base_horiz_axis_ = (bases, scripts)
+
+    def set_size_parameters(
+        self, location, DesignSize, SubfamilyID, RangeStart, RangeEnd
+    ):
+        if self.cur_feature_name_ != "size":
+            raise FeatureLibError(
+                "Parameters statements are not allowed "
+                'within "feature %s"' % self.cur_feature_name_,
+                location,
+            )
+        self.size_parameters_ = [DesignSize, SubfamilyID, RangeStart, RangeEnd]
+        for script, lang in self.language_systems:
+            key = (script, lang, self.cur_feature_name_)
+            self.features_.setdefault(key, [])
+
+    # GSUB rules
+
+    # GSUB 1
+    def add_single_subst(self, location, prefix, suffix, mapping, forceChain):
+        if self.cur_feature_name_ == "aalt":
+            for from_glyph, to_glyph in mapping.items():
+                alts = self.aalt_alternates_.setdefault(from_glyph, [])
+                if to_glyph not in alts:
+                    alts.append(to_glyph)
+            return
+        if prefix or suffix or forceChain:
+            self.add_single_subst_chained_(location, prefix, suffix, mapping)
+            return
+        lookup = self.get_lookup_(location, SingleSubstBuilder)
+        for from_glyph, to_glyph in mapping.items():
+            if from_glyph in lookup.mapping:
+                if to_glyph == lookup.mapping[from_glyph]:
+                    log.info(
+                        "Removing duplicate single substitution from glyph"
+                        ' "%s" to "%s" at %s',
+                        from_glyph,
+                        to_glyph,
+                        location,
+                    )
+                else:
+                    raise FeatureLibError(
+                        'Already defined rule for replacing glyph "%s" by "%s"'
+                        % (from_glyph, lookup.mapping[from_glyph]),
+                        location,
+                    )
+            lookup.mapping[from_glyph] = to_glyph
+
+    # GSUB 2
+    def add_multiple_subst(
+        self, location, prefix, glyph, suffix, replacements, forceChain=False
+    ):
+        if prefix or suffix or forceChain:
+            self.add_multi_subst_chained_(location, prefix, glyph, suffix, replacements)
+            return
+        lookup = self.get_lookup_(location, MultipleSubstBuilder)
+        if glyph in lookup.mapping:
+            if replacements == lookup.mapping[glyph]:
+                log.info(
+                    "Removing duplicate multiple substitution from glyph"
+                    ' "%s" to %s%s',
+                    glyph,
+                    replacements,
+                    f" at {location}" if location else "",
+                )
+            else:
+                raise FeatureLibError(
+                    'Already defined substitution for glyph "%s"' % glyph, location
+                )
+        lookup.mapping[glyph] = replacements
+
+    # GSUB 3
+    def add_alternate_subst(self, location, prefix, glyph, suffix, replacement):
+        if self.cur_feature_name_ == "aalt":
+            alts = self.aalt_alternates_.setdefault(glyph, [])
+            alts.extend(g for g in replacement if g not in alts)
+            return
+        if prefix or suffix:
+            chain = self.get_lookup_(location, ChainContextSubstBuilder)
+            lookup = self.get_chained_lookup_(location, AlternateSubstBuilder)
+            chain.rules.append(ChainContextualRule(prefix, [{glyph}], suffix, [lookup]))
+        else:
+            lookup = self.get_lookup_(location, AlternateSubstBuilder)
+        if glyph in lookup.alternates:
+            raise FeatureLibError(
+                'Already defined alternates for glyph "%s"' % glyph, location
+            )
+        # We allow empty replacement glyphs here.
+        lookup.alternates[glyph] = replacement
+
+    # GSUB 4
+    def add_ligature_subst(
+        self, location, prefix, glyphs, suffix, replacement, forceChain
+    ):
+        if prefix or suffix or forceChain:
+            chain = self.get_lookup_(location, ChainContextSubstBuilder)
+            lookup = self.get_chained_lookup_(location, LigatureSubstBuilder)
+            chain.rules.append(ChainContextualRule(prefix, glyphs, suffix, [lookup]))
+        else:
+            lookup = self.get_lookup_(location, LigatureSubstBuilder)
+
+        if not all(glyphs):
+            raise FeatureLibError("Empty glyph class in substitution", location)
+
+        # OpenType feature file syntax, section 5.d, "Ligature substitution":
+        # "Since the OpenType specification does not allow ligature
+        # substitutions to be specified on target sequences that contain
+        # glyph classes, the implementation software will enumerate
+        # all specific glyph sequences if glyph classes are detected"
+        for g in itertools.product(*glyphs):
+            lookup.ligatures[g] = replacement
+
+    # GSUB 5/6
+    def add_chain_context_subst(self, location, prefix, glyphs, suffix, lookups):
+        if not all(glyphs) or not all(prefix) or not all(suffix):
+            raise FeatureLibError(
+                "Empty glyph class in contextual substitution", location
+            )
+        lookup = self.get_lookup_(location, ChainContextSubstBuilder)
+        lookup.rules.append(
+            ChainContextualRule(
+                prefix, glyphs, suffix, self.find_lookup_builders_(lookups)
+            )
+        )
+
+    def add_single_subst_chained_(self, location, prefix, suffix, mapping):
+        if not mapping or not all(prefix) or not all(suffix):
+            raise FeatureLibError(
+                "Empty glyph class in contextual substitution", location
+            )
+        # https://github.com/fonttools/fonttools/issues/512
+        # https://github.com/fonttools/fonttools/issues/2150
+        chain = self.get_lookup_(location, ChainContextSubstBuilder)
+        sub = chain.find_chainable_subst(mapping, SingleSubstBuilder)
+        if sub is None:
+            sub = self.get_chained_lookup_(location, SingleSubstBuilder)
+        sub.mapping.update(mapping)
+        chain.rules.append(
+            ChainContextualRule(prefix, [list(mapping.keys())], suffix, [sub])
+        )
+
+    def add_multi_subst_chained_(self, location, prefix, glyph, suffix, replacements):
+        if not all(prefix) or not all(suffix):
+            raise FeatureLibError(
+                "Empty glyph class in contextual substitution", location
+            )
+        # https://github.com/fonttools/fonttools/issues/3551
+        chain = self.get_lookup_(location, ChainContextSubstBuilder)
+        sub = chain.find_chainable_subst({glyph: replacements}, MultipleSubstBuilder)
+        if sub is None:
+            sub = self.get_chained_lookup_(location, MultipleSubstBuilder)
+        sub.mapping[glyph] = replacements
+        chain.rules.append(ChainContextualRule(prefix, [{glyph}], suffix, [sub]))
+
+    # GSUB 8
+    def add_reverse_chain_single_subst(self, location, old_prefix, old_suffix, mapping):
+        if not mapping:
+            raise FeatureLibError("Empty glyph class in substitution", location)
+        lookup = self.get_lookup_(location, ReverseChainSingleSubstBuilder)
+        lookup.rules.append((old_prefix, old_suffix, mapping))
+
+    # GPOS rules
+
+    # GPOS 1
+    def add_single_pos(self, location, prefix, suffix, pos, forceChain):
+        if prefix or suffix or forceChain:
+            self.add_single_pos_chained_(location, prefix, suffix, pos)
+        else:
+            lookup = self.get_lookup_(location, SinglePosBuilder)
+            for glyphs, value in pos:
+                if not glyphs:
+                    raise FeatureLibError(
+                        "Empty glyph class in positioning rule", location
+                    )
+                otValueRecord = self.makeOpenTypeValueRecord(
+                    location, value, pairPosContext=False
+                )
+                for glyph in glyphs:
+                    try:
+                        lookup.add_pos(location, glyph, otValueRecord)
+                    except OpenTypeLibError as e:
+                        raise FeatureLibError(str(e), e.location) from e
+
+    # GPOS 2
+    def add_class_pair_pos(self, location, glyphclass1, value1, glyphclass2, value2):
+        if not glyphclass1 or not glyphclass2:
+            raise FeatureLibError("Empty glyph class in positioning rule", location)
+        lookup = self.get_lookup_(location, PairPosBuilder)
+        v1 = self.makeOpenTypeValueRecord(location, value1, pairPosContext=True)
+        v2 = self.makeOpenTypeValueRecord(location, value2, pairPosContext=True)
+        lookup.addClassPair(location, glyphclass1, v1, glyphclass2, v2)
+
+    def add_specific_pair_pos(self, location, glyph1, value1, glyph2, value2):
+        if not glyph1 or not glyph2:
+            raise FeatureLibError("Empty glyph class in positioning rule", location)
+        lookup = self.get_lookup_(location, PairPosBuilder)
+        v1 = self.makeOpenTypeValueRecord(location, value1, pairPosContext=True)
+        v2 = self.makeOpenTypeValueRecord(location, value2, pairPosContext=True)
+        lookup.addGlyphPair(location, glyph1, v1, glyph2, v2)
+
+    # GPOS 3
+    def add_cursive_pos(self, location, glyphclass, entryAnchor, exitAnchor):
+        if not glyphclass:
+            raise FeatureLibError("Empty glyph class in positioning rule", location)
+        lookup = self.get_lookup_(location, CursivePosBuilder)
+        lookup.add_attachment(
+            location,
+            glyphclass,
+            self.makeOpenTypeAnchor(location, entryAnchor),
+            self.makeOpenTypeAnchor(location, exitAnchor),
+        )
+
+    # GPOS 4
+    def add_mark_base_pos(self, location, bases, marks):
+        builder = self.get_lookup_(location, MarkBasePosBuilder)
+        self.add_marks_(location, builder, marks)
+        if not bases:
+            raise FeatureLibError("Empty glyph class in positioning rule", location)
+        for baseAnchor, markClass in marks:
+            otBaseAnchor = self.makeOpenTypeAnchor(location, baseAnchor)
+            for base in bases:
+                builder.bases.setdefault(base, {})[markClass.name] = otBaseAnchor
+
+    # GPOS 5
+    def add_mark_lig_pos(self, location, ligatures, components):
+        builder = self.get_lookup_(location, MarkLigPosBuilder)
+        componentAnchors = []
+        if not ligatures:
+            raise FeatureLibError("Empty glyph class in positioning rule", location)
+        for marks in components:
+            anchors = {}
+            self.add_marks_(location, builder, marks)
+            for ligAnchor, markClass in marks:
+                anchors[markClass.name] = self.makeOpenTypeAnchor(location, ligAnchor)
+            componentAnchors.append(anchors)
+        for glyph in ligatures:
+            builder.ligatures[glyph] = componentAnchors
+
+    # GPOS 6
+    def add_mark_mark_pos(self, location, baseMarks, marks):
+        builder = self.get_lookup_(location, MarkMarkPosBuilder)
+        self.add_marks_(location, builder, marks)
+        if not baseMarks:
+            raise FeatureLibError("Empty glyph class in positioning rule", location)
+        for baseAnchor, markClass in marks:
+            otBaseAnchor = self.makeOpenTypeAnchor(location, baseAnchor)
+            for baseMark in baseMarks:
+                builder.baseMarks.setdefault(baseMark, {})[
+                    markClass.name
+                ] = otBaseAnchor
+
+    # GPOS 7/8
+    def add_chain_context_pos(self, location, prefix, glyphs, suffix, lookups):
+        if not all(glyphs) or not all(prefix) or not all(suffix):
+            raise FeatureLibError(
+                "Empty glyph class in contextual positioning rule", location
+            )
+        lookup = self.get_lookup_(location, ChainContextPosBuilder)
+        lookup.rules.append(
+            ChainContextualRule(
+                prefix, glyphs, suffix, self.find_lookup_builders_(lookups)
+            )
+        )
+
+    def add_single_pos_chained_(self, location, prefix, suffix, pos):
+        if not pos or not all(prefix) or not all(suffix):
+            raise FeatureLibError(
+                "Empty glyph class in contextual positioning rule", location
+            )
+        # https://github.com/fonttools/fonttools/issues/514
+        chain = self.get_lookup_(location, ChainContextPosBuilder)
+        targets = []
+        for _, _, _, lookups in chain.rules:
+            targets.extend(lookups)
+        subs = []
+        for glyphs, value in pos:
+            if value is None:
+                subs.append(None)
+                continue
+            otValue = self.makeOpenTypeValueRecord(
+                location, value, pairPosContext=False
+            )
+            sub = chain.find_chainable_single_pos(targets, glyphs, otValue)
+            if sub is None:
+                sub = self.get_chained_lookup_(location, SinglePosBuilder)
+                targets.append(sub)
+            for glyph in glyphs:
+                sub.add_pos(location, glyph, otValue)
+            subs.append(sub)
+        assert len(pos) == len(subs), (pos, subs)
+        chain.rules.append(
+            ChainContextualRule(prefix, [g for g, v in pos], suffix, subs)
+        )
+
+    def add_marks_(self, location, lookupBuilder, marks):
+        """Helper for add_mark_{base,liga,mark}_pos."""
+        for _, markClass in marks:
+            for markClassDef in markClass.definitions:
+                for mark in markClassDef.glyphs.glyphSet():
+                    if mark not in lookupBuilder.marks:
+                        otMarkAnchor = self.makeOpenTypeAnchor(
+                            location, copy.deepcopy(markClassDef.anchor)
+                        )
+                        lookupBuilder.marks[mark] = (markClass.name, otMarkAnchor)
+                    else:
+                        existingMarkClass = lookupBuilder.marks[mark][0]
+                        if markClass.name != existingMarkClass:
+                            raise FeatureLibError(
+                                "Glyph %s cannot be in both @%s and @%s"
+                                % (mark, existingMarkClass, markClass.name),
+                                location,
+                            )
+
+    def add_subtable_break(self, location):
+        self.cur_lookup_.add_subtable_break(location)
+
+    def setGlyphClass_(self, location, glyph, glyphClass):
+        oldClass, oldLocation = self.glyphClassDefs_.get(glyph, (None, None))
+        if oldClass and oldClass != glyphClass:
+            raise FeatureLibError(
+                "Glyph %s was assigned to a different class at %s"
+                % (glyph, oldLocation),
+                location,
+            )
+        self.glyphClassDefs_[glyph] = (glyphClass, location)
+
+    def add_glyphClassDef(
+        self, location, baseGlyphs, ligatureGlyphs, markGlyphs, componentGlyphs
+    ):
+        for glyph in baseGlyphs:
+            self.setGlyphClass_(location, glyph, 1)
+        for glyph in ligatureGlyphs:
+            self.setGlyphClass_(location, glyph, 2)
+        for glyph in markGlyphs:
+            self.setGlyphClass_(location, glyph, 3)
+        for glyph in componentGlyphs:
+            self.setGlyphClass_(location, glyph, 4)
+
+    def add_ligatureCaretByIndex_(self, location, glyphs, carets):
+        for glyph in glyphs:
+            if glyph not in self.ligCaretPoints_:
+                self.ligCaretPoints_[glyph] = carets
+
+    def makeLigCaret(self, location, caret):
+        if not isinstance(caret, VariableScalar):
+            return caret
+        default, device = self.makeVariablePos(location, caret)
+        if device is not None:
+            return (default, device)
+        return default
+
+    def add_ligatureCaretByPos_(self, location, glyphs, carets):
+        carets = [self.makeLigCaret(location, caret) for caret in carets]
+        for glyph in glyphs:
+            if glyph not in self.ligCaretCoords_:
+                self.ligCaretCoords_[glyph] = carets
+
+    def add_name_record(self, location, nameID, platformID, platEncID, langID, string):
+        self.names_.append([nameID, platformID, platEncID, langID, string])
+
+    def add_os2_field(self, key, value):
+        self.os2_[key] = value
+
+    def add_hhea_field(self, key, value):
+        self.hhea_[key] = value
+
+    def add_vhea_field(self, key, value):
+        self.vhea_[key] = value
+
+    def add_conditionset(self, location, key, value):
+        if "fvar" not in self.font:
+            raise FeatureLibError(
+                "Cannot add feature variations to a font without an 'fvar' table",
+                location,
+            )
+
+        # Normalize
+        axisMap = {
+            axis.axisTag: (axis.minValue, axis.defaultValue, axis.maxValue)
+            for axis in self.axes
+        }
+
+        value = {
+            tag: (
+                normalizeValue(bottom, axisMap[tag]),
+                normalizeValue(top, axisMap[tag]),
+            )
+            for tag, (bottom, top) in value.items()
+        }
+
+        # NOTE: This might result in rounding errors (off-by-ones) compared to
+        # rules in Designspace files, since we're working with what's in the
+        # `avar` table rather than the original values.
+        if "avar" in self.font:
+            mapping = self.font["avar"].segments
+            value = {
+                axis: tuple(
+                    piecewiseLinearMap(v, mapping[axis]) if axis in mapping else v
+                    for v in condition_range
+                )
+                for axis, condition_range in value.items()
+            }
+
+        self.conditionsets_[key] = value
+
+    def makeVariablePos(self, location, varscalar):
+        if not self.varstorebuilder:
+            raise FeatureLibError(
+                "Can't define a variable scalar in a non-variable font", location
+            )
+
+        varscalar.axes = self.axes
+        if not varscalar.does_vary:
+            return varscalar.default, None
+
+        default, index = varscalar.add_to_variation_store(
+            self.varstorebuilder, self.model_cache, self.font.get("avar")
+        )
+
+        device = None
+        if index is not None and index != 0xFFFFFFFF:
+            device = buildVarDevTable(index)
+
+        return default, device
+
+    def makeOpenTypeAnchor(self, location, anchor):
+        """ast.Anchor --> otTables.Anchor"""
+        if anchor is None:
+            return None
+        variable = False
+        deviceX, deviceY = None, None
+        if anchor.xDeviceTable is not None:
+            deviceX = otl.buildDevice(dict(anchor.xDeviceTable))
+        if anchor.yDeviceTable is not None:
+            deviceY = otl.buildDevice(dict(anchor.yDeviceTable))
+        for dim in ("x", "y"):
+            varscalar = getattr(anchor, dim)
+            if not isinstance(varscalar, VariableScalar):
+                continue
+            if getattr(anchor, dim + "DeviceTable") is not None:
+                raise FeatureLibError(
+                    "Can't define a device coordinate and variable scalar", location
+                )
+            default, device = self.makeVariablePos(location, varscalar)
+            setattr(anchor, dim, default)
+            if device is not None:
+                if dim == "x":
+                    deviceX = device
+                else:
+                    deviceY = device
+                variable = True
+
+        otlanchor = otl.buildAnchor(
+            anchor.x, anchor.y, anchor.contourpoint, deviceX, deviceY
+        )
+        if variable:
+            otlanchor.Format = 3
+        return otlanchor
+
+    _VALUEREC_ATTRS = {
+        name[0].lower() + name[1:]: (name, isDevice)
+        for _, name, isDevice, _ in otBase.valueRecordFormat
+        if not name.startswith("Reserved")
+    }
+
+    def makeOpenTypeValueRecord(self, location, v, pairPosContext):
+        """ast.ValueRecord --> otBase.ValueRecord"""
+        if not v:
+            return None
+
+        vr = {}
+        for astName, (otName, isDevice) in self._VALUEREC_ATTRS.items():
+            val = getattr(v, astName, None)
+            if not val:
+                continue
+            if isDevice:
+                vr[otName] = otl.buildDevice(dict(val))
+            elif isinstance(val, VariableScalar):
+                otDeviceName = otName[0:4] + "Device"
+                feaDeviceName = otDeviceName[0].lower() + otDeviceName[1:]
+                if getattr(v, feaDeviceName):
+                    raise FeatureLibError(
+                        "Can't define a device coordinate and variable scalar", location
+                    )
+                vr[otName], device = self.makeVariablePos(location, val)
+                if device is not None:
+                    vr[otDeviceName] = device
+            else:
+                vr[otName] = val
+
+        if pairPosContext and not vr:
+            vr = {"YAdvance": 0} if v.vertical else {"XAdvance": 0}
+        valRec = otl.buildValue(vr)
+        return valRec

evalkit_tf437/lib/python3.10/site-packages/fontTools/feaLib/error.py

@@ -0,0 +1,22 @@
+class FeatureLibError(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
+
+
+class IncludedFeaNotFound(FeatureLibError):
+    def __str__(self):
+        assert self.location is not None
+
+        message = (
+            "The following feature file should be included but cannot be found: "
+            f"{Exception.__str__(self)}"
+        )
+        return f"{self.location}: {message}"

evalkit_tf437/lib/python3.10/site-packages/fontTools/feaLib/lexer.cpython-310-x86_64-linux-gnu.so

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

evalkit_tf437/lib/python3.10/site-packages/fontTools/merge/util.py

@@ -0,0 +1,143 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools.misc.timeTools import timestampNow
+from fontTools.ttLib.tables.DefaultTable import DefaultTable
+from functools import reduce
+import operator
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+# General utility functions for merging values from different fonts
+
+
+def equal(lst):
+    lst = list(lst)
+    t = iter(lst)
+    first = next(t)
+    assert all(item == first for item in t), "Expected all items to be equal: %s" % lst
+    return first
+
+
+def first(lst):
+    return next(iter(lst))
+
+
+def recalculate(lst):
+    return NotImplemented
+
+
+def current_time(lst):
+    return timestampNow()
+
+
+def bitwise_and(lst):
+    return reduce(operator.and_, lst)
+
+
+def bitwise_or(lst):
+    return reduce(operator.or_, lst)
+
+
+def avg_int(lst):
+    lst = list(lst)
+    return sum(lst) // len(lst)
+
+
+def onlyExisting(func):
+    """Returns a filter func that when called with a list,
+    only calls func on the non-NotImplemented items of the list,
+    and only so if there's at least one item remaining.
+    Otherwise returns NotImplemented."""
+
+    def wrapper(lst):
+        items = [item for item in lst if item is not NotImplemented]
+        return func(items) if items else NotImplemented
+
+    return wrapper
+
+
+def sumLists(lst):
+    l = []
+    for item in lst:
+        l.extend(item)
+    return l
+
+
+def sumDicts(lst):
+    d = {}
+    for item in lst:
+        d.update(item)
+    return d
+
+
+def mergeBits(bitmap):
+    def wrapper(lst):
+        lst = list(lst)
+        returnValue = 0
+        for bitNumber in range(bitmap["size"]):
+            try:
+                mergeLogic = bitmap[bitNumber]
+            except KeyError:
+                try:
+                    mergeLogic = bitmap["*"]
+                except KeyError:
+                    raise Exception("Don't know how to merge bit %s" % bitNumber)
+            shiftedBit = 1 << bitNumber
+            mergedValue = mergeLogic(bool(item & shiftedBit) for item in lst)
+            returnValue |= mergedValue << bitNumber
+        return returnValue
+
+    return wrapper
+
+
+class AttendanceRecordingIdentityDict(object):
+    """A dictionary-like object that records indices of items actually accessed
+    from a list."""
+
+    def __init__(self, lst):
+        self.l = lst
+        self.d = {id(v): i for i, v in enumerate(lst)}
+        self.s = set()
+
+    def __getitem__(self, v):
+        self.s.add(self.d[id(v)])
+        return v
+
+
+class GregariousIdentityDict(object):
+    """A dictionary-like object that welcomes guests without reservations and
+    adds them to the end of the guest list."""
+
+    def __init__(self, lst):
+        self.l = lst
+        self.s = set(id(v) for v in lst)
+
+    def __getitem__(self, v):
+        if id(v) not in self.s:
+            self.s.add(id(v))
+            self.l.append(v)
+        return v
+
+
+class NonhashableDict(object):
+    """A dictionary-like object mapping objects to values."""
+
+    def __init__(self, keys, values=None):
+        if values is None:
+            self.d = {id(v): i for i, v in enumerate(keys)}
+        else:
+            self.d = {id(k): v for k, v in zip(keys, values)}
+
+    def __getitem__(self, k):
+        return self.d[id(k)]
+
+    def __setitem__(self, k, v):
+        self.d[id(k)] = v
+
+    def __delitem__(self, k):
+        del self.d[id(k)]

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/bezierTools.py

@@ -0,0 +1,1493 @@
+# -*- coding: utf-8 -*-
+"""fontTools.misc.bezierTools.py -- tools for working with Bezier path segments.
+"""
+
+from fontTools.misc.arrayTools import calcBounds, sectRect, rectArea
+from fontTools.misc.transform import Identity
+import math
+from collections import namedtuple
+
+try:
+    import cython
+
+    COMPILED = cython.compiled
+except (AttributeError, ImportError):
+    # if cython not installed, use mock module with no-op decorators and types
+    from fontTools.misc import cython
+
+    COMPILED = False
+
+
+EPSILON = 1e-9
+
+
+Intersection = namedtuple("Intersection", ["pt", "t1", "t2"])
+
+
+__all__ = [
+    "approximateCubicArcLength",
+    "approximateCubicArcLengthC",
+    "approximateQuadraticArcLength",
+    "approximateQuadraticArcLengthC",
+    "calcCubicArcLength",
+    "calcCubicArcLengthC",
+    "calcQuadraticArcLength",
+    "calcQuadraticArcLengthC",
+    "calcCubicBounds",
+    "calcQuadraticBounds",
+    "splitLine",
+    "splitQuadratic",
+    "splitCubic",
+    "splitQuadraticAtT",
+    "splitCubicAtT",
+    "splitCubicAtTC",
+    "splitCubicIntoTwoAtTC",
+    "solveQuadratic",
+    "solveCubic",
+    "quadraticPointAtT",
+    "cubicPointAtT",
+    "cubicPointAtTC",
+    "linePointAtT",
+    "segmentPointAtT",
+    "lineLineIntersections",
+    "curveLineIntersections",
+    "curveCurveIntersections",
+    "segmentSegmentIntersections",
+]
+
+
+def calcCubicArcLength(pt1, pt2, pt3, pt4, tolerance=0.005):
+    """Calculates the arc length for a cubic Bezier segment.
+
+    Whereas :func:`approximateCubicArcLength` approximates the length, this
+    function calculates it by "measuring", recursively dividing the curve
+    until the divided segments are shorter than ``tolerance``.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
+        tolerance: Controls the precision of the calcuation.
+
+    Returns:
+        Arc length value.
+    """
+    return calcCubicArcLengthC(
+        complex(*pt1), complex(*pt2), complex(*pt3), complex(*pt4), tolerance
+    )
+
+
+def _split_cubic_into_two(p0, p1, p2, p3):
+    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.returns(cython.double)
+@cython.locals(
+    p0=cython.complex,
+    p1=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+)
+@cython.locals(mult=cython.double, arch=cython.double, box=cython.double)
+def _calcCubicArcLengthCRecurse(mult, p0, p1, p2, p3):
+    arch = abs(p0 - p3)
+    box = abs(p0 - p1) + abs(p1 - p2) + abs(p2 - p3)
+    if arch * mult + EPSILON >= box:
+        return (arch + box) * 0.5
+    else:
+        one, two = _split_cubic_into_two(p0, p1, p2, p3)
+        return _calcCubicArcLengthCRecurse(mult, *one) + _calcCubicArcLengthCRecurse(
+            mult, *two
+        )
+
+
+@cython.returns(cython.double)
+@cython.locals(
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    pt4=cython.complex,
+)
+@cython.locals(
+    tolerance=cython.double,
+    mult=cython.double,
+)
+def calcCubicArcLengthC(pt1, pt2, pt3, pt4, tolerance=0.005):
+    """Calculates the arc length for a cubic Bezier segment.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.
+        tolerance: Controls the precision of the calcuation.
+
+    Returns:
+        Arc length value.
+    """
+    mult = 1.0 + 1.5 * tolerance  # The 1.5 is a empirical hack; no math
+    return _calcCubicArcLengthCRecurse(mult, pt1, pt2, pt3, pt4)
+
+
+epsilonDigits = 6
+epsilon = 1e-10
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.double)
+@cython.locals(v1=cython.complex, v2=cython.complex)
+def _dot(v1, v2):
+    return (v1 * v2.conjugate()).real
+
+
+@cython.cfunc
+@cython.inline
+@cython.returns(cython.double)
+@cython.locals(x=cython.double)
+def _intSecAtan(x):
+    # In : sympy.integrate(sp.sec(sp.atan(x)))
+    # Out: x*sqrt(x**2 + 1)/2 + asinh(x)/2
+    return x * math.sqrt(x**2 + 1) / 2 + math.asinh(x) / 2
+
+
+def calcQuadraticArcLength(pt1, pt2, pt3):
+    """Calculates the arc length for a quadratic Bezier segment.
+
+    Args:
+        pt1: Start point of the Bezier as 2D tuple.
+        pt2: Handle point of the Bezier as 2D tuple.
+        pt3: End point of the Bezier as 2D tuple.
+
+    Returns:
+        Arc length value.
+
+    Example::
+
+        >>> calcQuadraticArcLength((0, 0), (0, 0), (0, 0)) # empty segment
+        0.0
+        >>> calcQuadraticArcLength((0, 0), (50, 0), (80, 0)) # collinear points
+        80.0
+        >>> calcQuadraticArcLength((0, 0), (0, 50), (0, 80)) # collinear points vertical
+        80.0
+        >>> calcQuadraticArcLength((0, 0), (50, 20), (100, 40)) # collinear points
+        107.70329614269008
+        >>> calcQuadraticArcLength((0, 0), (0, 100), (100, 0))
+        154.02976155645263
+        >>> calcQuadraticArcLength((0, 0), (0, 50), (100, 0))
+        120.21581243984076
+        >>> calcQuadraticArcLength((0, 0), (50, -10), (80, 50))
+        102.53273816445825
+        >>> calcQuadraticArcLength((0, 0), (40, 0), (-40, 0)) # collinear points, control point outside
+        66.66666666666667
+        >>> calcQuadraticArcLength((0, 0), (40, 0), (0, 0)) # collinear points, looping back
+        40.0
+    """
+    return calcQuadraticArcLengthC(complex(*pt1), complex(*pt2), complex(*pt3))
+
+
+@cython.returns(cython.double)
+@cython.locals(
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    d0=cython.complex,
+    d1=cython.complex,
+    d=cython.complex,
+    n=cython.complex,
+)
+@cython.locals(
+    scale=cython.double,
+    origDist=cython.double,
+    a=cython.double,
+    b=cython.double,
+    x0=cython.double,
+    x1=cython.double,
+    Len=cython.double,
+)
+def calcQuadraticArcLengthC(pt1, pt2, pt3):
+    """Calculates the arc length for a quadratic Bezier segment.
+
+    Args:
+        pt1: Start point of the Bezier as a complex number.
+        pt2: Handle point of the Bezier as a complex number.
+        pt3: End point of the Bezier as a complex number.
+
+    Returns:
+        Arc length value.
+    """
+    # Analytical solution to the length of a quadratic bezier.
+    # Documentation: https://github.com/fonttools/fonttools/issues/3055
+    d0 = pt2 - pt1
+    d1 = pt3 - pt2
+    d = d1 - d0
+    n = d * 1j
+    scale = abs(n)
+    if scale == 0.0:
+        return abs(pt3 - pt1)
+    origDist = _dot(n, d0)
+    if abs(origDist) < epsilon:
+        if _dot(d0, d1) >= 0:
+            return abs(pt3 - pt1)
+        a, b = abs(d0), abs(d1)
+        return (a * a + b * b) / (a + b)
+    x0 = _dot(d, d0) / origDist
+    x1 = _dot(d, d1) / origDist
+    Len = abs(2 * (_intSecAtan(x1) - _intSecAtan(x0)) * origDist / (scale * (x1 - x0)))
+    return Len
+
+
+def approximateQuadraticArcLength(pt1, pt2, pt3):
+    """Calculates the arc length for a quadratic Bezier segment.
+
+    Uses Gauss-Legendre quadrature for a branch-free approximation.
+    See :func:`calcQuadraticArcLength` for a slower but more accurate result.
+
+    Args:
+        pt1: Start point of the Bezier as 2D tuple.
+        pt2: Handle point of the Bezier as 2D tuple.
+        pt3: End point of the Bezier as 2D tuple.
+
+    Returns:
+        Approximate arc length value.
+    """
+    return approximateQuadraticArcLengthC(complex(*pt1), complex(*pt2), complex(*pt3))
+
+
+@cython.returns(cython.double)
+@cython.locals(
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+)
+@cython.locals(
+    v0=cython.double,
+    v1=cython.double,
+    v2=cython.double,
+)
+def approximateQuadraticArcLengthC(pt1, pt2, pt3):
+    """Calculates the arc length for a quadratic Bezier segment.
+
+    Uses Gauss-Legendre quadrature for a branch-free approximation.
+    See :func:`calcQuadraticArcLength` for a slower but more accurate result.
+
+    Args:
+        pt1: Start point of the Bezier as a complex number.
+        pt2: Handle point of the Bezier as a complex number.
+        pt3: End point of the Bezier as a complex number.
+
+    Returns:
+        Approximate arc length value.
+    """
+    # This, essentially, approximates the length-of-derivative function
+    # to be integrated with the best-matching fifth-degree polynomial
+    # approximation of it.
+    #
+    # https://en.wikipedia.org/wiki/Gaussian_quadrature#Gauss.E2.80.93Legendre_quadrature
+
+    # abs(BezierCurveC[2].diff(t).subs({t:T})) for T in sorted(.5, .5±sqrt(3/5)/2),
+    # weighted 5/18, 8/18, 5/18 respectively.
+    v0 = abs(
+        -0.492943519233745 * pt1 + 0.430331482911935 * pt2 + 0.0626120363218102 * pt3
+    )
+    v1 = abs(pt3 - pt1) * 0.4444444444444444
+    v2 = abs(
+        -0.0626120363218102 * pt1 - 0.430331482911935 * pt2 + 0.492943519233745 * pt3
+    )
+
+    return v0 + v1 + v2
+
+
+def calcQuadraticBounds(pt1, pt2, pt3):
+    """Calculates the bounding rectangle for a quadratic Bezier segment.
+
+    Args:
+        pt1: Start point of the Bezier as a 2D tuple.
+        pt2: Handle point of the Bezier as a 2D tuple.
+        pt3: End point of the Bezier as a 2D tuple.
+
+    Returns:
+        A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``.
+
+    Example::
+
+        >>> calcQuadraticBounds((0, 0), (50, 100), (100, 0))
+        (0, 0, 100, 50.0)
+        >>> calcQuadraticBounds((0, 0), (100, 0), (100, 100))
+        (0.0, 0.0, 100, 100)
+    """
+    (ax, ay), (bx, by), (cx, cy) = calcQuadraticParameters(pt1, pt2, pt3)
+    ax2 = ax * 2.0
+    ay2 = ay * 2.0
+    roots = []
+    if ax2 != 0:
+        roots.append(-bx / ax2)
+    if ay2 != 0:
+        roots.append(-by / ay2)
+    points = [
+        (ax * t * t + bx * t + cx, ay * t * t + by * t + cy)
+        for t in roots
+        if 0 <= t < 1
+    ] + [pt1, pt3]
+    return calcBounds(points)
+
+
+def approximateCubicArcLength(pt1, pt2, pt3, pt4):
+    """Approximates the arc length for a cubic Bezier segment.
+
+    Uses Gauss-Lobatto quadrature with n=5 points to approximate arc length.
+    See :func:`calcCubicArcLength` for a slower but more accurate result.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
+
+    Returns:
+        Arc length value.
+
+    Example::
+
+        >>> approximateCubicArcLength((0, 0), (25, 100), (75, 100), (100, 0))
+        190.04332968932817
+        >>> approximateCubicArcLength((0, 0), (50, 0), (100, 50), (100, 100))
+        154.8852074945903
+        >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (150, 0)) # line; exact result should be 150.
+        149.99999999999991
+        >>> approximateCubicArcLength((0, 0), (50, 0), (100, 0), (-50, 0)) # cusp; exact result should be 150.
+        136.9267662156362
+        >>> approximateCubicArcLength((0, 0), (50, 0), (100, -50), (-50, 0)) # cusp
+        154.80848416537057
+    """
+    return approximateCubicArcLengthC(
+        complex(*pt1), complex(*pt2), complex(*pt3), complex(*pt4)
+    )
+
+
+@cython.returns(cython.double)
+@cython.locals(
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    pt4=cython.complex,
+)
+@cython.locals(
+    v0=cython.double,
+    v1=cython.double,
+    v2=cython.double,
+    v3=cython.double,
+    v4=cython.double,
+)
+def approximateCubicArcLengthC(pt1, pt2, pt3, pt4):
+    """Approximates the arc length for a cubic Bezier segment.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.
+
+    Returns:
+        Arc length value.
+    """
+    # This, essentially, approximates the length-of-derivative function
+    # to be integrated with the best-matching seventh-degree polynomial
+    # approximation of it.
+    #
+    # https://en.wikipedia.org/wiki/Gaussian_quadrature#Gauss.E2.80.93Lobatto_rules
+
+    # abs(BezierCurveC[3].diff(t).subs({t:T})) for T in sorted(0, .5±(3/7)**.5/2, .5, 1),
+    # weighted 1/20, 49/180, 32/90, 49/180, 1/20 respectively.
+    v0 = abs(pt2 - pt1) * 0.15
+    v1 = abs(
+        -0.558983582205757 * pt1
+        + 0.325650248872424 * pt2
+        + 0.208983582205757 * pt3
+        + 0.024349751127576 * pt4
+    )
+    v2 = abs(pt4 - pt1 + pt3 - pt2) * 0.26666666666666666
+    v3 = abs(
+        -0.024349751127576 * pt1
+        - 0.208983582205757 * pt2
+        - 0.325650248872424 * pt3
+        + 0.558983582205757 * pt4
+    )
+    v4 = abs(pt4 - pt3) * 0.15
+
+    return v0 + v1 + v2 + v3 + v4
+
+
+def calcCubicBounds(pt1, pt2, pt3, pt4):
+    """Calculates the bounding rectangle for a quadratic Bezier segment.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
+
+    Returns:
+        A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``.
+
+    Example::
+
+        >>> calcCubicBounds((0, 0), (25, 100), (75, 100), (100, 0))
+        (0, 0, 100, 75.0)
+        >>> calcCubicBounds((0, 0), (50, 0), (100, 50), (100, 100))
+        (0.0, 0.0, 100, 100)
+        >>> print("%f %f %f %f" % calcCubicBounds((50, 0), (0, 100), (100, 100), (50, 0)))
+        35.566243 0.000000 64.433757 75.000000
+    """
+    (ax, ay), (bx, by), (cx, cy), (dx, dy) = calcCubicParameters(pt1, pt2, pt3, pt4)
+    # calc first derivative
+    ax3 = ax * 3.0
+    ay3 = ay * 3.0
+    bx2 = bx * 2.0
+    by2 = by * 2.0
+    xRoots = [t for t in solveQuadratic(ax3, bx2, cx) if 0 <= t < 1]
+    yRoots = [t for t in solveQuadratic(ay3, by2, cy) if 0 <= t < 1]
+    roots = xRoots + yRoots
+
+    points = [
+        (
+            ax * t * t * t + bx * t * t + cx * t + dx,
+            ay * t * t * t + by * t * t + cy * t + dy,
+        )
+        for t in roots
+    ] + [pt1, pt4]
+    return calcBounds(points)
+
+
+def splitLine(pt1, pt2, where, isHorizontal):
+    """Split a line at a given coordinate.
+
+    Args:
+        pt1: Start point of line as 2D tuple.
+        pt2: End point of line as 2D tuple.
+        where: Position at which to split the line.
+        isHorizontal: Direction of the ray splitting the line. If true,
+            ``where`` is interpreted as a Y coordinate; if false, then
+            ``where`` is interpreted as an X coordinate.
+
+    Returns:
+        A list of two line segments (each line segment being two 2D tuples)
+        if the line was successfully split, or a list containing the original
+        line.
+
+    Example::
+
+        >>> printSegments(splitLine((0, 0), (100, 100), 50, True))
+        ((0, 0), (50, 50))
+        ((50, 50), (100, 100))
+        >>> printSegments(splitLine((0, 0), (100, 100), 100, True))
+        ((0, 0), (100, 100))
+        >>> printSegments(splitLine((0, 0), (100, 100), 0, True))
+        ((0, 0), (0, 0))
+        ((0, 0), (100, 100))
+        >>> printSegments(splitLine((0, 0), (100, 100), 0, False))
+        ((0, 0), (0, 0))
+        ((0, 0), (100, 100))
+        >>> printSegments(splitLine((100, 0), (0, 0), 50, False))
+        ((100, 0), (50, 0))
+        ((50, 0), (0, 0))
+        >>> printSegments(splitLine((0, 100), (0, 0), 50, True))
+        ((0, 100), (0, 50))
+        ((0, 50), (0, 0))
+    """
+    pt1x, pt1y = pt1
+    pt2x, pt2y = pt2
+
+    ax = pt2x - pt1x
+    ay = pt2y - pt1y
+
+    bx = pt1x
+    by = pt1y
+
+    a = (ax, ay)[isHorizontal]
+
+    if a == 0:
+        return [(pt1, pt2)]
+    t = (where - (bx, by)[isHorizontal]) / a
+    if 0 <= t < 1:
+        midPt = ax * t + bx, ay * t + by
+        return [(pt1, midPt), (midPt, pt2)]
+    else:
+        return [(pt1, pt2)]
+
+
+def splitQuadratic(pt1, pt2, pt3, where, isHorizontal):
+    """Split a quadratic Bezier curve at a given coordinate.
+
+    Args:
+        pt1,pt2,pt3: Control points of the Bezier as 2D tuples.
+        where: Position at which to split the curve.
+        isHorizontal: Direction of the ray splitting the curve. If true,
+            ``where`` is interpreted as a Y coordinate; if false, then
+            ``where`` is interpreted as an X coordinate.
+
+    Returns:
+        A list of two curve segments (each curve segment being three 2D tuples)
+        if the curve was successfully split, or a list containing the original
+        curve.
+
+    Example::
+
+        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 150, False))
+        ((0, 0), (50, 100), (100, 0))
+        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, False))
+        ((0, 0), (25, 50), (50, 50))
+        ((50, 50), (75, 50), (100, 0))
+        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, False))
+        ((0, 0), (12.5, 25), (25, 37.5))
+        ((25, 37.5), (62.5, 75), (100, 0))
+        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 25, True))
+        ((0, 0), (7.32233, 14.6447), (14.6447, 25))
+        ((14.6447, 25), (50, 75), (85.3553, 25))
+        ((85.3553, 25), (92.6777, 14.6447), (100, -7.10543e-15))
+        >>> # XXX I'm not at all sure if the following behavior is desirable:
+        >>> printSegments(splitQuadratic((0, 0), (50, 100), (100, 0), 50, True))
+        ((0, 0), (25, 50), (50, 50))
+        ((50, 50), (50, 50), (50, 50))
+        ((50, 50), (75, 50), (100, 0))
+    """
+    a, b, c = calcQuadraticParameters(pt1, pt2, pt3)
+    solutions = solveQuadratic(
+        a[isHorizontal], b[isHorizontal], c[isHorizontal] - where
+    )
+    solutions = sorted(t for t in solutions if 0 <= t < 1)
+    if not solutions:
+        return [(pt1, pt2, pt3)]
+    return _splitQuadraticAtT(a, b, c, *solutions)
+
+
+def splitCubic(pt1, pt2, pt3, pt4, where, isHorizontal):
+    """Split a cubic Bezier curve at a given coordinate.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
+        where: Position at which to split the curve.
+        isHorizontal: Direction of the ray splitting the curve. If true,
+            ``where`` is interpreted as a Y coordinate; if false, then
+            ``where`` is interpreted as an X coordinate.
+
+    Returns:
+        A list of two curve segments (each curve segment being four 2D tuples)
+        if the curve was successfully split, or a list containing the original
+        curve.
+
+    Example::
+
+        >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 150, False))
+        ((0, 0), (25, 100), (75, 100), (100, 0))
+        >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 50, False))
+        ((0, 0), (12.5, 50), (31.25, 75), (50, 75))
+        ((50, 75), (68.75, 75), (87.5, 50), (100, 0))
+        >>> printSegments(splitCubic((0, 0), (25, 100), (75, 100), (100, 0), 25, True))
+        ((0, 0), (2.29379, 9.17517), (4.79804, 17.5085), (7.47414, 25))
+        ((7.47414, 25), (31.2886, 91.6667), (68.7114, 91.6667), (92.5259, 25))
+        ((92.5259, 25), (95.202, 17.5085), (97.7062, 9.17517), (100, 1.77636e-15))
+    """
+    a, b, c, d = calcCubicParameters(pt1, pt2, pt3, pt4)
+    solutions = solveCubic(
+        a[isHorizontal], b[isHorizontal], c[isHorizontal], d[isHorizontal] - where
+    )
+    solutions = sorted(t for t in solutions if 0 <= t < 1)
+    if not solutions:
+        return [(pt1, pt2, pt3, pt4)]
+    return _splitCubicAtT(a, b, c, d, *solutions)
+
+
+def splitQuadraticAtT(pt1, pt2, pt3, *ts):
+    """Split a quadratic Bezier curve at one or more values of t.
+
+    Args:
+        pt1,pt2,pt3: Control points of the Bezier as 2D tuples.
+        *ts: Positions at which to split the curve.
+
+    Returns:
+        A list of curve segments (each curve segment being three 2D tuples).
+
+    Examples::
+
+        >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5))
+        ((0, 0), (25, 50), (50, 50))
+        ((50, 50), (75, 50), (100, 0))
+        >>> printSegments(splitQuadraticAtT((0, 0), (50, 100), (100, 0), 0.5, 0.75))
+        ((0, 0), (25, 50), (50, 50))
+        ((50, 50), (62.5, 50), (75, 37.5))
+        ((75, 37.5), (87.5, 25), (100, 0))
+    """
+    a, b, c = calcQuadraticParameters(pt1, pt2, pt3)
+    return _splitQuadraticAtT(a, b, c, *ts)
+
+
+def splitCubicAtT(pt1, pt2, pt3, pt4, *ts):
+    """Split a cubic Bezier curve at one or more values of t.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as 2D tuples.
+        *ts: Positions at which to split the curve.
+
+    Returns:
+        A list of curve segments (each curve segment being four 2D tuples).
+
+    Examples::
+
+        >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5))
+        ((0, 0), (12.5, 50), (31.25, 75), (50, 75))
+        ((50, 75), (68.75, 75), (87.5, 50), (100, 0))
+        >>> printSegments(splitCubicAtT((0, 0), (25, 100), (75, 100), (100, 0), 0.5, 0.75))
+        ((0, 0), (12.5, 50), (31.25, 75), (50, 75))
+        ((50, 75), (59.375, 75), (68.75, 68.75), (77.3438, 56.25))
+        ((77.3438, 56.25), (85.9375, 43.75), (93.75, 25), (100, 0))
+    """
+    a, b, c, d = calcCubicParameters(pt1, pt2, pt3, pt4)
+    return _splitCubicAtT(a, b, c, d, *ts)
+
+
+@cython.locals(
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    pt4=cython.complex,
+    a=cython.complex,
+    b=cython.complex,
+    c=cython.complex,
+    d=cython.complex,
+)
+def splitCubicAtTC(pt1, pt2, pt3, pt4, *ts):
+    """Split a cubic Bezier curve at one or more values of t.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers..
+        *ts: Positions at which to split the curve.
+
+    Yields:
+        Curve segments (each curve segment being four complex numbers).
+    """
+    a, b, c, d = calcCubicParametersC(pt1, pt2, pt3, pt4)
+    yield from _splitCubicAtTC(a, b, c, d, *ts)
+
+
+@cython.returns(cython.complex)
+@cython.locals(
+    t=cython.double,
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    pt4=cython.complex,
+    pointAtT=cython.complex,
+    off1=cython.complex,
+    off2=cython.complex,
+)
+@cython.locals(
+    t2=cython.double, _1_t=cython.double, _1_t_2=cython.double, _2_t_1_t=cython.double
+)
+def splitCubicIntoTwoAtTC(pt1, pt2, pt3, pt4, t):
+    """Split a cubic Bezier curve at t.
+
+    Args:
+        pt1,pt2,pt3,pt4: Control points of the Bezier as complex numbers.
+        t: Position at which to split the curve.
+
+    Returns:
+        A tuple of two curve segments (each curve segment being four complex numbers).
+    """
+    t2 = t * t
+    _1_t = 1 - t
+    _1_t_2 = _1_t * _1_t
+    _2_t_1_t = 2 * t * _1_t
+    pointAtT = (
+        _1_t_2 * _1_t * pt1 + 3 * (_1_t_2 * t * pt2 + _1_t * t2 * pt3) + t2 * t * pt4
+    )
+    off1 = _1_t_2 * pt1 + _2_t_1_t * pt2 + t2 * pt3
+    off2 = _1_t_2 * pt2 + _2_t_1_t * pt3 + t2 * pt4
+
+    pt2 = pt1 + (pt2 - pt1) * t
+    pt3 = pt4 + (pt3 - pt4) * _1_t
+
+    return ((pt1, pt2, off1, pointAtT), (pointAtT, off2, pt3, pt4))
+
+
+def _splitQuadraticAtT(a, b, c, *ts):
+    ts = list(ts)
+    segments = []
+    ts.insert(0, 0.0)
+    ts.append(1.0)
+    ax, ay = a
+    bx, by = b
+    cx, cy = c
+    for i in range(len(ts) - 1):
+        t1 = ts[i]
+        t2 = ts[i + 1]
+        delta = t2 - t1
+        # calc new a, b and c
+        delta_2 = delta * delta
+        a1x = ax * delta_2
+        a1y = ay * delta_2
+        b1x = (2 * ax * t1 + bx) * delta
+        b1y = (2 * ay * t1 + by) * delta
+        t1_2 = t1 * t1
+        c1x = ax * t1_2 + bx * t1 + cx
+        c1y = ay * t1_2 + by * t1 + cy
+
+        pt1, pt2, pt3 = calcQuadraticPoints((a1x, a1y), (b1x, b1y), (c1x, c1y))
+        segments.append((pt1, pt2, pt3))
+    return segments
+
+
+def _splitCubicAtT(a, b, c, d, *ts):
+    ts = list(ts)
+    ts.insert(0, 0.0)
+    ts.append(1.0)
+    segments = []
+    ax, ay = a
+    bx, by = b
+    cx, cy = c
+    dx, dy = d
+    for i in range(len(ts) - 1):
+        t1 = ts[i]
+        t2 = ts[i + 1]
+        delta = t2 - t1
+
+        delta_2 = delta * delta
+        delta_3 = delta * delta_2
+        t1_2 = t1 * t1
+        t1_3 = t1 * t1_2
+
+        # calc new a, b, c and d
+        a1x = ax * delta_3
+        a1y = ay * delta_3
+        b1x = (3 * ax * t1 + bx) * delta_2
+        b1y = (3 * ay * t1 + by) * delta_2
+        c1x = (2 * bx * t1 + cx + 3 * ax * t1_2) * delta
+        c1y = (2 * by * t1 + cy + 3 * ay * t1_2) * delta
+        d1x = ax * t1_3 + bx * t1_2 + cx * t1 + dx
+        d1y = ay * t1_3 + by * t1_2 + cy * t1 + dy
+        pt1, pt2, pt3, pt4 = calcCubicPoints(
+            (a1x, a1y), (b1x, b1y), (c1x, c1y), (d1x, d1y)
+        )
+        segments.append((pt1, pt2, pt3, pt4))
+    return segments
+
+
+@cython.locals(
+    a=cython.complex,
+    b=cython.complex,
+    c=cython.complex,
+    d=cython.complex,
+    t1=cython.double,
+    t2=cython.double,
+    delta=cython.double,
+    delta_2=cython.double,
+    delta_3=cython.double,
+    a1=cython.complex,
+    b1=cython.complex,
+    c1=cython.complex,
+    d1=cython.complex,
+)
+def _splitCubicAtTC(a, b, c, d, *ts):
+    ts = list(ts)
+    ts.insert(0, 0.0)
+    ts.append(1.0)
+    for i in range(len(ts) - 1):
+        t1 = ts[i]
+        t2 = ts[i + 1]
+        delta = t2 - t1
+
+        delta_2 = delta * delta
+        delta_3 = delta * delta_2
+        t1_2 = t1 * t1
+        t1_3 = t1 * t1_2
+
+        # 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) * delta
+        d1 = a * t1_3 + b * t1_2 + c * t1 + d
+        pt1, pt2, pt3, pt4 = calcCubicPointsC(a1, b1, c1, d1)
+        yield (pt1, pt2, pt3, pt4)
+
+
+#
+# Equation solvers.
+#
+
+from math import sqrt, acos, cos, pi
+
+
+def solveQuadratic(a, b, c, sqrt=sqrt):
+    """Solve a quadratic equation.
+
+    Solves *a*x*x + b*x + c = 0* where a, b and c are real.
+
+    Args:
+        a: coefficient of *x²*
+        b: coefficient of *x*
+        c: constant term
+
+    Returns:
+        A list of roots. Note that the returned list is neither guaranteed to
+        be sorted nor to contain unique values!
+    """
+    if abs(a) < epsilon:
+        if abs(b) < epsilon:
+            # We have a non-equation; therefore, we have no valid solution
+            roots = []
+        else:
+            # We have a linear equation with 1 root.
+            roots = [-c / b]
+    else:
+        # We have a true quadratic equation.  Apply the quadratic formula to find two roots.
+        DD = b * b - 4.0 * a * c
+        if DD >= 0.0:
+            rDD = sqrt(DD)
+            roots = [(-b + rDD) / 2.0 / a, (-b - rDD) / 2.0 / a]
+        else:
+            # complex roots, ignore
+            roots = []
+    return roots
+
+
+def solveCubic(a, b, c, d):
+    """Solve a cubic equation.
+
+    Solves *a*x*x*x + b*x*x + c*x + d = 0* where a, b, c and d are real.
+
+    Args:
+        a: coefficient of *x³*
+        b: coefficient of *x²*
+        c: coefficient of *x*
+        d: constant term
+
+    Returns:
+        A list of roots. Note that the returned list is neither guaranteed to
+        be sorted nor to contain unique values!
+
+    Examples::
+
+        >>> solveCubic(1, 1, -6, 0)
+        [-3.0, -0.0, 2.0]
+        >>> solveCubic(-10.0, -9.0, 48.0, -29.0)
+        [-2.9, 1.0, 1.0]
+        >>> solveCubic(-9.875, -9.0, 47.625, -28.75)
+        [-2.911392, 1.0, 1.0]
+        >>> solveCubic(1.0, -4.5, 6.75, -3.375)
+        [1.5, 1.5, 1.5]
+        >>> solveCubic(-12.0, 18.0, -9.0, 1.50023651123)
+        [0.5, 0.5, 0.5]
+        >>> solveCubic(
+        ...     9.0, 0.0, 0.0, -7.62939453125e-05
+        ... ) == [-0.0, -0.0, -0.0]
+        True
+    """
+    #
+    # adapted from:
+    #   CUBIC.C - Solve a cubic polynomial
+    #   public domain by Ross Cottrell
+    # found at: http://www.strangecreations.com/library/snippets/Cubic.C
+    #
+    if abs(a) < epsilon:
+        # don't just test for zero; for very small values of 'a' solveCubic()
+        # returns unreliable results, so we fall back to quad.
+        return solveQuadratic(b, c, d)
+    a = float(a)
+    a1 = b / a
+    a2 = c / a
+    a3 = d / a
+
+    Q = (a1 * a1 - 3.0 * a2) / 9.0
+    R = (2.0 * a1 * a1 * a1 - 9.0 * a1 * a2 + 27.0 * a3) / 54.0
+
+    R2 = R * R
+    Q3 = Q * Q * Q
+    R2 = 0 if R2 < epsilon else R2
+    Q3 = 0 if abs(Q3) < epsilon else Q3
+
+    R2_Q3 = R2 - Q3
+
+    if R2 == 0.0 and Q3 == 0.0:
+        x = round(-a1 / 3.0, epsilonDigits)
+        return [x, x, x]
+    elif R2_Q3 <= epsilon * 0.5:
+        # The epsilon * .5 above ensures that Q3 is not zero.
+        theta = acos(max(min(R / sqrt(Q3), 1.0), -1.0))
+        rQ2 = -2.0 * sqrt(Q)
+        a1_3 = a1 / 3.0
+        x0 = rQ2 * cos(theta / 3.0) - a1_3
+        x1 = rQ2 * cos((theta + 2.0 * pi) / 3.0) - a1_3
+        x2 = rQ2 * cos((theta + 4.0 * pi) / 3.0) - a1_3
+        x0, x1, x2 = sorted([x0, x1, x2])
+        # Merge roots that are close-enough
+        if x1 - x0 < epsilon and x2 - x1 < epsilon:
+            x0 = x1 = x2 = round((x0 + x1 + x2) / 3.0, epsilonDigits)
+        elif x1 - x0 < epsilon:
+            x0 = x1 = round((x0 + x1) / 2.0, epsilonDigits)
+            x2 = round(x2, epsilonDigits)
+        elif x2 - x1 < epsilon:
+            x0 = round(x0, epsilonDigits)
+            x1 = x2 = round((x1 + x2) / 2.0, epsilonDigits)
+        else:
+            x0 = round(x0, epsilonDigits)
+            x1 = round(x1, epsilonDigits)
+            x2 = round(x2, epsilonDigits)
+        return [x0, x1, x2]
+    else:
+        x = pow(sqrt(R2_Q3) + abs(R), 1 / 3.0)
+        x = x + Q / x
+        if R >= 0.0:
+            x = -x
+        x = round(x - a1 / 3.0, epsilonDigits)
+        return [x]
+
+
+#
+# Conversion routines for points to parameters and vice versa
+#
+
+
+def calcQuadraticParameters(pt1, pt2, pt3):
+    x2, y2 = pt2
+    x3, y3 = pt3
+    cx, cy = pt1
+    bx = (x2 - cx) * 2.0
+    by = (y2 - cy) * 2.0
+    ax = x3 - cx - bx
+    ay = y3 - cy - by
+    return (ax, ay), (bx, by), (cx, cy)
+
+
+def calcCubicParameters(pt1, pt2, pt3, pt4):
+    x2, y2 = pt2
+    x3, y3 = pt3
+    x4, y4 = pt4
+    dx, dy = pt1
+    cx = (x2 - dx) * 3.0
+    cy = (y2 - dy) * 3.0
+    bx = (x3 - x2) * 3.0 - cx
+    by = (y3 - y2) * 3.0 - cy
+    ax = x4 - dx - cx - bx
+    ay = y4 - dy - cy - by
+    return (ax, ay), (bx, by), (cx, cy), (dx, dy)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    pt4=cython.complex,
+    a=cython.complex,
+    b=cython.complex,
+    c=cython.complex,
+)
+def calcCubicParametersC(pt1, pt2, pt3, pt4):
+    c = (pt2 - pt1) * 3.0
+    b = (pt3 - pt2) * 3.0 - c
+    a = pt4 - pt1 - c - b
+    return (a, b, c, pt1)
+
+
+def calcQuadraticPoints(a, b, c):
+    ax, ay = a
+    bx, by = b
+    cx, cy = c
+    x1 = cx
+    y1 = cy
+    x2 = (bx * 0.5) + cx
+    y2 = (by * 0.5) + cy
+    x3 = ax + bx + cx
+    y3 = ay + by + cy
+    return (x1, y1), (x2, y2), (x3, y3)
+
+
+def calcCubicPoints(a, b, c, d):
+    ax, ay = a
+    bx, by = b
+    cx, cy = c
+    dx, dy = d
+    x1 = dx
+    y1 = dy
+    x2 = (cx / 3.0) + dx
+    y2 = (cy / 3.0) + dy
+    x3 = (bx + cx) / 3.0 + x2
+    y3 = (by + cy) / 3.0 + y2
+    x4 = ax + dx + cx + bx
+    y4 = ay + dy + cy + by
+    return (x1, y1), (x2, y2), (x3, y3), (x4, y4)
+
+
+@cython.cfunc
+@cython.inline
+@cython.locals(
+    a=cython.complex,
+    b=cython.complex,
+    c=cython.complex,
+    d=cython.complex,
+    p2=cython.complex,
+    p3=cython.complex,
+    p4=cython.complex,
+)
+def calcCubicPointsC(a, b, c, d):
+    p2 = c * (1 / 3) + d
+    p3 = (b + c) * (1 / 3) + p2
+    p4 = a + b + c + d
+    return (d, p2, p3, p4)
+
+
+#
+# Point at time
+#
+
+
+def linePointAtT(pt1, pt2, t):
+    """Finds the point at time `t` on a line.
+
+    Args:
+        pt1, pt2: Coordinates of the line as 2D tuples.
+        t: The time along the line.
+
+    Returns:
+        A 2D tuple with the coordinates of the point.
+    """
+    return ((pt1[0] * (1 - t) + pt2[0] * t), (pt1[1] * (1 - t) + pt2[1] * t))
+
+
+def quadraticPointAtT(pt1, pt2, pt3, t):
+    """Finds the point at time `t` on a quadratic curve.
+
+    Args:
+        pt1, pt2, pt3: Coordinates of the curve as 2D tuples.
+        t: The time along the curve.
+
+    Returns:
+        A 2D tuple with the coordinates of the point.
+    """
+    x = (1 - t) * (1 - t) * pt1[0] + 2 * (1 - t) * t * pt2[0] + t * t * pt3[0]
+    y = (1 - t) * (1 - t) * pt1[1] + 2 * (1 - t) * t * pt2[1] + t * t * pt3[1]
+    return (x, y)
+
+
+def cubicPointAtT(pt1, pt2, pt3, pt4, t):
+    """Finds the point at time `t` on a cubic curve.
+
+    Args:
+        pt1, pt2, pt3, pt4: Coordinates of the curve as 2D tuples.
+        t: The time along the curve.
+
+    Returns:
+        A 2D tuple with the coordinates of the point.
+    """
+    t2 = t * t
+    _1_t = 1 - t
+    _1_t_2 = _1_t * _1_t
+    x = (
+        _1_t_2 * _1_t * pt1[0]
+        + 3 * (_1_t_2 * t * pt2[0] + _1_t * t2 * pt3[0])
+        + t2 * t * pt4[0]
+    )
+    y = (
+        _1_t_2 * _1_t * pt1[1]
+        + 3 * (_1_t_2 * t * pt2[1] + _1_t * t2 * pt3[1])
+        + t2 * t * pt4[1]
+    )
+    return (x, y)
+
+
+@cython.returns(cython.complex)
+@cython.locals(
+    t=cython.double,
+    pt1=cython.complex,
+    pt2=cython.complex,
+    pt3=cython.complex,
+    pt4=cython.complex,
+)
+@cython.locals(t2=cython.double, _1_t=cython.double, _1_t_2=cython.double)
+def cubicPointAtTC(pt1, pt2, pt3, pt4, t):
+    """Finds the point at time `t` on a cubic curve.
+
+    Args:
+        pt1, pt2, pt3, pt4: Coordinates of the curve as complex numbers.
+        t: The time along the curve.
+
+    Returns:
+        A complex number with the coordinates of the point.
+    """
+    t2 = t * t
+    _1_t = 1 - t
+    _1_t_2 = _1_t * _1_t
+    return _1_t_2 * _1_t * pt1 + 3 * (_1_t_2 * t * pt2 + _1_t * t2 * pt3) + t2 * t * pt4
+
+
+def segmentPointAtT(seg, t):
+    if len(seg) == 2:
+        return linePointAtT(*seg, t)
+    elif len(seg) == 3:
+        return quadraticPointAtT(*seg, t)
+    elif len(seg) == 4:
+        return cubicPointAtT(*seg, t)
+    raise ValueError("Unknown curve degree")
+
+
+#
+# Intersection finders
+#
+
+
+def _line_t_of_pt(s, e, pt):
+    sx, sy = s
+    ex, ey = e
+    px, py = pt
+    if abs(sx - ex) < epsilon and abs(sy - ey) < epsilon:
+        # Line is a point!
+        return -1
+    # Use the largest
+    if abs(sx - ex) > abs(sy - ey):
+        return (px - sx) / (ex - sx)
+    else:
+        return (py - sy) / (ey - sy)
+
+
+def _both_points_are_on_same_side_of_origin(a, b, origin):
+    xDiff = (a[0] - origin[0]) * (b[0] - origin[0])
+    yDiff = (a[1] - origin[1]) * (b[1] - origin[1])
+    return not (xDiff <= 0.0 and yDiff <= 0.0)
+
+
+def lineLineIntersections(s1, e1, s2, e2):
+    """Finds intersections between two line segments.
+
+    Args:
+        s1, e1: Coordinates of the first line as 2D tuples.
+        s2, e2: Coordinates of the second line as 2D tuples.
+
+    Returns:
+        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
+        and ``t2`` attributes containing the intersection point, time on first
+        segment and time on second segment respectively.
+
+    Examples::
+
+        >>> a = lineLineIntersections( (310,389), (453, 222), (289, 251), (447, 367))
+        >>> len(a)
+        1
+        >>> intersection = a[0]
+        >>> intersection.pt
+        (374.44882952482897, 313.73458370177315)
+        >>> (intersection.t1, intersection.t2)
+        (0.45069111555824465, 0.5408153767394238)
+    """
+    s1x, s1y = s1
+    e1x, e1y = e1
+    s2x, s2y = s2
+    e2x, e2y = e2
+    if (
+        math.isclose(s2x, e2x) and math.isclose(s1x, e1x) and not math.isclose(s1x, s2x)
+    ):  # Parallel vertical
+        return []
+    if (
+        math.isclose(s2y, e2y) and math.isclose(s1y, e1y) and not math.isclose(s1y, s2y)
+    ):  # Parallel horizontal
+        return []
+    if math.isclose(s2x, e2x) and math.isclose(s2y, e2y):  # Line segment is tiny
+        return []
+    if math.isclose(s1x, e1x) and math.isclose(s1y, e1y):  # Line segment is tiny
+        return []
+    if math.isclose(e1x, s1x):
+        x = s1x
+        slope34 = (e2y - s2y) / (e2x - s2x)
+        y = slope34 * (x - s2x) + s2y
+        pt = (x, y)
+        return [
+            Intersection(
+                pt=pt, t1=_line_t_of_pt(s1, e1, pt), t2=_line_t_of_pt(s2, e2, pt)
+            )
+        ]
+    if math.isclose(s2x, e2x):
+        x = s2x
+        slope12 = (e1y - s1y) / (e1x - s1x)
+        y = slope12 * (x - s1x) + s1y
+        pt = (x, y)
+        return [
+            Intersection(
+                pt=pt, t1=_line_t_of_pt(s1, e1, pt), t2=_line_t_of_pt(s2, e2, pt)
+            )
+        ]
+
+    slope12 = (e1y - s1y) / (e1x - s1x)
+    slope34 = (e2y - s2y) / (e2x - s2x)
+    if math.isclose(slope12, slope34):
+        return []
+    x = (slope12 * s1x - s1y - slope34 * s2x + s2y) / (slope12 - slope34)
+    y = slope12 * (x - s1x) + s1y
+    pt = (x, y)
+    if _both_points_are_on_same_side_of_origin(
+        pt, e1, s1
+    ) and _both_points_are_on_same_side_of_origin(pt, s2, e2):
+        return [
+            Intersection(
+                pt=pt, t1=_line_t_of_pt(s1, e1, pt), t2=_line_t_of_pt(s2, e2, pt)
+            )
+        ]
+    return []
+
+
+def _alignment_transformation(segment):
+    # Returns a transformation which aligns a segment horizontally at the
+    # origin. Apply this transformation to curves and root-find to find
+    # intersections with the segment.
+    start = segment[0]
+    end = segment[-1]
+    angle = math.atan2(end[1] - start[1], end[0] - start[0])
+    return Identity.rotate(-angle).translate(-start[0], -start[1])
+
+
+def _curve_line_intersections_t(curve, line):
+    aligned_curve = _alignment_transformation(line).transformPoints(curve)
+    if len(curve) == 3:
+        a, b, c = calcQuadraticParameters(*aligned_curve)
+        intersections = solveQuadratic(a[1], b[1], c[1])
+    elif len(curve) == 4:
+        a, b, c, d = calcCubicParameters(*aligned_curve)
+        intersections = solveCubic(a[1], b[1], c[1], d[1])
+    else:
+        raise ValueError("Unknown curve degree")
+    return sorted(i for i in intersections if 0.0 <= i <= 1)
+
+
+def curveLineIntersections(curve, line):
+    """Finds intersections between a curve and a line.
+
+    Args:
+        curve: List of coordinates of the curve segment as 2D tuples.
+        line: List of coordinates of the line segment as 2D tuples.
+
+    Returns:
+        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
+        and ``t2`` attributes containing the intersection point, time on first
+        segment and time on second segment respectively.
+
+    Examples::
+        >>> curve = [ (100, 240), (30, 60), (210, 230), (160, 30) ]
+        >>> line  = [ (25, 260), (230, 20) ]
+        >>> intersections = curveLineIntersections(curve, line)
+        >>> len(intersections)
+        3
+        >>> intersections[0].pt
+        (84.9000930760723, 189.87306176459828)
+    """
+    if len(curve) == 3:
+        pointFinder = quadraticPointAtT
+    elif len(curve) == 4:
+        pointFinder = cubicPointAtT
+    else:
+        raise ValueError("Unknown curve degree")
+    intersections = []
+    for t in _curve_line_intersections_t(curve, line):
+        pt = pointFinder(*curve, t)
+        # Back-project the point onto the line, to avoid problems with
+        # numerical accuracy in the case of vertical and horizontal lines
+        line_t = _line_t_of_pt(*line, pt)
+        pt = linePointAtT(*line, line_t)
+        intersections.append(Intersection(pt=pt, t1=t, t2=line_t))
+    return intersections
+
+
+def _curve_bounds(c):
+    if len(c) == 3:
+        return calcQuadraticBounds(*c)
+    elif len(c) == 4:
+        return calcCubicBounds(*c)
+    raise ValueError("Unknown curve degree")
+
+
+def _split_segment_at_t(c, t):
+    if len(c) == 2:
+        s, e = c
+        midpoint = linePointAtT(s, e, t)
+        return [(s, midpoint), (midpoint, e)]
+    if len(c) == 3:
+        return splitQuadraticAtT(*c, t)
+    elif len(c) == 4:
+        return splitCubicAtT(*c, t)
+    raise ValueError("Unknown curve degree")
+
+
+def _curve_curve_intersections_t(
+    curve1, curve2, precision=1e-3, range1=None, range2=None
+):
+    bounds1 = _curve_bounds(curve1)
+    bounds2 = _curve_bounds(curve2)
+
+    if not range1:
+        range1 = (0.0, 1.0)
+    if not range2:
+        range2 = (0.0, 1.0)
+
+    # If bounds don't intersect, go home
+    intersects, _ = sectRect(bounds1, bounds2)
+    if not intersects:
+        return []
+
+    def midpoint(r):
+        return 0.5 * (r[0] + r[1])
+
+    # If they do overlap but they're tiny, approximate
+    if rectArea(bounds1) < precision and rectArea(bounds2) < precision:
+        return [(midpoint(range1), midpoint(range2))]
+
+    c11, c12 = _split_segment_at_t(curve1, 0.5)
+    c11_range = (range1[0], midpoint(range1))
+    c12_range = (midpoint(range1), range1[1])
+
+    c21, c22 = _split_segment_at_t(curve2, 0.5)
+    c21_range = (range2[0], midpoint(range2))
+    c22_range = (midpoint(range2), range2[1])
+
+    found = []
+    found.extend(
+        _curve_curve_intersections_t(
+            c11, c21, precision, range1=c11_range, range2=c21_range
+        )
+    )
+    found.extend(
+        _curve_curve_intersections_t(
+            c12, c21, precision, range1=c12_range, range2=c21_range
+        )
+    )
+    found.extend(
+        _curve_curve_intersections_t(
+            c11, c22, precision, range1=c11_range, range2=c22_range
+        )
+    )
+    found.extend(
+        _curve_curve_intersections_t(
+            c12, c22, precision, range1=c12_range, range2=c22_range
+        )
+    )
+
+    unique_key = lambda ts: (int(ts[0] / precision), int(ts[1] / precision))
+    seen = set()
+    unique_values = []
+
+    for ts in found:
+        key = unique_key(ts)
+        if key in seen:
+            continue
+        seen.add(key)
+        unique_values.append(ts)
+
+    return unique_values
+
+
+def _is_linelike(segment):
+    maybeline = _alignment_transformation(segment).transformPoints(segment)
+    return all(math.isclose(p[1], 0.0) for p in maybeline)
+
+
+def curveCurveIntersections(curve1, curve2):
+    """Finds intersections between a curve and a curve.
+
+    Args:
+        curve1: List of coordinates of the first curve segment as 2D tuples.
+        curve2: List of coordinates of the second curve segment as 2D tuples.
+
+    Returns:
+        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
+        and ``t2`` attributes containing the intersection point, time on first
+        segment and time on second segment respectively.
+
+    Examples::
+        >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ]
+        >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ]
+        >>> intersections = curveCurveIntersections(curve1, curve2)
+        >>> len(intersections)
+        3
+        >>> intersections[0].pt
+        (81.7831487395506, 109.88904552375288)
+    """
+    if _is_linelike(curve1):
+        line1 = curve1[0], curve1[-1]
+        if _is_linelike(curve2):
+            line2 = curve2[0], curve2[-1]
+            return lineLineIntersections(*line1, *line2)
+        else:
+            return curveLineIntersections(curve2, line1)
+    elif _is_linelike(curve2):
+        line2 = curve2[0], curve2[-1]
+        return curveLineIntersections(curve1, line2)
+
+    intersection_ts = _curve_curve_intersections_t(curve1, curve2)
+    return [
+        Intersection(pt=segmentPointAtT(curve1, ts[0]), t1=ts[0], t2=ts[1])
+        for ts in intersection_ts
+    ]
+
+
+def segmentSegmentIntersections(seg1, seg2):
+    """Finds intersections between two segments.
+
+    Args:
+        seg1: List of coordinates of the first segment as 2D tuples.
+        seg2: List of coordinates of the second segment as 2D tuples.
+
+    Returns:
+        A list of ``Intersection`` objects, each object having ``pt``, ``t1``
+        and ``t2`` attributes containing the intersection point, time on first
+        segment and time on second segment respectively.
+
+    Examples::
+        >>> curve1 = [ (10,100), (90,30), (40,140), (220,220) ]
+        >>> curve2 = [ (5,150), (180,20), (80,250), (210,190) ]
+        >>> intersections = segmentSegmentIntersections(curve1, curve2)
+        >>> len(intersections)
+        3
+        >>> intersections[0].pt
+        (81.7831487395506, 109.88904552375288)
+        >>> curve3 = [ (100, 240), (30, 60), (210, 230), (160, 30) ]
+        >>> line  = [ (25, 260), (230, 20) ]
+        >>> intersections = segmentSegmentIntersections(curve3, line)
+        >>> len(intersections)
+        3
+        >>> intersections[0].pt
+        (84.9000930760723, 189.87306176459828)
+
+    """
+    # Arrange by degree
+    swapped = False
+    if len(seg2) > len(seg1):
+        seg2, seg1 = seg1, seg2
+        swapped = True
+    if len(seg1) > 2:
+        if len(seg2) > 2:
+            intersections = curveCurveIntersections(seg1, seg2)
+        else:
+            intersections = curveLineIntersections(seg1, seg2)
+    elif len(seg1) == 2 and len(seg2) == 2:
+        intersections = lineLineIntersections(*seg1, *seg2)
+    else:
+        raise ValueError("Couldn't work out which intersection function to use")
+    if not swapped:
+        return intersections
+    return [Intersection(pt=i.pt, t1=i.t2, t2=i.t1) for i in intersections]
+
+
+def _segmentrepr(obj):
+    """
+    >>> _segmentrepr([1, [2, 3], [], [[2, [3, 4], [0.1, 2.2]]]])
+    '(1, (2, 3), (), ((2, (3, 4), (0.1, 2.2))))'
+    """
+    try:
+        it = iter(obj)
+    except TypeError:
+        return "%g" % obj
+    else:
+        return "(%s)" % ", ".join(_segmentrepr(x) for x in it)
+
+
+def printSegments(segments):
+    """Helper for the doctests, displaying each segment in a list of
+    segments on a single line as a tuple.
+    """
+    for segment in segments:
+        print(_segmentrepr(segment))
+
+
+if __name__ == "__main__":
+    import sys
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/classifyTools.py

@@ -0,0 +1,170 @@
+""" fontTools.misc.classifyTools.py -- tools for classifying things.
+"""
+
+
+class Classifier(object):
+    """
+    Main Classifier object, used to classify things into similar sets.
+    """
+
+    def __init__(self, sort=True):
+        self._things = set()  # set of all things known so far
+        self._sets = []  # list of class sets produced so far
+        self._mapping = {}  # map from things to their class set
+        self._dirty = False
+        self._sort = sort
+
+    def add(self, set_of_things):
+        """
+        Add a set to the classifier.  Any iterable is accepted.
+        """
+        if not set_of_things:
+            return
+
+        self._dirty = True
+
+        things, sets, mapping = self._things, self._sets, self._mapping
+
+        s = set(set_of_things)
+        intersection = s.intersection(things)  # existing things
+        s.difference_update(intersection)  # new things
+        difference = s
+        del s
+
+        # Add new class for new things
+        if difference:
+            things.update(difference)
+            sets.append(difference)
+            for thing in difference:
+                mapping[thing] = difference
+        del difference
+
+        while intersection:
+            # Take one item and process the old class it belongs to
+            old_class = mapping[next(iter(intersection))]
+            old_class_intersection = old_class.intersection(intersection)
+
+            # Update old class to remove items from new set
+            old_class.difference_update(old_class_intersection)
+
+            # Remove processed items from todo list
+            intersection.difference_update(old_class_intersection)
+
+            # Add new class for the intersection with old class
+            sets.append(old_class_intersection)
+            for thing in old_class_intersection:
+                mapping[thing] = old_class_intersection
+            del old_class_intersection
+
+    def update(self, list_of_sets):
+        """
+        Add a a list of sets to the classifier.  Any iterable of iterables is accepted.
+        """
+        for s in list_of_sets:
+            self.add(s)
+
+    def _process(self):
+        if not self._dirty:
+            return
+
+        # Do any deferred processing
+        sets = self._sets
+        self._sets = [s for s in sets if s]
+
+        if self._sort:
+            self._sets = sorted(self._sets, key=lambda s: (-len(s), sorted(s)))
+
+        self._dirty = False
+
+    # Output methods
+
+    def getThings(self):
+        """Returns the set of all things known so far.
+
+        The return value belongs to the Classifier object and should NOT
+        be modified while the classifier is still in use.
+        """
+        self._process()
+        return self._things
+
+    def getMapping(self):
+        """Returns the mapping from things to their class set.
+
+        The return value belongs to the Classifier object and should NOT
+        be modified while the classifier is still in use.
+        """
+        self._process()
+        return self._mapping
+
+    def getClasses(self):
+        """Returns the list of class sets.
+
+        The return value belongs to the Classifier object and should NOT
+        be modified while the classifier is still in use.
+        """
+        self._process()
+        return self._sets
+
+
+def classify(list_of_sets, sort=True):
+    """
+    Takes a iterable of iterables (list of sets from here on; but any
+    iterable works.), and returns the smallest list of sets such that
+    each set, is either a subset, or is disjoint from, each of the input
+    sets.
+
+    In other words, this function classifies all the things present in
+    any of the input sets, into similar classes, based on which sets
+    things are a member of.
+
+    If sort=True, return class sets are sorted by decreasing size and
+    their natural sort order within each class size.  Otherwise, class
+    sets are returned in the order that they were identified, which is
+    generally not significant.
+
+    >>> classify([]) == ([], {})
+    True
+    >>> classify([[]]) == ([], {})
+    True
+    >>> classify([[], []]) == ([], {})
+    True
+    >>> classify([[1]]) == ([{1}], {1: {1}})
+    True
+    >>> classify([[1,2]]) == ([{1, 2}], {1: {1, 2}, 2: {1, 2}})
+    True
+    >>> classify([[1],[2]]) == ([{1}, {2}], {1: {1}, 2: {2}})
+    True
+    >>> classify([[1,2],[2]]) == ([{1}, {2}], {1: {1}, 2: {2}})
+    True
+    >>> classify([[1,2],[2,4]]) == ([{1}, {2}, {4}], {1: {1}, 2: {2}, 4: {4}})
+    True
+    >>> classify([[1,2],[2,4,5]]) == (
+    ...     [{4, 5}, {1}, {2}], {1: {1}, 2: {2}, 4: {4, 5}, 5: {4, 5}})
+    True
+    >>> classify([[1,2],[2,4,5]], sort=False) == (
+    ...     [{1}, {4, 5}, {2}], {1: {1}, 2: {2}, 4: {4, 5}, 5: {4, 5}})
+    True
+    >>> classify([[1,2,9],[2,4,5]], sort=False) == (
+    ...     [{1, 9}, {4, 5}, {2}], {1: {1, 9}, 2: {2}, 4: {4, 5}, 5: {4, 5},
+    ...     9: {1, 9}})
+    True
+    >>> classify([[1,2,9,15],[2,4,5]], sort=False) == (
+    ...     [{1, 9, 15}, {4, 5}, {2}], {1: {1, 9, 15}, 2: {2}, 4: {4, 5},
+    ...     5: {4, 5}, 9: {1, 9, 15}, 15: {1, 9, 15}})
+    True
+    >>> classes, mapping = classify([[1,2,9,15],[2,4,5],[15,5]], sort=False)
+    >>> set([frozenset(c) for c in classes]) == set(
+    ...     [frozenset(s) for s in ({1, 9}, {4}, {2}, {5}, {15})])
+    True
+    >>> mapping == {1: {1, 9}, 2: {2}, 4: {4}, 5: {5}, 9: {1, 9}, 15: {15}}
+    True
+    """
+    classifier = Classifier(sort=sort)
+    classifier.update(list_of_sets)
+    return classifier.getClasses(), classifier.getMapping()
+
+
+if __name__ == "__main__":
+    import sys, doctest
+
+    sys.exit(doctest.testmod(optionflags=doctest.ELLIPSIS).failed)

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/configTools.py

@@ -0,0 +1,349 @@
+"""
+Code of the config system; not related to fontTools or fonts in particular.
+
+The options that are specific to fontTools are in :mod:`fontTools.config`.
+
+To create your own config system, you need to create an instance of
+:class:`Options`, and a subclass of :class:`AbstractConfig` with its
+``options`` class variable set to your instance of Options.
+
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Iterable,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Set,
+    Union,
+)
+
+
+log = logging.getLogger(__name__)
+
+__all__ = [
+    "AbstractConfig",
+    "ConfigAlreadyRegisteredError",
+    "ConfigError",
+    "ConfigUnknownOptionError",
+    "ConfigValueParsingError",
+    "ConfigValueValidationError",
+    "Option",
+    "Options",
+]
+
+
+class ConfigError(Exception):
+    """Base exception for the config module."""
+
+
+class ConfigAlreadyRegisteredError(ConfigError):
+    """Raised when a module tries to register a configuration option that
+    already exists.
+
+    Should not be raised too much really, only when developing new fontTools
+    modules.
+    """
+
+    def __init__(self, name):
+        super().__init__(f"Config option {name} is already registered.")
+
+
+class ConfigValueParsingError(ConfigError):
+    """Raised when a configuration value cannot be parsed."""
+
+    def __init__(self, name, value):
+        super().__init__(
+            f"Config option {name}: value cannot be parsed (given {repr(value)})"
+        )
+
+
+class ConfigValueValidationError(ConfigError):
+    """Raised when a configuration value cannot be validated."""
+
+    def __init__(self, name, value):
+        super().__init__(
+            f"Config option {name}: value is invalid (given {repr(value)})"
+        )
+
+
+class ConfigUnknownOptionError(ConfigError):
+    """Raised when a configuration option is unknown."""
+
+    def __init__(self, option_or_name):
+        name = (
+            f"'{option_or_name.name}' (id={id(option_or_name)})>"
+            if isinstance(option_or_name, Option)
+            else f"'{option_or_name}'"
+        )
+        super().__init__(f"Config option {name} is unknown")
+
+
+# eq=False because Options are unique, not fungible objects
+@dataclass(frozen=True, eq=False)
+class Option:
+    name: str
+    """Unique name identifying the option (e.g. package.module:MY_OPTION)."""
+    help: str
+    """Help text for this option."""
+    default: Any
+    """Default value for this option."""
+    parse: Callable[[str], Any]
+    """Turn input (e.g. string) into proper type. Only when reading from file."""
+    validate: Optional[Callable[[Any], bool]] = None
+    """Return true if the given value is an acceptable value."""
+
+    @staticmethod
+    def parse_optional_bool(v: str) -> Optional[bool]:
+        s = str(v).lower()
+        if s in {"0", "no", "false"}:
+            return False
+        if s in {"1", "yes", "true"}:
+            return True
+        if s in {"auto", "none"}:
+            return None
+        raise ValueError("invalid optional bool: {v!r}")
+
+    @staticmethod
+    def validate_optional_bool(v: Any) -> bool:
+        return v is None or isinstance(v, bool)
+
+
+class Options(Mapping):
+    """Registry of available options for a given config system.
+
+    Define new options using the :meth:`register()` method.
+
+    Access existing options using the Mapping interface.
+    """
+
+    __options: Dict[str, Option]
+
+    def __init__(self, other: "Options" = None) -> None:
+        self.__options = {}
+        if other is not None:
+            for option in other.values():
+                self.register_option(option)
+
+    def register(
+        self,
+        name: str,
+        help: str,
+        default: Any,
+        parse: Callable[[str], Any],
+        validate: Optional[Callable[[Any], bool]] = None,
+    ) -> Option:
+        """Create and register a new option."""
+        return self.register_option(Option(name, help, default, parse, validate))
+
+    def register_option(self, option: Option) -> Option:
+        """Register a new option."""
+        name = option.name
+        if name in self.__options:
+            raise ConfigAlreadyRegisteredError(name)
+        self.__options[name] = option
+        return option
+
+    def is_registered(self, option: Option) -> bool:
+        """Return True if the same option object is already registered."""
+        return self.__options.get(option.name) is option
+
+    def __getitem__(self, key: str) -> Option:
+        return self.__options.__getitem__(key)
+
+    def __iter__(self) -> Iterator[str]:
+        return self.__options.__iter__()
+
+    def __len__(self) -> int:
+        return self.__options.__len__()
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}({{\n"
+            + "".join(
+                f"    {k!r}: Option(default={v.default!r}, ...),\n"
+                for k, v in self.__options.items()
+            )
+            + "})"
+        )
+
+
+_USE_GLOBAL_DEFAULT = object()
+
+
+class AbstractConfig(MutableMapping):
+    """
+    Create a set of config values, optionally pre-filled with values from
+    the given dictionary or pre-existing config object.
+
+    The class implements the MutableMapping protocol keyed by option name (`str`).
+    For convenience its methods accept either Option or str as the key parameter.
+
+    .. seealso:: :meth:`set()`
+
+    This config class is abstract because it needs its ``options`` class
+    var to be set to an instance of :class:`Options` before it can be
+    instanciated and used.
+
+    .. code:: python
+
+        class MyConfig(AbstractConfig):
+            options = Options()
+
+        MyConfig.register_option( "test:option_name", "This is an option", 0, int, lambda v: isinstance(v, int))
+
+        cfg = MyConfig({"test:option_name": 10})
+
+    """
+
+    options: ClassVar[Options]
+
+    @classmethod
+    def register_option(
+        cls,
+        name: str,
+        help: str,
+        default: Any,
+        parse: Callable[[str], Any],
+        validate: Optional[Callable[[Any], bool]] = None,
+    ) -> Option:
+        """Register an available option in this config system."""
+        return cls.options.register(
+            name, help=help, default=default, parse=parse, validate=validate
+        )
+
+    _values: Dict[str, Any]
+
+    def __init__(
+        self,
+        values: Union[AbstractConfig, Dict[Union[Option, str], Any]] = {},
+        parse_values: bool = False,
+        skip_unknown: bool = False,
+    ):
+        self._values = {}
+        values_dict = values._values if isinstance(values, AbstractConfig) else values
+        for name, value in values_dict.items():
+            self.set(name, value, parse_values, skip_unknown)
+
+    def _resolve_option(self, option_or_name: Union[Option, str]) -> Option:
+        if isinstance(option_or_name, Option):
+            option = option_or_name
+            if not self.options.is_registered(option):
+                raise ConfigUnknownOptionError(option)
+            return option
+        elif isinstance(option_or_name, str):
+            name = option_or_name
+            try:
+                return self.options[name]
+            except KeyError:
+                raise ConfigUnknownOptionError(name)
+        else:
+            raise TypeError(
+                "expected Option or str, found "
+                f"{type(option_or_name).__name__}: {option_or_name!r}"
+            )
+
+    def set(
+        self,
+        option_or_name: Union[Option, str],
+        value: Any,
+        parse_values: bool = False,
+        skip_unknown: bool = False,
+    ):
+        """Set the value of an option.
+
+        Args:
+            * `option_or_name`: an `Option` object or its name (`str`).
+            * `value`: the value to be assigned to given option.
+            * `parse_values`: parse the configuration value from a string into
+                its proper type, as per its `Option` object. The default
+                behavior is to raise `ConfigValueValidationError` when the value
+                is not of the right type. Useful when reading options from a
+                file type that doesn't support as many types as Python.
+            * `skip_unknown`: skip unknown configuration options. The default
+                behaviour is to raise `ConfigUnknownOptionError`. Useful when
+                reading options from a configuration file that has extra entries
+                (e.g. for a later version of fontTools)
+        """
+        try:
+            option = self._resolve_option(option_or_name)
+        except ConfigUnknownOptionError as e:
+            if skip_unknown:
+                log.debug(str(e))
+                return
+            raise
+
+        # Can be useful if the values come from a source that doesn't have
+        # strict typing (.ini file? Terminal input?)
+        if parse_values:
+            try:
+                value = option.parse(value)
+            except Exception as e:
+                raise ConfigValueParsingError(option.name, value) from e
+
+        if option.validate is not None and not option.validate(value):
+            raise ConfigValueValidationError(option.name, value)
+
+        self._values[option.name] = value
+
+    def get(
+        self, option_or_name: Union[Option, str], default: Any = _USE_GLOBAL_DEFAULT
+    ) -> Any:
+        """
+        Get the value of an option. The value which is returned is the first
+        provided among:
+
+        1. a user-provided value in the options's ``self._values`` dict
+        2. a caller-provided default value to this method call
+        3. the global default for the option provided in ``fontTools.config``
+
+        This is to provide the ability to migrate progressively from config
+        options passed as arguments to fontTools APIs to config options read
+        from the current TTFont, e.g.
+
+        .. code:: python
+
+            def fontToolsAPI(font, some_option):
+                value = font.cfg.get("someLib.module:SOME_OPTION", some_option)
+                # use value
+
+        That way, the function will work the same for users of the API that
+        still pass the option to the function call, but will favour the new
+        config mechanism if the given font specifies a value for that option.
+        """
+        option = self._resolve_option(option_or_name)
+        if option.name in self._values:
+            return self._values[option.name]
+        if default is not _USE_GLOBAL_DEFAULT:
+            return default
+        return option.default
+
+    def copy(self):
+        return self.__class__(self._values)
+
+    def __getitem__(self, option_or_name: Union[Option, str]) -> Any:
+        return self.get(option_or_name)
+
+    def __setitem__(self, option_or_name: Union[Option, str], value: Any) -> None:
+        return self.set(option_or_name, value)
+
+    def __delitem__(self, option_or_name: Union[Option, str]) -> None:
+        option = self._resolve_option(option_or_name)
+        del self._values[option.name]
+
+    def __iter__(self) -> Iterable[str]:
+        return self._values.__iter__()
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({repr(self._values)})"

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/encodingTools.py

@@ -0,0 +1,72 @@
+"""fontTools.misc.encodingTools.py -- tools for working with OpenType encodings.
+"""
+
+import fontTools.encodings.codecs
+
+# Map keyed by platformID, then platEncID, then possibly langID
+_encodingMap = {
+    0: {  # Unicode
+        0: "utf_16_be",
+        1: "utf_16_be",
+        2: "utf_16_be",
+        3: "utf_16_be",
+        4: "utf_16_be",
+        5: "utf_16_be",
+        6: "utf_16_be",
+    },
+    1: {  # Macintosh
+        # See
+        # https://github.com/fonttools/fonttools/issues/236
+        0: {  # Macintosh, platEncID==0, keyed by langID
+            15: "mac_iceland",
+            17: "mac_turkish",
+            18: "mac_croatian",
+            24: "mac_latin2",
+            25: "mac_latin2",
+            26: "mac_latin2",
+            27: "mac_latin2",
+            28: "mac_latin2",
+            36: "mac_latin2",
+            37: "mac_romanian",
+            38: "mac_latin2",
+            39: "mac_latin2",
+            40: "mac_latin2",
+            Ellipsis: "mac_roman",  # Other
+        },
+        1: "x_mac_japanese_ttx",
+        2: "x_mac_trad_chinese_ttx",
+        3: "x_mac_korean_ttx",
+        6: "mac_greek",
+        7: "mac_cyrillic",
+        25: "x_mac_simp_chinese_ttx",
+        29: "mac_latin2",
+        35: "mac_turkish",
+        37: "mac_iceland",
+    },
+    2: {  # ISO
+        0: "ascii",
+        1: "utf_16_be",
+        2: "latin1",
+    },
+    3: {  # Microsoft
+        0: "utf_16_be",
+        1: "utf_16_be",
+        2: "shift_jis",
+        3: "gb2312",
+        4: "big5",
+        5: "euc_kr",
+        6: "johab",
+        10: "utf_16_be",
+    },
+}
+
+
+def getEncoding(platformID, platEncID, langID, default=None):
+    """Returns the Python encoding name for OpenType platformID/encodingID/langID
+    triplet.  If encoding for these values is not known, by default None is
+    returned.  That can be overriden by passing a value to the default argument.
+    """
+    encoding = _encodingMap.get(platformID, {}).get(platEncID, default)
+    if isinstance(encoding, dict):
+        encoding = encoding.get(langID, encoding[Ellipsis])
+    return encoding

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/etree.py

@@ -0,0 +1,479 @@
+"""Shim module exporting the same ElementTree API for lxml and
+xml.etree backends.
+
+When lxml is installed, it is automatically preferred over the built-in
+xml.etree module.
+On Python 2.7, the cElementTree module is preferred over the pure-python
+ElementTree module.
+
+Besides exporting a unified interface, this also defines extra functions
+or subclasses built-in ElementTree classes to add features that are
+only availble in lxml, like OrderedDict for attributes, pretty_print and
+iterwalk.
+"""
+
+from fontTools.misc.textTools import tostr
+
+
+XML_DECLARATION = """<?xml version='1.0' encoding='%s'?>"""
+
+__all__ = [
+    # public symbols
+    "Comment",
+    "dump",
+    "Element",
+    "ElementTree",
+    "fromstring",
+    "fromstringlist",
+    "iselement",
+    "iterparse",
+    "parse",
+    "ParseError",
+    "PI",
+    "ProcessingInstruction",
+    "QName",
+    "SubElement",
+    "tostring",
+    "tostringlist",
+    "TreeBuilder",
+    "XML",
+    "XMLParser",
+    "register_namespace",
+]
+
+try:
+    from lxml.etree import *
+
+    _have_lxml = True
+except ImportError:
+    try:
+        from xml.etree.cElementTree import *
+
+        # the cElementTree version of XML function doesn't support
+        # the optional 'parser' keyword argument
+        from xml.etree.ElementTree import XML
+    except ImportError:  # pragma: no cover
+        from xml.etree.ElementTree import *
+    _have_lxml = False
+
+    import sys
+
+    # dict is always ordered in python >= 3.6 and on pypy
+    PY36 = sys.version_info >= (3, 6)
+    try:
+        import __pypy__
+    except ImportError:
+        __pypy__ = None
+    _dict_is_ordered = bool(PY36 or __pypy__)
+    del PY36, __pypy__
+
+    if _dict_is_ordered:
+        _Attrib = dict
+    else:
+        from collections import OrderedDict as _Attrib
+
+    if isinstance(Element, type):
+        _Element = Element
+    else:
+        # in py27, cElementTree.Element cannot be subclassed, so
+        # we need to import the pure-python class
+        from xml.etree.ElementTree import Element as _Element
+
+    class Element(_Element):
+        """Element subclass that keeps the order of attributes."""
+
+        def __init__(self, tag, attrib=_Attrib(), **extra):
+            super(Element, self).__init__(tag)
+            self.attrib = _Attrib()
+            if attrib:
+                self.attrib.update(attrib)
+            if extra:
+                self.attrib.update(extra)
+
+    def SubElement(parent, tag, attrib=_Attrib(), **extra):
+        """Must override SubElement as well otherwise _elementtree.SubElement
+        fails if 'parent' is a subclass of Element object.
+        """
+        element = parent.__class__(tag, attrib, **extra)
+        parent.append(element)
+        return element
+
+    def _iterwalk(element, events, tag):
+        include = tag is None or element.tag == tag
+        if include and "start" in events:
+            yield ("start", element)
+        for e in element:
+            for item in _iterwalk(e, events, tag):
+                yield item
+        if include:
+            yield ("end", element)
+
+    def iterwalk(element_or_tree, events=("end",), tag=None):
+        """A tree walker that generates events from an existing tree as
+        if it was parsing XML data with iterparse().
+        Drop-in replacement for lxml.etree.iterwalk.
+        """
+        if iselement(element_or_tree):
+            element = element_or_tree
+        else:
+            element = element_or_tree.getroot()
+        if tag == "*":
+            tag = None
+        for item in _iterwalk(element, events, tag):
+            yield item
+
+    _ElementTree = ElementTree
+
+    class ElementTree(_ElementTree):
+        """ElementTree subclass that adds 'pretty_print' and 'doctype'
+        arguments to the 'write' method.
+        Currently these are only supported for the default XML serialization
+        'method', and not also for "html" or "text", for these are delegated
+        to the base class.
+        """
+
+        def write(
+            self,
+            file_or_filename,
+            encoding=None,
+            xml_declaration=False,
+            method=None,
+            doctype=None,
+            pretty_print=False,
+        ):
+            if method and method != "xml":
+                # delegate to super-class
+                super(ElementTree, self).write(
+                    file_or_filename,
+                    encoding=encoding,
+                    xml_declaration=xml_declaration,
+                    method=method,
+                )
+                return
+
+            if encoding is not None and encoding.lower() == "unicode":
+                if xml_declaration:
+                    raise ValueError(
+                        "Serialisation to unicode must not request an XML declaration"
+                    )
+                write_declaration = False
+                encoding = "unicode"
+            elif xml_declaration is None:
+                # by default, write an XML declaration only for non-standard encodings
+                write_declaration = encoding is not None and encoding.upper() not in (
+                    "ASCII",
+                    "UTF-8",
+                    "UTF8",
+                    "US-ASCII",
+                )
+            else:
+                write_declaration = xml_declaration
+
+            if encoding is None:
+                encoding = "ASCII"
+
+            if pretty_print:
+                # NOTE this will modify the tree in-place
+                _indent(self._root)
+
+            with _get_writer(file_or_filename, encoding) as write:
+                if write_declaration:
+                    write(XML_DECLARATION % encoding.upper())
+                    if pretty_print:
+                        write("\n")
+                if doctype:
+                    write(_tounicode(doctype))
+                    if pretty_print:
+                        write("\n")
+
+                qnames, namespaces = _namespaces(self._root)
+                _serialize_xml(write, self._root, qnames, namespaces)
+
+    import io
+
+    def tostring(
+        element,
+        encoding=None,
+        xml_declaration=None,
+        method=None,
+        doctype=None,
+        pretty_print=False,
+    ):
+        """Custom 'tostring' function that uses our ElementTree subclass, with
+        pretty_print support.
+        """
+        stream = io.StringIO() if encoding == "unicode" else io.BytesIO()
+        ElementTree(element).write(
+            stream,
+            encoding=encoding,
+            xml_declaration=xml_declaration,
+            method=method,
+            doctype=doctype,
+            pretty_print=pretty_print,
+        )
+        return stream.getvalue()
+
+    # serialization support
+
+    import re
+
+    # Valid XML strings can include any Unicode character, excluding control
+    # characters, the surrogate blocks, FFFE, and FFFF:
+    #   Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+    # Here we reversed the pattern to match only the invalid characters.
+    # For the 'narrow' python builds supporting only UCS-2, which represent
+    # characters beyond BMP as UTF-16 surrogate pairs, we need to pass through
+    # the surrogate block. I haven't found a more elegant solution...
+    UCS2 = sys.maxunicode < 0x10FFFF
+    if UCS2:
+        _invalid_xml_string = re.compile(
+            "[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uFFFE-\uFFFF]"
+        )
+    else:
+        _invalid_xml_string = re.compile(
+            "[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]"
+        )
+
+    def _tounicode(s):
+        """Test if a string is valid user input and decode it to unicode string
+        using ASCII encoding if it's a bytes string.
+        Reject all bytes/unicode input that contains non-XML characters.
+        Reject all bytes input that contains non-ASCII characters.
+        """
+        try:
+            s = tostr(s, encoding="ascii", errors="strict")
+        except UnicodeDecodeError:
+            raise ValueError(
+                "Bytes strings can only contain ASCII characters. "
+                "Use unicode strings for non-ASCII characters."
+            )
+        except AttributeError:
+            _raise_serialization_error(s)
+        if s and _invalid_xml_string.search(s):
+            raise ValueError(
+                "All strings must be XML compatible: Unicode or ASCII, "
+                "no NULL bytes or control characters"
+            )
+        return s
+
+    import contextlib
+
+    @contextlib.contextmanager
+    def _get_writer(file_or_filename, encoding):
+        # returns text write method and release all resources after using
+        try:
+            write = file_or_filename.write
+        except AttributeError:
+            # file_or_filename is a file name
+            f = open(
+                file_or_filename,
+                "w",
+                encoding="utf-8" if encoding == "unicode" else encoding,
+                errors="xmlcharrefreplace",
+            )
+            with f:
+                yield f.write
+        else:
+            # file_or_filename is a file-like object
+            # encoding determines if it is a text or binary writer
+            if encoding == "unicode":
+                # use a text writer as is
+                yield write
+            else:
+                # wrap a binary writer with TextIOWrapper
+                detach_buffer = False
+                if isinstance(file_or_filename, io.BufferedIOBase):
+                    buf = file_or_filename
+                elif isinstance(file_or_filename, io.RawIOBase):
+                    buf = io.BufferedWriter(file_or_filename)
+                    detach_buffer = True
+                else:
+                    # This is to handle passed objects that aren't in the
+                    # IOBase hierarchy, but just have a write method
+                    buf = io.BufferedIOBase()
+                    buf.writable = lambda: True
+                    buf.write = write
+                    try:
+                        # TextIOWrapper uses this methods to determine
+                        # if BOM (for UTF-16, etc) should be added
+                        buf.seekable = file_or_filename.seekable
+                        buf.tell = file_or_filename.tell
+                    except AttributeError:
+                        pass
+                wrapper = io.TextIOWrapper(
+                    buf,
+                    encoding=encoding,
+                    errors="xmlcharrefreplace",
+                    newline="\n",
+                )
+                try:
+                    yield wrapper.write
+                finally:
+                    # Keep the original file open when the TextIOWrapper and
+                    # the BufferedWriter are destroyed
+                    wrapper.detach()
+                    if detach_buffer:
+                        buf.detach()
+
+    from xml.etree.ElementTree import _namespace_map
+
+    def _namespaces(elem):
+        # identify namespaces used in this tree
+
+        # maps qnames to *encoded* prefix:local names
+        qnames = {None: None}
+
+        # maps uri:s to prefixes
+        namespaces = {}
+
+        def add_qname(qname):
+            # calculate serialized qname representation
+            try:
+                qname = _tounicode(qname)
+                if qname[:1] == "{":
+                    uri, tag = qname[1:].rsplit("}", 1)
+                    prefix = namespaces.get(uri)
+                    if prefix is None:
+                        prefix = _namespace_map.get(uri)
+                        if prefix is None:
+                            prefix = "ns%d" % len(namespaces)
+                        else:
+                            prefix = _tounicode(prefix)
+                        if prefix != "xml":
+                            namespaces[uri] = prefix
+                    if prefix:
+                        qnames[qname] = "%s:%s" % (prefix, tag)
+                    else:
+                        qnames[qname] = tag  # default element
+                else:
+                    qnames[qname] = qname
+            except TypeError:
+                _raise_serialization_error(qname)
+
+        # populate qname and namespaces table
+        for elem in elem.iter():
+            tag = elem.tag
+            if isinstance(tag, QName):
+                if tag.text not in qnames:
+                    add_qname(tag.text)
+            elif isinstance(tag, str):
+                if tag not in qnames:
+                    add_qname(tag)
+            elif tag is not None and tag is not Comment and tag is not PI:
+                _raise_serialization_error(tag)
+            for key, value in elem.items():
+                if isinstance(key, QName):
+                    key = key.text
+                if key not in qnames:
+                    add_qname(key)
+                if isinstance(value, QName) and value.text not in qnames:
+                    add_qname(value.text)
+            text = elem.text
+            if isinstance(text, QName) and text.text not in qnames:
+                add_qname(text.text)
+        return qnames, namespaces
+
+    def _serialize_xml(write, elem, qnames, namespaces, **kwargs):
+        tag = elem.tag
+        text = elem.text
+        if tag is Comment:
+            write("<!--%s-->" % _tounicode(text))
+        elif tag is ProcessingInstruction:
+            write("<?%s?>" % _tounicode(text))
+        else:
+            tag = qnames[_tounicode(tag) if tag is not None else None]
+            if tag is None:
+                if text:
+                    write(_escape_cdata(text))
+                for e in elem:
+                    _serialize_xml(write, e, qnames, None)
+            else:
+                write("<" + tag)
+                if namespaces:
+                    for uri, prefix in sorted(
+                        namespaces.items(), key=lambda x: x[1]
+                    ):  # sort on prefix
+                        if prefix:
+                            prefix = ":" + prefix
+                        write(' xmlns%s="%s"' % (prefix, _escape_attrib(uri)))
+                attrs = elem.attrib
+                if attrs:
+                    # try to keep existing attrib order
+                    if len(attrs) <= 1 or type(attrs) is _Attrib:
+                        items = attrs.items()
+                    else:
+                        # if plain dict, use lexical order
+                        items = sorted(attrs.items())
+                    for k, v in items:
+                        if isinstance(k, QName):
+                            k = _tounicode(k.text)
+                        else:
+                            k = _tounicode(k)
+                        if isinstance(v, QName):
+                            v = qnames[_tounicode(v.text)]
+                        else:
+                            v = _escape_attrib(v)
+                        write(' %s="%s"' % (qnames[k], v))
+                if text is not None or len(elem):
+                    write(">")
+                    if text:
+                        write(_escape_cdata(text))
+                    for e in elem:
+                        _serialize_xml(write, e, qnames, None)
+                    write("</" + tag + ">")
+                else:
+                    write("/>")
+        if elem.tail:
+            write(_escape_cdata(elem.tail))
+
+    def _raise_serialization_error(text):
+        raise TypeError("cannot serialize %r (type %s)" % (text, type(text).__name__))
+
+    def _escape_cdata(text):
+        # escape character data
+        try:
+            text = _tounicode(text)
+            # it's worth avoiding do-nothing calls for short strings
+            if "&" in text:
+                text = text.replace("&", "&amp;")
+            if "<" in text:
+                text = text.replace("<", "&lt;")
+            if ">" in text:
+                text = text.replace(">", "&gt;")
+            return text
+        except (TypeError, AttributeError):
+            _raise_serialization_error(text)
+
+    def _escape_attrib(text):
+        # escape attribute value
+        try:
+            text = _tounicode(text)
+            if "&" in text:
+                text = text.replace("&", "&amp;")
+            if "<" in text:
+                text = text.replace("<", "&lt;")
+            if ">" in text:
+                text = text.replace(">", "&gt;")
+            if '"' in text:
+                text = text.replace('"', "&quot;")
+            if "\n" in text:
+                text = text.replace("\n", "&#10;")
+            return text
+        except (TypeError, AttributeError):
+            _raise_serialization_error(text)
+
+    def _indent(elem, level=0):
+        # From http://effbot.org/zone/element-lib.htm#prettyprint
+        i = "\n" + level * "  "
+        if len(elem):
+            if not elem.text or not elem.text.strip():
+                elem.text = i + "  "
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+            for elem in elem:
+                _indent(elem, level + 1)
+            if not elem.tail or not elem.tail.strip():
+                elem.tail = i
+        else:
+            if level and (not elem.tail or not elem.tail.strip()):
+                elem.tail = i

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/filenames.py

@@ -0,0 +1,245 @@
+"""
+This module implements the algorithm for converting between a "user name" -
+something that a user can choose arbitrarily inside a font editor - and a file
+name suitable for use in a wide range of operating systems and filesystems.
+
+The `UFO 3 specification <http://unifiedfontobject.org/versions/ufo3/conventions/>`_
+provides an example of an algorithm for such conversion, which avoids illegal
+characters, reserved file names, ambiguity between upper- and lower-case
+characters, and clashes with existing files.
+
+This code was originally copied from
+`ufoLib <https://github.com/unified-font-object/ufoLib/blob/8747da7/Lib/ufoLib/filenames.py>`_
+by Tal Leming and is copyright (c) 2005-2016, The RoboFab Developers:
+
+-	Erik van Blokland
+-	Tal Leming
+-	Just van Rossum
+"""
+
+illegalCharacters = r"\" * + / : < > ? [ \ ] | \0".split(" ")
+illegalCharacters += [chr(i) for i in range(1, 32)]
+illegalCharacters += [chr(0x7F)]
+reservedFileNames = "CON PRN AUX CLOCK$ NUL A:-Z: COM1".lower().split(" ")
+reservedFileNames += "LPT1 LPT2 LPT3 COM2 COM3 COM4".lower().split(" ")
+maxFileNameLength = 255
+
+
+class NameTranslationError(Exception):
+    pass
+
+
+def userNameToFileName(userName, existing=[], prefix="", suffix=""):
+    """Converts from a user name to a file name.
+
+    Takes care to avoid illegal characters, reserved file names, ambiguity between
+    upper- and lower-case characters, and clashes with existing files.
+
+    Args:
+            userName (str): The input file name.
+            existing: A case-insensitive list of all existing file names.
+            prefix: Prefix to be prepended to the file name.
+            suffix: Suffix to be appended to the file name.
+
+    Returns:
+            A suitable filename.
+
+    Raises:
+            NameTranslationError: If no suitable name could be generated.
+
+    Examples::
+
+            >>> userNameToFileName("a") == "a"
+            True
+            >>> userNameToFileName("A") == "A_"
+            True
+            >>> userNameToFileName("AE") == "A_E_"
+            True
+            >>> userNameToFileName("Ae") == "A_e"
+            True
+            >>> userNameToFileName("ae") == "ae"
+            True
+            >>> userNameToFileName("aE") == "aE_"
+            True
+            >>> userNameToFileName("a.alt") == "a.alt"
+            True
+            >>> userNameToFileName("A.alt") == "A_.alt"
+            True
+            >>> userNameToFileName("A.Alt") == "A_.A_lt"
+            True
+            >>> userNameToFileName("A.aLt") == "A_.aL_t"
+            True
+            >>> userNameToFileName(u"A.alT") == "A_.alT_"
+            True
+            >>> userNameToFileName("T_H") == "T__H_"
+            True
+            >>> userNameToFileName("T_h") == "T__h"
+            True
+            >>> userNameToFileName("t_h") == "t_h"
+            True
+            >>> userNameToFileName("F_F_I") == "F__F__I_"
+            True
+            >>> userNameToFileName("f_f_i") == "f_f_i"
+            True
+            >>> userNameToFileName("Aacute_V.swash") == "A_acute_V_.swash"
+            True
+            >>> userNameToFileName(".notdef") == "_notdef"
+            True
+            >>> userNameToFileName("con") == "_con"
+            True
+            >>> userNameToFileName("CON") == "C_O_N_"
+            True
+            >>> userNameToFileName("con.alt") == "_con.alt"
+            True
+            >>> userNameToFileName("alt.con") == "alt._con"
+            True
+    """
+    # the incoming name must be a str
+    if not isinstance(userName, str):
+        raise ValueError("The value for userName must be a string.")
+    # establish the prefix and suffix lengths
+    prefixLength = len(prefix)
+    suffixLength = len(suffix)
+    # replace an initial period with an _
+    # if no prefix is to be added
+    if not prefix and userName[0] == ".":
+        userName = "_" + userName[1:]
+    # filter the user name
+    filteredUserName = []
+    for character in userName:
+        # replace illegal characters with _
+        if character in illegalCharacters:
+            character = "_"
+        # add _ to all non-lower characters
+        elif character != character.lower():
+            character += "_"
+        filteredUserName.append(character)
+    userName = "".join(filteredUserName)
+    # clip to 255
+    sliceLength = maxFileNameLength - prefixLength - suffixLength
+    userName = userName[:sliceLength]
+    # test for illegal files names
+    parts = []
+    for part in userName.split("."):
+        if part.lower() in reservedFileNames:
+            part = "_" + part
+        parts.append(part)
+    userName = ".".join(parts)
+    # test for clash
+    fullName = prefix + userName + suffix
+    if fullName.lower() in existing:
+        fullName = handleClash1(userName, existing, prefix, suffix)
+    # finished
+    return fullName
+
+
+def handleClash1(userName, existing=[], prefix="", suffix=""):
+    """
+    existing should be a case-insensitive list
+    of all existing file names.
+
+    >>> prefix = ("0" * 5) + "."
+    >>> suffix = "." + ("0" * 10)
+    >>> existing = ["a" * 5]
+
+    >>> e = list(existing)
+    >>> handleClash1(userName="A" * 5, existing=e,
+    ...		prefix=prefix, suffix=suffix) == (
+    ... 	'00000.AAAAA000000000000001.0000000000')
+    True
+
+    >>> e = list(existing)
+    >>> e.append(prefix + "aaaaa" + "1".zfill(15) + suffix)
+    >>> handleClash1(userName="A" * 5, existing=e,
+    ...		prefix=prefix, suffix=suffix) == (
+    ... 	'00000.AAAAA000000000000002.0000000000')
+    True
+
+    >>> e = list(existing)
+    >>> e.append(prefix + "AAAAA" + "2".zfill(15) + suffix)
+    >>> handleClash1(userName="A" * 5, existing=e,
+    ...		prefix=prefix, suffix=suffix) == (
+    ... 	'00000.AAAAA000000000000001.0000000000')
+    True
+    """
+    # if the prefix length + user name length + suffix length + 15 is at
+    # or past the maximum length, silce 15 characters off of the user name
+    prefixLength = len(prefix)
+    suffixLength = len(suffix)
+    if prefixLength + len(userName) + suffixLength + 15 > maxFileNameLength:
+        l = prefixLength + len(userName) + suffixLength + 15
+        sliceLength = maxFileNameLength - l
+        userName = userName[:sliceLength]
+    finalName = None
+    # try to add numbers to create a unique name
+    counter = 1
+    while finalName is None:
+        name = userName + str(counter).zfill(15)
+        fullName = prefix + name + suffix
+        if fullName.lower() not in existing:
+            finalName = fullName
+            break
+        else:
+            counter += 1
+        if counter >= 999999999999999:
+            break
+    # if there is a clash, go to the next fallback
+    if finalName is None:
+        finalName = handleClash2(existing, prefix, suffix)
+    # finished
+    return finalName
+
+
+def handleClash2(existing=[], prefix="", suffix=""):
+    """
+    existing should be a case-insensitive list
+    of all existing file names.
+
+    >>> prefix = ("0" * 5) + "."
+    >>> suffix = "." + ("0" * 10)
+    >>> existing = [prefix + str(i) + suffix for i in range(100)]
+
+    >>> e = list(existing)
+    >>> handleClash2(existing=e, prefix=prefix, suffix=suffix) == (
+    ... 	'00000.100.0000000000')
+    True
+
+    >>> e = list(existing)
+    >>> e.remove(prefix + "1" + suffix)
+    >>> handleClash2(existing=e, prefix=prefix, suffix=suffix) == (
+    ... 	'00000.1.0000000000')
+    True
+
+    >>> e = list(existing)
+    >>> e.remove(prefix + "2" + suffix)
+    >>> handleClash2(existing=e, prefix=prefix, suffix=suffix) == (
+    ... 	'00000.2.0000000000')
+    True
+    """
+    # calculate the longest possible string
+    maxLength = maxFileNameLength - len(prefix) - len(suffix)
+    maxValue = int("9" * maxLength)
+    # try to find a number
+    finalName = None
+    counter = 1
+    while finalName is None:
+        fullName = prefix + str(counter) + suffix
+        if fullName.lower() not in existing:
+            finalName = fullName
+            break
+        else:
+            counter += 1
+        if counter >= maxValue:
+            break
+    # raise an error if nothing has been found
+    if finalName is None:
+        raise NameTranslationError("No unique name could be found.")
+    # finished
+    return finalName
+
+
+if __name__ == "__main__":
+    import doctest
+    import sys
+
+    sys.exit(doctest.testmod().failed)

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/intTools.py

@@ -0,0 +1,25 @@
+__all__ = ["popCount", "bit_count", "bit_indices"]
+
+
+try:
+    bit_count = int.bit_count
+except AttributeError:
+
+    def bit_count(v):
+        return bin(v).count("1")
+
+
+"""Return number of 1 bits (population count) of the absolute value of an integer.
+
+See https://docs.python.org/3.10/library/stdtypes.html#int.bit_count
+"""
+popCount = bit_count  # alias
+
+
+def bit_indices(v):
+    """Return list of indices where bits are set, 0 being the index of the least significant bit.
+
+    >>> bit_indices(0b101)
+    [0, 2]
+    """
+    return [i for i, b in enumerate(bin(v)[::-1]) if b == "1"]

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/lazyTools.py

@@ -0,0 +1,42 @@
+from collections import UserDict, UserList
+
+__all__ = ["LazyDict", "LazyList"]
+
+
+class LazyDict(UserDict):
+    def __init__(self, data):
+        super().__init__()
+        self.data = data
+
+    def __getitem__(self, k):
+        v = self.data[k]
+        if callable(v):
+            v = v(k)
+            self.data[k] = v
+        return v
+
+
+class LazyList(UserList):
+    def __getitem__(self, k):
+        if isinstance(k, slice):
+            indices = range(*k.indices(len(self)))
+            return [self[i] for i in indices]
+        v = self.data[k]
+        if callable(v):
+            v = v(k)
+            self.data[k] = v
+        return v
+
+    def __add__(self, other):
+        if isinstance(other, LazyList):
+            other = list(other)
+        elif isinstance(other, list):
+            pass
+        else:
+            return NotImplemented
+        return list(self) + other
+
+    def __radd__(self, other):
+        if not isinstance(other, list):
+            return NotImplemented
+        return other + list(self)

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/psOperators.py

@@ -0,0 +1,572 @@
+_accessstrings = {0: "", 1: "readonly", 2: "executeonly", 3: "noaccess"}
+
+
+class ps_object(object):
+    literal = 1
+    access = 0
+    value = None
+
+    def __init__(self, value):
+        self.value = value
+        self.type = self.__class__.__name__[3:] + "type"
+
+    def __repr__(self):
+        return "<%s %s>" % (self.__class__.__name__[3:], repr(self.value))
+
+
+class ps_operator(ps_object):
+    literal = 0
+
+    def __init__(self, name, function):
+        self.name = name
+        self.function = function
+        self.type = self.__class__.__name__[3:] + "type"
+
+    def __repr__(self):
+        return "<operator %s>" % self.name
+
+
+class ps_procedure(ps_object):
+    literal = 0
+
+    def __repr__(self):
+        return "<procedure>"
+
+    def __str__(self):
+        psstring = "{"
+        for i in range(len(self.value)):
+            if i:
+                psstring = psstring + " " + str(self.value[i])
+            else:
+                psstring = psstring + str(self.value[i])
+        return psstring + "}"
+
+
+class ps_name(ps_object):
+    literal = 0
+
+    def __str__(self):
+        if self.literal:
+            return "/" + self.value
+        else:
+            return self.value
+
+
+class ps_literal(ps_object):
+    def __str__(self):
+        return "/" + self.value
+
+
+class ps_array(ps_object):
+    def __str__(self):
+        psstring = "["
+        for i in range(len(self.value)):
+            item = self.value[i]
+            access = _accessstrings[item.access]
+            if access:
+                access = " " + access
+            if i:
+                psstring = psstring + " " + str(item) + access
+            else:
+                psstring = psstring + str(item) + access
+        return psstring + "]"
+
+    def __repr__(self):
+        return "<array>"
+
+
+_type1_pre_eexec_order = [
+    "FontInfo",
+    "FontName",
+    "Encoding",
+    "PaintType",
+    "FontType",
+    "FontMatrix",
+    "FontBBox",
+    "UniqueID",
+    "Metrics",
+    "StrokeWidth",
+]
+
+_type1_fontinfo_order = [
+    "version",
+    "Notice",
+    "FullName",
+    "FamilyName",
+    "Weight",
+    "ItalicAngle",
+    "isFixedPitch",
+    "UnderlinePosition",
+    "UnderlineThickness",
+]
+
+_type1_post_eexec_order = ["Private", "CharStrings", "FID"]
+
+
+def _type1_item_repr(key, value):
+    psstring = ""
+    access = _accessstrings[value.access]
+    if access:
+        access = access + " "
+    if key == "CharStrings":
+        psstring = psstring + "/%s %s def\n" % (
+            key,
+            _type1_CharString_repr(value.value),
+        )
+    elif key == "Encoding":
+        psstring = psstring + _type1_Encoding_repr(value, access)
+    else:
+        psstring = psstring + "/%s %s %sdef\n" % (str(key), str(value), access)
+    return psstring
+
+
+def _type1_Encoding_repr(encoding, access):
+    encoding = encoding.value
+    psstring = "/Encoding 256 array\n0 1 255 {1 index exch /.notdef put} for\n"
+    for i in range(256):
+        name = encoding[i].value
+        if name != ".notdef":
+            psstring = psstring + "dup %d /%s put\n" % (i, name)
+    return psstring + access + "def\n"
+
+
+def _type1_CharString_repr(charstrings):
+    items = sorted(charstrings.items())
+    return "xxx"
+
+
+class ps_font(ps_object):
+    def __str__(self):
+        psstring = "%d dict dup begin\n" % len(self.value)
+        for key in _type1_pre_eexec_order:
+            try:
+                value = self.value[key]
+            except KeyError:
+                pass
+            else:
+                psstring = psstring + _type1_item_repr(key, value)
+        items = sorted(self.value.items())
+        for key, value in items:
+            if key not in _type1_pre_eexec_order + _type1_post_eexec_order:
+                psstring = psstring + _type1_item_repr(key, value)
+        psstring = psstring + "currentdict end\ncurrentfile eexec\ndup "
+        for key in _type1_post_eexec_order:
+            try:
+                value = self.value[key]
+            except KeyError:
+                pass
+            else:
+                psstring = psstring + _type1_item_repr(key, value)
+        return (
+            psstring
+            + "dup/FontName get exch definefont pop\nmark currentfile closefile\n"
+            + 8 * (64 * "0" + "\n")
+            + "cleartomark"
+            + "\n"
+        )
+
+    def __repr__(self):
+        return "<font>"
+
+
+class ps_file(ps_object):
+    pass
+
+
+class ps_dict(ps_object):
+    def __str__(self):
+        psstring = "%d dict dup begin\n" % len(self.value)
+        items = sorted(self.value.items())
+        for key, value in items:
+            access = _accessstrings[value.access]
+            if access:
+                access = access + " "
+            psstring = psstring + "/%s %s %sdef\n" % (str(key), str(value), access)
+        return psstring + "end "
+
+    def __repr__(self):
+        return "<dict>"
+
+
+class ps_mark(ps_object):
+    def __init__(self):
+        self.value = "mark"
+        self.type = self.__class__.__name__[3:] + "type"
+
+
+class ps_procmark(ps_object):
+    def __init__(self):
+        self.value = "procmark"
+        self.type = self.__class__.__name__[3:] + "type"
+
+
+class ps_null(ps_object):
+    def __init__(self):
+        self.type = self.__class__.__name__[3:] + "type"
+
+
+class ps_boolean(ps_object):
+    def __str__(self):
+        if self.value:
+            return "true"
+        else:
+            return "false"
+
+
+class ps_string(ps_object):
+    def __str__(self):
+        return "(%s)" % repr(self.value)[1:-1]
+
+
+class ps_integer(ps_object):
+    def __str__(self):
+        return repr(self.value)
+
+
+class ps_real(ps_object):
+    def __str__(self):
+        return repr(self.value)
+
+
+class PSOperators(object):
+    def ps_def(self):
+        obj = self.pop()
+        name = self.pop()
+        self.dictstack[-1][name.value] = obj
+
+    def ps_bind(self):
+        proc = self.pop("proceduretype")
+        self.proc_bind(proc)
+        self.push(proc)
+
+    def proc_bind(self, proc):
+        for i in range(len(proc.value)):
+            item = proc.value[i]
+            if item.type == "proceduretype":
+                self.proc_bind(item)
+            else:
+                if not item.literal:
+                    try:
+                        obj = self.resolve_name(item.value)
+                    except:
+                        pass
+                    else:
+                        if obj.type == "operatortype":
+                            proc.value[i] = obj
+
+    def ps_exch(self):
+        if len(self.stack) < 2:
+            raise RuntimeError("stack underflow")
+        obj1 = self.pop()
+        obj2 = self.pop()
+        self.push(obj1)
+        self.push(obj2)
+
+    def ps_dup(self):
+        if not self.stack:
+            raise RuntimeError("stack underflow")
+        self.push(self.stack[-1])
+
+    def ps_exec(self):
+        obj = self.pop()
+        if obj.type == "proceduretype":
+            self.call_procedure(obj)
+        else:
+            self.handle_object(obj)
+
+    def ps_count(self):
+        self.push(ps_integer(len(self.stack)))
+
+    def ps_eq(self):
+        any1 = self.pop()
+        any2 = self.pop()
+        self.push(ps_boolean(any1.value == any2.value))
+
+    def ps_ne(self):
+        any1 = self.pop()
+        any2 = self.pop()
+        self.push(ps_boolean(any1.value != any2.value))
+
+    def ps_cvx(self):
+        obj = self.pop()
+        obj.literal = 0
+        self.push(obj)
+
+    def ps_matrix(self):
+        matrix = [
+            ps_real(1.0),
+            ps_integer(0),
+            ps_integer(0),
+            ps_real(1.0),
+            ps_integer(0),
+            ps_integer(0),
+        ]
+        self.push(ps_array(matrix))
+
+    def ps_string(self):
+        num = self.pop("integertype").value
+        self.push(ps_string("\0" * num))
+
+    def ps_type(self):
+        obj = self.pop()
+        self.push(ps_string(obj.type))
+
+    def ps_store(self):
+        value = self.pop()
+        key = self.pop()
+        name = key.value
+        for i in range(len(self.dictstack) - 1, -1, -1):
+            if name in self.dictstack[i]:
+                self.dictstack[i][name] = value
+                break
+        self.dictstack[-1][name] = value
+
+    def ps_where(self):
+        name = self.pop()
+        # XXX
+        self.push(ps_boolean(0))
+
+    def ps_systemdict(self):
+        self.push(ps_dict(self.dictstack[0]))
+
+    def ps_userdict(self):
+        self.push(ps_dict(self.dictstack[1]))
+
+    def ps_currentdict(self):
+        self.push(ps_dict(self.dictstack[-1]))
+
+    def ps_currentfile(self):
+        self.push(ps_file(self.tokenizer))
+
+    def ps_eexec(self):
+        f = self.pop("filetype").value
+        f.starteexec()
+
+    def ps_closefile(self):
+        f = self.pop("filetype").value
+        f.skipwhite()
+        f.stopeexec()
+
+    def ps_cleartomark(self):
+        obj = self.pop()
+        while obj != self.mark:
+            obj = self.pop()
+
+    def ps_readstring(self, ps_boolean=ps_boolean, len=len):
+        s = self.pop("stringtype")
+        oldstr = s.value
+        f = self.pop("filetype")
+        # pad = file.value.read(1)
+        # for StringIO, this is faster
+        f.value.pos = f.value.pos + 1
+        newstr = f.value.read(len(oldstr))
+        s.value = newstr
+        self.push(s)
+        self.push(ps_boolean(len(oldstr) == len(newstr)))
+
+    def ps_known(self):
+        key = self.pop()
+        d = self.pop("dicttype", "fonttype")
+        self.push(ps_boolean(key.value in d.value))
+
+    def ps_if(self):
+        proc = self.pop("proceduretype")
+        if self.pop("booleantype").value:
+            self.call_procedure(proc)
+
+    def ps_ifelse(self):
+        proc2 = self.pop("proceduretype")
+        proc1 = self.pop("proceduretype")
+        if self.pop("booleantype").value:
+            self.call_procedure(proc1)
+        else:
+            self.call_procedure(proc2)
+
+    def ps_readonly(self):
+        obj = self.pop()
+        if obj.access < 1:
+            obj.access = 1
+        self.push(obj)
+
+    def ps_executeonly(self):
+        obj = self.pop()
+        if obj.access < 2:
+            obj.access = 2
+        self.push(obj)
+
+    def ps_noaccess(self):
+        obj = self.pop()
+        if obj.access < 3:
+            obj.access = 3
+        self.push(obj)
+
+    def ps_not(self):
+        obj = self.pop("booleantype", "integertype")
+        if obj.type == "booleantype":
+            self.push(ps_boolean(not obj.value))
+        else:
+            self.push(ps_integer(~obj.value))
+
+    def ps_print(self):
+        str = self.pop("stringtype")
+        print("PS output --->", str.value)
+
+    def ps_anchorsearch(self):
+        seek = self.pop("stringtype")
+        s = self.pop("stringtype")
+        seeklen = len(seek.value)
+        if s.value[:seeklen] == seek.value:
+            self.push(ps_string(s.value[seeklen:]))
+            self.push(seek)
+            self.push(ps_boolean(1))
+        else:
+            self.push(s)
+            self.push(ps_boolean(0))
+
+    def ps_array(self):
+        num = self.pop("integertype")
+        array = ps_array([None] * num.value)
+        self.push(array)
+
+    def ps_astore(self):
+        array = self.pop("arraytype")
+        for i in range(len(array.value) - 1, -1, -1):
+            array.value[i] = self.pop()
+        self.push(array)
+
+    def ps_load(self):
+        name = self.pop()
+        self.push(self.resolve_name(name.value))
+
+    def ps_put(self):
+        obj1 = self.pop()
+        obj2 = self.pop()
+        obj3 = self.pop("arraytype", "dicttype", "stringtype", "proceduretype")
+        tp = obj3.type
+        if tp == "arraytype" or tp == "proceduretype":
+            obj3.value[obj2.value] = obj1
+        elif tp == "dicttype":
+            obj3.value[obj2.value] = obj1
+        elif tp == "stringtype":
+            index = obj2.value
+            obj3.value = obj3.value[:index] + chr(obj1.value) + obj3.value[index + 1 :]
+
+    def ps_get(self):
+        obj1 = self.pop()
+        if obj1.value == "Encoding":
+            pass
+        obj2 = self.pop(
+            "arraytype", "dicttype", "stringtype", "proceduretype", "fonttype"
+        )
+        tp = obj2.type
+        if tp in ("arraytype", "proceduretype"):
+            self.push(obj2.value[obj1.value])
+        elif tp in ("dicttype", "fonttype"):
+            self.push(obj2.value[obj1.value])
+        elif tp == "stringtype":
+            self.push(ps_integer(ord(obj2.value[obj1.value])))
+        else:
+            assert False, "shouldn't get here"
+
+    def ps_getinterval(self):
+        obj1 = self.pop("integertype")
+        obj2 = self.pop("integertype")
+        obj3 = self.pop("arraytype", "stringtype")
+        tp = obj3.type
+        if tp == "arraytype":
+            self.push(ps_array(obj3.value[obj2.value : obj2.value + obj1.value]))
+        elif tp == "stringtype":
+            self.push(ps_string(obj3.value[obj2.value : obj2.value + obj1.value]))
+
+    def ps_putinterval(self):
+        obj1 = self.pop("arraytype", "stringtype")
+        obj2 = self.pop("integertype")
+        obj3 = self.pop("arraytype", "stringtype")
+        tp = obj3.type
+        if tp == "arraytype":
+            obj3.value[obj2.value : obj2.value + len(obj1.value)] = obj1.value
+        elif tp == "stringtype":
+            newstr = obj3.value[: obj2.value]
+            newstr = newstr + obj1.value
+            newstr = newstr + obj3.value[obj2.value + len(obj1.value) :]
+            obj3.value = newstr
+
+    def ps_cvn(self):
+        self.push(ps_name(self.pop("stringtype").value))
+
+    def ps_index(self):
+        n = self.pop("integertype").value
+        if n < 0:
+            raise RuntimeError("index may not be negative")
+        self.push(self.stack[-1 - n])
+
+    def ps_for(self):
+        proc = self.pop("proceduretype")
+        limit = self.pop("integertype", "realtype").value
+        increment = self.pop("integertype", "realtype").value
+        i = self.pop("integertype", "realtype").value
+        while 1:
+            if increment > 0:
+                if i > limit:
+                    break
+            else:
+                if i < limit:
+                    break
+            if type(i) == type(0.0):
+                self.push(ps_real(i))
+            else:
+                self.push(ps_integer(i))
+            self.call_procedure(proc)
+            i = i + increment
+
+    def ps_forall(self):
+        proc = self.pop("proceduretype")
+        obj = self.pop("arraytype", "stringtype", "dicttype")
+        tp = obj.type
+        if tp == "arraytype":
+            for item in obj.value:
+                self.push(item)
+                self.call_procedure(proc)
+        elif tp == "stringtype":
+            for item in obj.value:
+                self.push(ps_integer(ord(item)))
+                self.call_procedure(proc)
+        elif tp == "dicttype":
+            for key, value in obj.value.items():
+                self.push(ps_name(key))
+                self.push(value)
+                self.call_procedure(proc)
+
+    def ps_definefont(self):
+        font = self.pop("dicttype")
+        name = self.pop()
+        font = ps_font(font.value)
+        self.dictstack[0]["FontDirectory"].value[name.value] = font
+        self.push(font)
+
+    def ps_findfont(self):
+        name = self.pop()
+        font = self.dictstack[0]["FontDirectory"].value[name.value]
+        self.push(font)
+
+    def ps_pop(self):
+        self.pop()
+
+    def ps_dict(self):
+        self.pop("integertype")
+        self.push(ps_dict({}))
+
+    def ps_begin(self):
+        self.dictstack.append(self.pop("dicttype").value)
+
+    def ps_end(self):
+        if len(self.dictstack) > 2:
+            del self.dictstack[-1]
+        else:
+            raise RuntimeError("dictstack underflow")
+
+
+notdef = ".notdef"
+from fontTools.encodings.StandardEncoding import StandardEncoding
+
+ps_StandardEncoding = list(map(ps_name, StandardEncoding))

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/sstruct.py

@@ -0,0 +1,231 @@
+"""sstruct.py -- SuperStruct
+
+Higher level layer on top of the struct module, enabling to
+bind names to struct elements. The interface is similar to
+struct, except the objects passed and returned are not tuples
+(or argument lists), but dictionaries or instances.
+
+Just like struct, we use fmt strings to describe a data
+structure, except we use one line per element. Lines are
+separated by newlines or semi-colons. Each line contains
+either one of the special struct characters ('@', '=', '<',
+'>' or '!') or a 'name:formatchar' combo (eg. 'myFloat:f').
+Repetitions, like the struct module offers them are not useful
+in this context, except for fixed length strings  (eg. 'myInt:5h'
+is not allowed but 'myString:5s' is). The 'x' fmt character
+(pad byte) is treated as 'special', since it is by definition
+anonymous. Extra whitespace is allowed everywhere.
+
+The sstruct module offers one feature that the "normal" struct
+module doesn't: support for fixed point numbers. These are spelled
+as "n.mF", where n is the number of bits before the point, and m
+the number of bits after the point. Fixed point numbers get
+converted to floats.
+
+pack(fmt, object):
+	'object' is either a dictionary or an instance (or actually
+	anything that has a __dict__ attribute). If it is a dictionary,
+	its keys are used for names. If it is an instance, it's
+	attributes are used to grab struct elements from. Returns
+	a string containing the data.
+
+unpack(fmt, data, object=None)
+	If 'object' is omitted (or None), a new dictionary will be
+	returned. If 'object' is a dictionary, it will be used to add
+	struct elements to. If it is an instance (or in fact anything
+	that has a __dict__ attribute), an attribute will be added for
+	each struct element. In the latter two cases, 'object' itself
+	is returned.
+
+unpack2(fmt, data, object=None)
+	Convenience function. Same as unpack, except data may be longer
+	than needed. The returned value is a tuple: (object, leftoverdata).
+
+calcsize(fmt)
+	like struct.calcsize(), but uses our own fmt strings:
+	it returns the size of the data in bytes.
+"""
+
+from fontTools.misc.fixedTools import fixedToFloat as fi2fl, floatToFixed as fl2fi
+from fontTools.misc.textTools import tobytes, tostr
+import struct
+import re
+
+__version__ = "1.2"
+__copyright__ = "Copyright 1998, Just van Rossum <just@letterror.com>"
+
+
+class Error(Exception):
+    pass
+
+
+def pack(fmt, obj):
+    formatstring, names, fixes = getformat(fmt, keep_pad_byte=True)
+    elements = []
+    if not isinstance(obj, dict):
+        obj = obj.__dict__
+    string_index = formatstring
+    if formatstring.startswith(">"):
+        string_index = formatstring[1:]
+    for ix, name in enumerate(names.keys()):
+        value = obj[name]
+        if name in fixes:
+            # fixed point conversion
+            value = fl2fi(value, fixes[name])
+        elif isinstance(value, str):
+            value = tobytes(value)
+        elements.append(value)
+        # Check it fits
+        try:
+            struct.pack(names[name], value)
+        except Exception as e:
+            raise ValueError(
+                "Value %s does not fit in format %s for %s" % (value, names[name], name)
+            ) from e
+    data = struct.pack(*(formatstring,) + tuple(elements))
+    return data
+
+
+def unpack(fmt, data, obj=None):
+    if obj is None:
+        obj = {}
+    data = tobytes(data)
+    formatstring, names, fixes = getformat(fmt)
+    if isinstance(obj, dict):
+        d = obj
+    else:
+        d = obj.__dict__
+    elements = struct.unpack(formatstring, data)
+    for i in range(len(names)):
+        name = list(names.keys())[i]
+        value = elements[i]
+        if name in fixes:
+            # fixed point conversion
+            value = fi2fl(value, fixes[name])
+        elif isinstance(value, bytes):
+            try:
+                value = tostr(value)
+            except UnicodeDecodeError:
+                pass
+        d[name] = value
+    return obj
+
+
+def unpack2(fmt, data, obj=None):
+    length = calcsize(fmt)
+    return unpack(fmt, data[:length], obj), data[length:]
+
+
+def calcsize(fmt):
+    formatstring, names, fixes = getformat(fmt)
+    return struct.calcsize(formatstring)
+
+
+# matches "name:formatchar" (whitespace is allowed)
+_elementRE = re.compile(
+    r"\s*"  # whitespace
+    r"([A-Za-z_][A-Za-z_0-9]*)"  # name (python identifier)
+    r"\s*:\s*"  # whitespace : whitespace
+    r"([xcbB?hHiIlLqQfd]|"  # formatchar...
+    r"[0-9]+[ps]|"  # ...formatchar...
+    r"([0-9]+)\.([0-9]+)(F))"  # ...formatchar
+    r"\s*"  # whitespace
+    r"(#.*)?$"  # [comment] + end of string
+)
+
+# matches the special struct fmt chars and 'x' (pad byte)
+_extraRE = re.compile(r"\s*([x@=<>!])\s*(#.*)?$")
+
+# matches an "empty" string, possibly containing whitespace and/or a comment
+_emptyRE = re.compile(r"\s*(#.*)?$")
+
+_fixedpointmappings = {8: "b", 16: "h", 32: "l"}
+
+_formatcache = {}
+
+
+def getformat(fmt, keep_pad_byte=False):
+    fmt = tostr(fmt, encoding="ascii")
+    try:
+        formatstring, names, fixes = _formatcache[fmt]
+    except KeyError:
+        lines = re.split("[\n;]", fmt)
+        formatstring = ""
+        names = {}
+        fixes = {}
+        for line in lines:
+            if _emptyRE.match(line):
+                continue
+            m = _extraRE.match(line)
+            if m:
+                formatchar = m.group(1)
+                if formatchar != "x" and formatstring:
+                    raise Error("a special fmt char must be first")
+            else:
+                m = _elementRE.match(line)
+                if not m:
+                    raise Error("syntax error in fmt: '%s'" % line)
+                name = m.group(1)
+                formatchar = m.group(2)
+                if keep_pad_byte or formatchar != "x":
+                    names[name] = formatchar
+                if m.group(3):
+                    # fixed point
+                    before = int(m.group(3))
+                    after = int(m.group(4))
+                    bits = before + after
+                    if bits not in [8, 16, 32]:
+                        raise Error("fixed point must be 8, 16 or 32 bits long")
+                    formatchar = _fixedpointmappings[bits]
+                    names[name] = formatchar
+                    assert m.group(5) == "F"
+                    fixes[name] = after
+            formatstring += formatchar
+        _formatcache[fmt] = formatstring, names, fixes
+    return formatstring, names, fixes
+
+
+def _test():
+    fmt = """
+		# comments are allowed
+		>  # big endian (see documentation for struct)
+		# empty lines are allowed:
+
+		ashort: h
+		along: l
+		abyte: b	# a byte
+		achar: c
+		astr: 5s
+		afloat: f; adouble: d	# multiple "statements" are allowed
+		afixed: 16.16F
+		abool: ?
+		apad: x
+	"""
+
+    print("size:", calcsize(fmt))
+
+    class foo(object):
+        pass
+
+    i = foo()
+
+    i.ashort = 0x7FFF
+    i.along = 0x7FFFFFFF
+    i.abyte = 0x7F
+    i.achar = "a"
+    i.astr = "12345"
+    i.afloat = 0.5
+    i.adouble = 0.5
+    i.afixed = 1.5
+    i.abool = True
+
+    data = pack(fmt, i)
+    print("data:", repr(data))
+    print(unpack(fmt, data))
+    i2 = foo()
+    unpack(fmt, data, i2)
+    print(vars(i2))
+
+
+if __name__ == "__main__":
+    _test()

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/testTools.py

@@ -0,0 +1,229 @@
+"""Helpers for writing unit tests."""
+
+from collections.abc import Iterable
+from io import BytesIO
+import os
+import re
+import shutil
+import sys
+import tempfile
+from unittest import TestCase as _TestCase
+from fontTools.config import Config
+from fontTools.misc.textTools import tobytes
+from fontTools.misc.xmlWriter import XMLWriter
+
+
+def parseXML(xmlSnippet):
+    """Parses a snippet of XML.
+
+    Input can be either a single string (unicode or UTF-8 bytes), or a
+    a sequence of strings.
+
+    The result is in the same format that would be returned by
+    XMLReader, but the parser imposes no constraints on the root
+    element so it can be called on small snippets of TTX files.
+    """
+    # To support snippets with multiple elements, we add a fake root.
+    reader = TestXMLReader_()
+    xml = b"<root>"
+    if isinstance(xmlSnippet, bytes):
+        xml += xmlSnippet
+    elif isinstance(xmlSnippet, str):
+        xml += tobytes(xmlSnippet, "utf-8")
+    elif isinstance(xmlSnippet, Iterable):
+        xml += b"".join(tobytes(s, "utf-8") for s in xmlSnippet)
+    else:
+        raise TypeError(
+            "expected string or sequence of strings; found %r"
+            % type(xmlSnippet).__name__
+        )
+    xml += b"</root>"
+    reader.parser.Parse(xml, 0)
+    return reader.root[2]
+
+
+def parseXmlInto(font, parseInto, xmlSnippet):
+    parsed_xml = [e for e in parseXML(xmlSnippet.strip()) if not isinstance(e, str)]
+    for name, attrs, content in parsed_xml:
+        parseInto.fromXML(name, attrs, content, font)
+    parseInto.populateDefaults()
+    return parseInto
+
+
+class FakeFont:
+    def __init__(self, glyphs):
+        self.glyphOrder_ = glyphs
+        self.reverseGlyphOrderDict_ = {g: i for i, g in enumerate(glyphs)}
+        self.lazy = False
+        self.tables = {}
+        self.cfg = Config()
+
+    def __getitem__(self, tag):
+        return self.tables[tag]
+
+    def __setitem__(self, tag, table):
+        self.tables[tag] = table
+
+    def get(self, tag, default=None):
+        return self.tables.get(tag, default)
+
+    def getGlyphID(self, name):
+        return self.reverseGlyphOrderDict_[name]
+
+    def getGlyphIDMany(self, lst):
+        return [self.getGlyphID(gid) for gid in lst]
+
+    def getGlyphName(self, glyphID):
+        if glyphID < len(self.glyphOrder_):
+            return self.glyphOrder_[glyphID]
+        else:
+            return "glyph%.5d" % glyphID
+
+    def getGlyphNameMany(self, lst):
+        return [self.getGlyphName(gid) for gid in lst]
+
+    def getGlyphOrder(self):
+        return self.glyphOrder_
+
+    def getReverseGlyphMap(self):
+        return self.reverseGlyphOrderDict_
+
+    def getGlyphNames(self):
+        return sorted(self.getGlyphOrder())
+
+
+class TestXMLReader_(object):
+    def __init__(self):
+        from xml.parsers.expat import ParserCreate
+
+        self.parser = ParserCreate()
+        self.parser.StartElementHandler = self.startElement_
+        self.parser.EndElementHandler = self.endElement_
+        self.parser.CharacterDataHandler = self.addCharacterData_
+        self.root = None
+        self.stack = []
+
+    def startElement_(self, name, attrs):
+        element = (name, attrs, [])
+        if self.stack:
+            self.stack[-1][2].append(element)
+        else:
+            self.root = element
+        self.stack.append(element)
+
+    def endElement_(self, name):
+        self.stack.pop()
+
+    def addCharacterData_(self, data):
+        self.stack[-1][2].append(data)
+
+
+def makeXMLWriter(newlinestr="\n"):
+    # don't write OS-specific new lines
+    writer = XMLWriter(BytesIO(), newlinestr=newlinestr)
+    # erase XML declaration
+    writer.file.seek(0)
+    writer.file.truncate()
+    return writer
+
+
+def getXML(func, ttFont=None):
+    """Call the passed toXML function and return the written content as a
+    list of lines (unicode strings).
+    Result is stripped of XML declaration and OS-specific newline characters.
+    """
+    writer = makeXMLWriter()
+    func(writer, ttFont)
+    xml = writer.file.getvalue().decode("utf-8")
+    # toXML methods must always end with a writer.newline()
+    assert xml.endswith("\n")
+    return xml.splitlines()
+
+
+def stripVariableItemsFromTTX(
+    string: str,
+    ttLibVersion: bool = True,
+    checkSumAdjustment: bool = True,
+    modified: bool = True,
+    created: bool = True,
+    sfntVersion: bool = False,  # opt-in only
+) -> str:
+    """Strip stuff like ttLibVersion, checksums, timestamps, etc. from TTX dumps."""
+    # ttlib changes with the fontTools version
+    if ttLibVersion:
+        string = re.sub(' ttLibVersion="[^"]+"', "", string)
+    # sometimes (e.g. some subsetter tests) we don't care whether it's OTF or TTF
+    if sfntVersion:
+        string = re.sub(' sfntVersion="[^"]+"', "", string)
+    # head table checksum and creation and mod date changes with each save.
+    if checkSumAdjustment:
+        string = re.sub('<checkSumAdjustment value="[^"]+"/>', "", string)
+    if modified:
+        string = re.sub('<modified value="[^"]+"/>', "", string)
+    if created:
+        string = re.sub('<created value="[^"]+"/>', "", string)
+    return string
+
+
+class MockFont(object):
+    """A font-like object that automatically adds any looked up glyphname
+    to its glyphOrder."""
+
+    def __init__(self):
+        self._glyphOrder = [".notdef"]
+
+        class AllocatingDict(dict):
+            def __missing__(reverseDict, key):
+                self._glyphOrder.append(key)
+                gid = len(reverseDict)
+                reverseDict[key] = gid
+                return gid
+
+        self._reverseGlyphOrder = AllocatingDict({".notdef": 0})
+        self.lazy = False
+
+    def getGlyphID(self, glyph):
+        gid = self._reverseGlyphOrder[glyph]
+        return gid
+
+    def getReverseGlyphMap(self):
+        return self._reverseGlyphOrder
+
+    def getGlyphName(self, gid):
+        return self._glyphOrder[gid]
+
+    def getGlyphOrder(self):
+        return self._glyphOrder
+
+
+class TestCase(_TestCase):
+    def __init__(self, methodName):
+        _TestCase.__init__(self, methodName)
+        # Python 3 renamed assertRaisesRegexp to assertRaisesRegex,
+        # and fires deprecation warnings if a program uses the old name.
+        if not hasattr(self, "assertRaisesRegex"):
+            self.assertRaisesRegex = self.assertRaisesRegexp
+
+
+class DataFilesHandler(TestCase):
+    def setUp(self):
+        self.tempdir = None
+        self.num_tempfiles = 0
+
+    def tearDown(self):
+        if self.tempdir:
+            shutil.rmtree(self.tempdir)
+
+    def getpath(self, testfile):
+        folder = os.path.dirname(sys.modules[self.__module__].__file__)
+        return os.path.join(folder, "data", testfile)
+
+    def temp_dir(self):
+        if not self.tempdir:
+            self.tempdir = tempfile.mkdtemp()
+
+    def temp_font(self, font_path, file_name):
+        self.temp_dir()
+        temppath = os.path.join(self.tempdir, file_name)
+        shutil.copy2(font_path, temppath)
+        return temppath

evalkit_tf437/lib/python3.10/site-packages/fontTools/misc/transform.py

@@ -0,0 +1,507 @@
+"""Affine 2D transformation matrix class.
+
+The Transform class implements various transformation matrix operations,
+both on the matrix itself, as well as on 2D coordinates.
+
+Transform instances are effectively immutable: all methods that operate on the
+transformation itself always return a new instance. This has as the
+interesting side effect that Transform instances are hashable, ie. they can be
+used as dictionary keys.
+
+This module exports the following symbols:
+
+Transform
+	this is the main class
+Identity
+	Transform instance set to the identity transformation
+Offset
+	Convenience function that returns a translating transformation
+Scale
+	Convenience function that returns a scaling transformation
+
+The DecomposedTransform class implements a transformation with separate
+translate, rotation, scale, skew, and transformation-center components.
+
+:Example:
+
+	>>> t = Transform(2, 0, 0, 3, 0, 0)
+	>>> t.transformPoint((100, 100))
+	(200, 300)
+	>>> t = Scale(2, 3)
+	>>> t.transformPoint((100, 100))
+	(200, 300)
+	>>> t.transformPoint((0, 0))
+	(0, 0)
+	>>> t = Offset(2, 3)
+	>>> t.transformPoint((100, 100))
+	(102, 103)
+	>>> t.transformPoint((0, 0))
+	(2, 3)
+	>>> t2 = t.scale(0.5)
+	>>> t2.transformPoint((100, 100))
+	(52.0, 53.0)
+	>>> import math
+	>>> t3 = t2.rotate(math.pi / 2)
+	>>> t3.transformPoint((0, 0))
+	(2.0, 3.0)
+	>>> t3.transformPoint((100, 100))
+	(-48.0, 53.0)
+	>>> t = Identity.scale(0.5).translate(100, 200).skew(0.1, 0.2)
+	>>> t.transformPoints([(0, 0), (1, 1), (100, 100)])
+	[(50.0, 100.0), (50.550167336042726, 100.60135501775433), (105.01673360427253, 160.13550177543362)]
+	>>>
+"""
+
+import math
+from typing import NamedTuple
+from dataclasses import dataclass
+
+
+__all__ = ["Transform", "Identity", "Offset", "Scale", "DecomposedTransform"]
+
+
+_EPSILON = 1e-15
+_ONE_EPSILON = 1 - _EPSILON
+_MINUS_ONE_EPSILON = -1 + _EPSILON
+
+
+def _normSinCos(v):
+    if abs(v) < _EPSILON:
+        v = 0
+    elif v > _ONE_EPSILON:
+        v = 1
+    elif v < _MINUS_ONE_EPSILON:
+        v = -1
+    return v
+
+
+class Transform(NamedTuple):
+    """2x2 transformation matrix plus offset, a.k.a. Affine transform.
+    Transform instances are immutable: all transforming methods, eg.
+    rotate(), return a new Transform instance.
+
+    :Example:
+
+            >>> t = Transform()
+            >>> t
+            <Transform [1 0 0 1 0 0]>
+            >>> t.scale(2)
+            <Transform [2 0 0 2 0 0]>
+            >>> t.scale(2.5, 5.5)
+            <Transform [2.5 0 0 5.5 0 0]>
+            >>>
+            >>> t.scale(2, 3).transformPoint((100, 100))
+            (200, 300)
+
+    Transform's constructor takes six arguments, all of which are
+    optional, and can be used as keyword arguments::
+
+            >>> Transform(12)
+            <Transform [12 0 0 1 0 0]>
+            >>> Transform(dx=12)
+            <Transform [1 0 0 1 12 0]>
+            >>> Transform(yx=12)
+            <Transform [1 0 12 1 0 0]>
+
+    Transform instances also behave like sequences of length 6::
+
+            >>> len(Identity)
+            6
+            >>> list(Identity)
+            [1, 0, 0, 1, 0, 0]
+            >>> tuple(Identity)
+            (1, 0, 0, 1, 0, 0)
+
+    Transform instances are comparable::
+
+            >>> t1 = Identity.scale(2, 3).translate(4, 6)
+            >>> t2 = Identity.translate(8, 18).scale(2, 3)
+            >>> t1 == t2
+            1
+
+    But beware of floating point rounding errors::
+
+            >>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6)
+            >>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3)
+            >>> t1
+            <Transform [0.2 0 0 0.3 0.08 0.18]>
+            >>> t2
+            <Transform [0.2 0 0 0.3 0.08 0.18]>
+            >>> t1 == t2
+            0
+
+    Transform instances are hashable, meaning you can use them as
+    keys in dictionaries::
+
+            >>> d = {Scale(12, 13): None}
+            >>> d
+            {<Transform [12 0 0 13 0 0]>: None}
+
+    But again, beware of floating point rounding errors::
+
+            >>> t1 = Identity.scale(0.2, 0.3).translate(0.4, 0.6)
+            >>> t2 = Identity.translate(0.08, 0.18).scale(0.2, 0.3)
+            >>> t1
+            <Transform [0.2 0 0 0.3 0.08 0.18]>
+            >>> t2
+            <Transform [0.2 0 0 0.3 0.08 0.18]>
+            >>> d = {t1: None}
+            >>> d
+            {<Transform [0.2 0 0 0.3 0.08 0.18]>: None}
+            >>> d[t2]
+            Traceback (most recent call last):
+              File "<stdin>", line 1, in ?
+            KeyError: <Transform [0.2 0 0 0.3 0.08 0.18]>
+    """
+
+    xx: float = 1
+    xy: float = 0
+    yx: float = 0
+    yy: float = 1
+    dx: float = 0
+    dy: float = 0
+
+    def transformPoint(self, p):
+        """Transform a point.
+
+        :Example:
+
+                >>> t = Transform()
+                >>> t = t.scale(2.5, 5.5)
+                >>> t.transformPoint((100, 100))
+                (250.0, 550.0)
+        """
+        (x, y) = p
+        xx, xy, yx, yy, dx, dy = self
+        return (xx * x + yx * y + dx, xy * x + yy * y + dy)
+
+    def transformPoints(self, points):
+        """Transform a list of points.
+
+        :Example:
+
+                >>> t = Scale(2, 3)
+                >>> t.transformPoints([(0, 0), (0, 100), (100, 100), (100, 0)])
+                [(0, 0), (0, 300), (200, 300), (200, 0)]
+                >>>
+        """
+        xx, xy, yx, yy, dx, dy = self
+        return [(xx * x + yx * y + dx, xy * x + yy * y + dy) for x, y in points]
+
+    def transformVector(self, v):
+        """Transform an (dx, dy) vector, treating translation as zero.
+
+        :Example:
+
+                >>> t = Transform(2, 0, 0, 2, 10, 20)
+                >>> t.transformVector((3, -4))
+                (6, -8)
+                >>>
+        """
+        (dx, dy) = v
+        xx, xy, yx, yy = self[:4]
+        return (xx * dx + yx * dy, xy * dx + yy * dy)
+
+    def transformVectors(self, vectors):
+        """Transform a list of (dx, dy) vector, treating translation as zero.
+
+        :Example:
+                >>> t = Transform(2, 0, 0, 2, 10, 20)
+                >>> t.transformVectors([(3, -4), (5, -6)])
+                [(6, -8), (10, -12)]
+                >>>
+        """
+        xx, xy, yx, yy = self[:4]
+        return [(xx * dx + yx * dy, xy * dx + yy * dy) for dx, dy in vectors]
+
+    def translate(self, x=0, y=0):
+        """Return a new transformation, translated (offset) by x, y.
+
+        :Example:
+                >>> t = Transform()
+                >>> t.translate(20, 30)
+                <Transform [1 0 0 1 20 30]>
+                >>>
+        """
+        return self.transform((1, 0, 0, 1, x, y))
+
+    def scale(self, x=1, y=None):
+        """Return a new transformation, scaled by x, y. The 'y' argument
+        may be None, which implies to use the x value for y as well.
+
+        :Example:
+                >>> t = Transform()
+                >>> t.scale(5)
+                <Transform [5 0 0 5 0 0]>
+                >>> t.scale(5, 6)
+                <Transform [5 0 0 6 0 0]>
+                >>>
+        """
+        if y is None:
+            y = x
+        return self.transform((x, 0, 0, y, 0, 0))
+
+    def rotate(self, angle):
+        """Return a new transformation, rotated by 'angle' (radians).
+
+        :Example:
+                >>> import math
+                >>> t = Transform()
+                >>> t.rotate(math.pi / 2)
+                <Transform [0 1 -1 0 0 0]>
+                >>>
+        """
+        import math
+
+        c = _normSinCos(math.cos(angle))
+        s = _normSinCos(math.sin(angle))
+        return self.transform((c, s, -s, c, 0, 0))
+
+    def skew(self, x=0, y=0):
+        """Return a new transformation, skewed by x and y.
+
+        :Example:
+                >>> import math
+                >>> t = Transform()
+                >>> t.skew(math.pi / 4)
+                <Transform [1 0 1 1 0 0]>
+                >>>
+        """
+        import math
+
+        return self.transform((1, math.tan(y), math.tan(x), 1, 0, 0))
+
+    def transform(self, other):
+        """Return a new transformation, transformed by another
+        transformation.
+
+        :Example:
+                >>> t = Transform(2, 0, 0, 3, 1, 6)
+                >>> t.transform((4, 3, 2, 1, 5, 6))
+                <Transform [8 9 4 3 11 24]>
+                >>>
+        """
+        xx1, xy1, yx1, yy1, dx1, dy1 = other
+        xx2, xy2, yx2, yy2, dx2, dy2 = self
+        return self.__class__(
+            xx1 * xx2 + xy1 * yx2,
+            xx1 * xy2 + xy1 * yy2,
+            yx1 * xx2 + yy1 * yx2,
+            yx1 * xy2 + yy1 * yy2,
+            xx2 * dx1 + yx2 * dy1 + dx2,
+            xy2 * dx1 + yy2 * dy1 + dy2,
+        )
+
+    def reverseTransform(self, other):
+        """Return a new transformation, which is the other transformation
+        transformed by self. self.reverseTransform(other) is equivalent to
+        other.transform(self).
+
+        :Example:
+                >>> t = Transform(2, 0, 0, 3, 1, 6)
+                >>> t.reverseTransform((4, 3, 2, 1, 5, 6))
+                <Transform [8 6 6 3 21 15]>
+                >>> Transform(4, 3, 2, 1, 5, 6).transform((2, 0, 0, 3, 1, 6))
+                <Transform [8 6 6 3 21 15]>
+                >>>
+        """
+        xx1, xy1, yx1, yy1, dx1, dy1 = self
+        xx2, xy2, yx2, yy2, dx2, dy2 = other
+        return self.__class__(
+            xx1 * xx2 + xy1 * yx2,
+            xx1 * xy2 + xy1 * yy2,
+            yx1 * xx2 + yy1 * yx2,
+            yx1 * xy2 + yy1 * yy2,
+            xx2 * dx1 + yx2 * dy1 + dx2,
+            xy2 * dx1 + yy2 * dy1 + dy2,
+        )
+
+    def inverse(self):
+        """Return the inverse transformation.
+
+        :Example:
+                >>> t = Identity.translate(2, 3).scale(4, 5)
+                >>> t.transformPoint((10, 20))
+                (42, 103)
+                >>> it = t.inverse()
+                >>> it.transformPoint((42, 103))
+                (10.0, 20.0)
+                >>>
+        """
+        if self == Identity:
+            return self
+        xx, xy, yx, yy, dx, dy = self
+        det = xx * yy - yx * xy
+        xx, xy, yx, yy = yy / det, -xy / det, -yx / det, xx / det
+        dx, dy = -xx * dx - yx * dy, -xy * dx - yy * dy
+        return self.__class__(xx, xy, yx, yy, dx, dy)
+
+    def toPS(self):
+        """Return a PostScript representation
+
+        :Example:
+
+                >>> t = Identity.scale(2, 3).translate(4, 5)
+                >>> t.toPS()
+                '[2 0 0 3 8 15]'
+                >>>
+        """
+        return "[%s %s %s %s %s %s]" % self
+
+    def toDecomposed(self) -> "DecomposedTransform":
+        """Decompose into a DecomposedTransform."""
+        return DecomposedTransform.fromTransform(self)
+
+    def __bool__(self):
+        """Returns True if transform is not identity, False otherwise.
+
+        :Example:
+
+                >>> bool(Identity)
+                False
+                >>> bool(Transform())
+                False
+                >>> bool(Scale(1.))
+                False
+                >>> bool(Scale(2))
+                True
+                >>> bool(Offset())
+                False
+                >>> bool(Offset(0))
+                False
+                >>> bool(Offset(2))
+                True
+        """
+        return self != Identity
+
+    def __repr__(self):
+        return "<%s [%g %g %g %g %g %g]>" % ((self.__class__.__name__,) + self)
+
+
+Identity = Transform()
+
+
+def Offset(x=0, y=0):
+    """Return the identity transformation offset by x, y.
+
+    :Example:
+            >>> Offset(2, 3)
+            <Transform [1 0 0 1 2 3]>
+            >>>
+    """
+    return Transform(1, 0, 0, 1, x, y)
+
+
+def Scale(x, y=None):
+    """Return the identity transformation scaled by x, y. The 'y' argument
+    may be None, which implies to use the x value for y as well.
+
+    :Example:
+            >>> Scale(2, 3)
+            <Transform [2 0 0 3 0 0]>
+            >>>
+    """
+    if y is None:
+        y = x
+    return Transform(x, 0, 0, y, 0, 0)
+
+
+@dataclass
+class DecomposedTransform:
+    """The DecomposedTransform class implements a transformation with separate
+    translate, rotation, scale, skew, and transformation-center components.
+    """
+
+    translateX: float = 0
+    translateY: float = 0
+    rotation: float = 0  # in degrees, counter-clockwise
+    scaleX: float = 1
+    scaleY: float = 1
+    skewX: float = 0  # in degrees, clockwise
+    skewY: float = 0  # in degrees, counter-clockwise
+    tCenterX: float = 0
+    tCenterY: float = 0
+
+    def __bool__(self):
+        return (
+            self.translateX != 0
+            or self.translateY != 0
+            or self.rotation != 0
+            or self.scaleX != 1
+            or self.scaleY != 1
+            or self.skewX != 0
+            or self.skewY != 0
+            or self.tCenterX != 0
+            or self.tCenterY != 0
+        )
+
+    @classmethod
+    def fromTransform(self, transform):
+        # Adapted from an answer on
+        # https://math.stackexchange.com/questions/13150/extracting-rotation-scale-values-from-2d-transformation-matrix
+        a, b, c, d, x, y = transform
+
+        sx = math.copysign(1, a)
+        if sx < 0:
+            a *= sx
+            b *= sx
+
+        delta = a * d - b * c
+
+        rotation = 0
+        scaleX = scaleY = 0
+        skewX = skewY = 0
+
+        # Apply the QR-like decomposition.
+        if a != 0 or b != 0:
+            r = math.sqrt(a * a + b * b)
+            rotation = math.acos(a / r) if b >= 0 else -math.acos(a / r)
+            scaleX, scaleY = (r, delta / r)
+            skewX, skewY = (math.atan((a * c + b * d) / (r * r)), 0)
+        elif c != 0 or d != 0:
+            s = math.sqrt(c * c + d * d)
+            rotation = math.pi / 2 - (
+                math.acos(-c / s) if d >= 0 else -math.acos(c / s)
+            )
+            scaleX, scaleY = (delta / s, s)
+            skewX, skewY = (0, math.atan((a * c + b * d) / (s * s)))
+        else:
+            # a = b = c = d = 0
+            pass
+
+        return DecomposedTransform(
+            x,
+            y,
+            math.degrees(rotation),
+            scaleX * sx,
+            scaleY,
+            math.degrees(skewX) * sx,
+            math.degrees(skewY),
+            0,
+            0,
+        )
+
+    def toTransform(self):
+        """Return the Transform() equivalent of this transformation.
+
+        :Example:
+                >>> DecomposedTransform(scaleX=2, scaleY=2).toTransform()
+                <Transform [2 0 0 2 0 0]>
+                >>>
+        """
+        t = Transform()
+        t = t.translate(
+            self.translateX + self.tCenterX, self.translateY + self.tCenterY
+        )
+        t = t.rotate(math.radians(self.rotation))
+        t = t.scale(self.scaleX, self.scaleY)
+        t = t.skew(math.radians(self.skewX), math.radians(self.skewY))
+        t = t.translate(-self.tCenterX, -self.tCenterY)
+        return t
+
+
+if __name__ == "__main__":
+    import sys
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

evalkit_tf437/lib/python3.10/site-packages/fontTools/mtiLib/__init__.py

@@ -0,0 +1,1402 @@
+#!/usr/bin/python
+
+# FontDame-to-FontTools for OpenType Layout tables
+#
+# Source language spec is available at:
+# http://monotype.github.io/OpenType_Table_Source/otl_source.html
+# https://github.com/Monotype/OpenType_Table_Source/
+
+from fontTools import ttLib
+from fontTools.ttLib.tables._c_m_a_p import cmap_classes
+from fontTools.ttLib.tables import otTables as ot
+from fontTools.ttLib.tables.otBase import ValueRecord, valueRecordFormatDict
+from fontTools.otlLib import builder as otl
+from contextlib import contextmanager
+from fontTools.ttLib import newTable
+from fontTools.feaLib.lookupDebugInfo import LOOKUP_DEBUG_ENV_VAR, LOOKUP_DEBUG_INFO_KEY
+from operator import setitem
+import os
+import logging
+
+
+class MtiLibError(Exception):
+    pass
+
+
+class ReferenceNotFoundError(MtiLibError):
+    pass
+
+
+class FeatureNotFoundError(ReferenceNotFoundError):
+    pass
+
+
+class LookupNotFoundError(ReferenceNotFoundError):
+    pass
+
+
+log = logging.getLogger("fontTools.mtiLib")
+
+
+def makeGlyph(s):
+    if s[:2] in ["U ", "u "]:
+        return ttLib.TTFont._makeGlyphName(int(s[2:], 16))
+    elif s[:2] == "# ":
+        return "glyph%.5d" % int(s[2:])
+    assert s.find(" ") < 0, "Space found in glyph name: %s" % s
+    assert s, "Glyph name is empty"
+    return s
+
+
+def makeGlyphs(l):
+    return [makeGlyph(g) for g in l]
+
+
+def mapLookup(sym, mapping):
+    # Lookups are addressed by name.  So resolved them using a map if available.
+    # Fallback to parsing as lookup index if a map isn't provided.
+    if mapping is not None:
+        try:
+            idx = mapping[sym]
+        except KeyError:
+            raise LookupNotFoundError(sym)
+    else:
+        idx = int(sym)
+    return idx
+
+
+def mapFeature(sym, mapping):
+    # Features are referenced by index according the spec.  So, if symbol is an
+    # integer, use it directly.  Otherwise look up in the map if provided.
+    try:
+        idx = int(sym)
+    except ValueError:
+        try:
+            idx = mapping[sym]
+        except KeyError:
+            raise FeatureNotFoundError(sym)
+    return idx
+
+
+def setReference(mapper, mapping, sym, setter, collection, key):
+    try:
+        mapped = mapper(sym, mapping)
+    except ReferenceNotFoundError as e:
+        try:
+            if mapping is not None:
+                mapping.addDeferredMapping(
+                    lambda ref: setter(collection, key, ref), sym, e
+                )
+                return
+        except AttributeError:
+            pass
+        raise
+    setter(collection, key, mapped)
+
+
+class DeferredMapping(dict):
+    def __init__(self):
+        self._deferredMappings = []
+
+    def addDeferredMapping(self, setter, sym, e):
+        log.debug("Adding deferred mapping for symbol '%s' %s", sym, type(e).__name__)
+        self._deferredMappings.append((setter, sym, e))
+
+    def applyDeferredMappings(self):
+        for setter, sym, e in self._deferredMappings:
+            log.debug(
+                "Applying deferred mapping for symbol '%s' %s", sym, type(e).__name__
+            )
+            try:
+                mapped = self[sym]
+            except KeyError:
+                raise e
+            setter(mapped)
+            log.debug("Set to %s", mapped)
+        self._deferredMappings = []
+
+
+def parseScriptList(lines, featureMap=None):
+    self = ot.ScriptList()
+    records = []
+    with lines.between("script table"):
+        for line in lines:
+            while len(line) < 4:
+                line.append("")
+            scriptTag, langSysTag, defaultFeature, features = line
+            log.debug("Adding script %s language-system %s", scriptTag, langSysTag)
+
+            langSys = ot.LangSys()
+            langSys.LookupOrder = None
+            if defaultFeature:
+                setReference(
+                    mapFeature,
+                    featureMap,
+                    defaultFeature,
+                    setattr,
+                    langSys,
+                    "ReqFeatureIndex",
+                )
+            else:
+                langSys.ReqFeatureIndex = 0xFFFF
+            syms = stripSplitComma(features)
+            langSys.FeatureIndex = theList = [3] * len(syms)
+            for i, sym in enumerate(syms):
+                setReference(mapFeature, featureMap, sym, setitem, theList, i)
+            langSys.FeatureCount = len(langSys.FeatureIndex)
+
+            script = [s for s in records if s.ScriptTag == scriptTag]
+            if script:
+                script = script[0].Script
+            else:
+                scriptRec = ot.ScriptRecord()
+                scriptRec.ScriptTag = scriptTag + " " * (4 - len(scriptTag))
+                scriptRec.Script = ot.Script()
+                records.append(scriptRec)
+                script = scriptRec.Script
+                script.DefaultLangSys = None
+                script.LangSysRecord = []
+                script.LangSysCount = 0
+
+            if langSysTag == "default":
+                script.DefaultLangSys = langSys
+            else:
+                langSysRec = ot.LangSysRecord()
+                langSysRec.LangSysTag = langSysTag + " " * (4 - len(langSysTag))
+                langSysRec.LangSys = langSys
+                script.LangSysRecord.append(langSysRec)
+                script.LangSysCount = len(script.LangSysRecord)
+
+    for script in records:
+        script.Script.LangSysRecord = sorted(
+            script.Script.LangSysRecord, key=lambda rec: rec.LangSysTag
+        )
+    self.ScriptRecord = sorted(records, key=lambda rec: rec.ScriptTag)
+    self.ScriptCount = len(self.ScriptRecord)
+    return self
+
+
+def parseFeatureList(lines, lookupMap=None, featureMap=None):
+    self = ot.FeatureList()
+    self.FeatureRecord = []
+    with lines.between("feature table"):
+        for line in lines:
+            name, featureTag, lookups = line
+            if featureMap is not None:
+                assert name not in featureMap, "Duplicate feature name: %s" % name
+                featureMap[name] = len(self.FeatureRecord)
+            # If feature name is integer, make sure it matches its index.
+            try:
+                assert int(name) == len(self.FeatureRecord), "%d %d" % (
+                    name,
+                    len(self.FeatureRecord),
+                )
+            except ValueError:
+                pass
+            featureRec = ot.FeatureRecord()
+            featureRec.FeatureTag = featureTag
+            featureRec.Feature = ot.Feature()
+            self.FeatureRecord.append(featureRec)
+            feature = featureRec.Feature
+            feature.FeatureParams = None
+            syms = stripSplitComma(lookups)
+            feature.LookupListIndex = theList = [None] * len(syms)
+            for i, sym in enumerate(syms):
+                setReference(mapLookup, lookupMap, sym, setitem, theList, i)
+            feature.LookupCount = len(feature.LookupListIndex)
+
+    self.FeatureCount = len(self.FeatureRecord)
+    return self
+
+
+def parseLookupFlags(lines):
+    flags = 0
+    filterset = None
+    allFlags = [
+        "righttoleft",
+        "ignorebaseglyphs",
+        "ignoreligatures",
+        "ignoremarks",
+        "markattachmenttype",
+        "markfiltertype",
+    ]
+    while lines.peeks()[0].lower() in allFlags:
+        line = next(lines)
+        flag = {
+            "righttoleft": 0x0001,
+            "ignorebaseglyphs": 0x0002,
+            "ignoreligatures": 0x0004,
+            "ignoremarks": 0x0008,
+        }.get(line[0].lower())
+        if flag:
+            assert line[1].lower() in ["yes", "no"], line[1]
+            if line[1].lower() == "yes":
+                flags |= flag
+            continue
+        if line[0].lower() == "markattachmenttype":
+            flags |= int(line[1]) << 8
+            continue
+        if line[0].lower() == "markfiltertype":
+            flags |= 0x10
+            filterset = int(line[1])
+    return flags, filterset
+
+
+def parseSingleSubst(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        assert len(line) == 2, line
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1]
+    return otl.buildSingleSubstSubtable(mapping)
+
+
+def parseMultiple(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1:]
+    return otl.buildMultipleSubstSubtable(mapping)
+
+
+def parseAlternate(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1:]
+    return otl.buildAlternateSubstSubtable(mapping)
+
+
+def parseLigature(lines, font, _lookupMap=None):
+    mapping = {}
+    for line in lines:
+        assert len(line) >= 2, line
+        line = makeGlyphs(line)
+        mapping[tuple(line[1:])] = line[0]
+    return otl.buildLigatureSubstSubtable(mapping)
+
+
+def parseSinglePos(lines, font, _lookupMap=None):
+    values = {}
+    for line in lines:
+        assert len(line) == 3, line
+        w = line[0].title().replace(" ", "")
+        assert w in valueRecordFormatDict
+        g = makeGlyph(line[1])
+        v = int(line[2])
+        if g not in values:
+            values[g] = ValueRecord()
+        assert not hasattr(values[g], w), (g, w)
+        setattr(values[g], w, v)
+    return otl.buildSinglePosSubtable(values, font.getReverseGlyphMap())
+
+
+def parsePair(lines, font, _lookupMap=None):
+    self = ot.PairPos()
+    self.ValueFormat1 = self.ValueFormat2 = 0
+    typ = lines.peeks()[0].split()[0].lower()
+    if typ in ("left", "right"):
+        self.Format = 1
+        values = {}
+        for line in lines:
+            assert len(line) == 4, line
+            side = line[0].split()[0].lower()
+            assert side in ("left", "right"), side
+            what = line[0][len(side) :].title().replace(" ", "")
+            mask = valueRecordFormatDict[what][0]
+            glyph1, glyph2 = makeGlyphs(line[1:3])
+            value = int(line[3])
+            if not glyph1 in values:
+                values[glyph1] = {}
+            if not glyph2 in values[glyph1]:
+                values[glyph1][glyph2] = (ValueRecord(), ValueRecord())
+            rec2 = values[glyph1][glyph2]
+            if side == "left":
+                self.ValueFormat1 |= mask
+                vr = rec2[0]
+            else:
+                self.ValueFormat2 |= mask
+                vr = rec2[1]
+            assert not hasattr(vr, what), (vr, what)
+            setattr(vr, what, value)
+        self.Coverage = makeCoverage(set(values.keys()), font)
+        self.PairSet = []
+        for glyph1 in self.Coverage.glyphs:
+            values1 = values[glyph1]
+            pairset = ot.PairSet()
+            records = pairset.PairValueRecord = []
+            for glyph2 in sorted(values1.keys(), key=font.getGlyphID):
+                values2 = values1[glyph2]
+                pair = ot.PairValueRecord()
+                pair.SecondGlyph = glyph2
+                pair.Value1 = values2[0]
+                pair.Value2 = values2[1] if self.ValueFormat2 else None
+                records.append(pair)
+            pairset.PairValueCount = len(pairset.PairValueRecord)
+            self.PairSet.append(pairset)
+        self.PairSetCount = len(self.PairSet)
+    elif typ.endswith("class"):
+        self.Format = 2
+        classDefs = [None, None]
+        while lines.peeks()[0].endswith("class definition begin"):
+            typ = lines.peek()[0][: -len("class definition begin")].lower()
+            idx, klass = {
+                "first": (0, ot.ClassDef1),
+                "second": (1, ot.ClassDef2),
+            }[typ]
+            assert classDefs[idx] is None
+            classDefs[idx] = parseClassDef(lines, font, klass=klass)
+        self.ClassDef1, self.ClassDef2 = classDefs
+        self.Class1Count, self.Class2Count = (
+            1 + max(c.classDefs.values()) for c in classDefs
+        )
+        self.Class1Record = [ot.Class1Record() for i in range(self.Class1Count)]
+        for rec1 in self.Class1Record:
+            rec1.Class2Record = [ot.Class2Record() for j in range(self.Class2Count)]
+            for rec2 in rec1.Class2Record:
+                rec2.Value1 = ValueRecord()
+                rec2.Value2 = ValueRecord()
+        for line in lines:
+            assert len(line) == 4, line
+            side = line[0].split()[0].lower()
+            assert side in ("left", "right"), side
+            what = line[0][len(side) :].title().replace(" ", "")
+            mask = valueRecordFormatDict[what][0]
+            class1, class2, value = (int(x) for x in line[1:4])
+            rec2 = self.Class1Record[class1].Class2Record[class2]
+            if side == "left":
+                self.ValueFormat1 |= mask
+                vr = rec2.Value1
+            else:
+                self.ValueFormat2 |= mask
+                vr = rec2.Value2
+            assert not hasattr(vr, what), (vr, what)
+            setattr(vr, what, value)
+        for rec1 in self.Class1Record:
+            for rec2 in rec1.Class2Record:
+                rec2.Value1 = ValueRecord(self.ValueFormat1, rec2.Value1)
+                rec2.Value2 = (
+                    ValueRecord(self.ValueFormat2, rec2.Value2)
+                    if self.ValueFormat2
+                    else None
+                )
+
+        self.Coverage = makeCoverage(set(self.ClassDef1.classDefs.keys()), font)
+    else:
+        assert 0, typ
+    return self
+
+
+def parseKernset(lines, font, _lookupMap=None):
+    typ = lines.peeks()[0].split()[0].lower()
+    if typ in ("left", "right"):
+        with lines.until(
+            ("firstclass definition begin", "secondclass definition begin")
+        ):
+            return parsePair(lines, font)
+    return parsePair(lines, font)
+
+
+def makeAnchor(data, klass=ot.Anchor):
+    assert len(data) <= 2
+    anchor = klass()
+    anchor.Format = 1
+    anchor.XCoordinate, anchor.YCoordinate = intSplitComma(data[0])
+    if len(data) > 1 and data[1] != "":
+        anchor.Format = 2
+        anchor.AnchorPoint = int(data[1])
+    return anchor
+
+
+def parseCursive(lines, font, _lookupMap=None):
+    records = {}
+    for line in lines:
+        assert len(line) in [3, 4], line
+        idx, klass = {
+            "entry": (0, ot.EntryAnchor),
+            "exit": (1, ot.ExitAnchor),
+        }[line[0]]
+        glyph = makeGlyph(line[1])
+        if glyph not in records:
+            records[glyph] = [None, None]
+        assert records[glyph][idx] is None, (glyph, idx)
+        records[glyph][idx] = makeAnchor(line[2:], klass)
+    return otl.buildCursivePosSubtable(records, font.getReverseGlyphMap())
+
+
+def makeMarkRecords(data, coverage, c):
+    records = []
+    for glyph in coverage.glyphs:
+        klass, anchor = data[glyph]
+        record = c.MarkRecordClass()
+        record.Class = klass
+        setattr(record, c.MarkAnchor, anchor)
+        records.append(record)
+    return records
+
+
+def makeBaseRecords(data, coverage, c, classCount):
+    records = []
+    idx = {}
+    for glyph in coverage.glyphs:
+        idx[glyph] = len(records)
+        record = c.BaseRecordClass()
+        anchors = [None] * classCount
+        setattr(record, c.BaseAnchor, anchors)
+        records.append(record)
+    for (glyph, klass), anchor in data.items():
+        record = records[idx[glyph]]
+        anchors = getattr(record, c.BaseAnchor)
+        assert anchors[klass] is None, (glyph, klass)
+        anchors[klass] = anchor
+    return records
+
+
+def makeLigatureRecords(data, coverage, c, classCount):
+    records = [None] * len(coverage.glyphs)
+    idx = {g: i for i, g in enumerate(coverage.glyphs)}
+
+    for (glyph, klass, compIdx, compCount), anchor in data.items():
+        record = records[idx[glyph]]
+        if record is None:
+            record = records[idx[glyph]] = ot.LigatureAttach()
+            record.ComponentCount = compCount
+            record.ComponentRecord = [ot.ComponentRecord() for i in range(compCount)]
+            for compRec in record.ComponentRecord:
+                compRec.LigatureAnchor = [None] * classCount
+        assert record.ComponentCount == compCount, (
+            glyph,
+            record.ComponentCount,
+            compCount,
+        )
+
+        anchors = record.ComponentRecord[compIdx - 1].LigatureAnchor
+        assert anchors[klass] is None, (glyph, compIdx, klass)
+        anchors[klass] = anchor
+    return records
+
+
+def parseMarkToSomething(lines, font, c):
+    self = c.Type()
+    self.Format = 1
+    markData = {}
+    baseData = {}
+    Data = {
+        "mark": (markData, c.MarkAnchorClass),
+        "base": (baseData, c.BaseAnchorClass),
+        "ligature": (baseData, c.BaseAnchorClass),
+    }
+    maxKlass = 0
+    for line in lines:
+        typ = line[0]
+        assert typ in ("mark", "base", "ligature")
+        glyph = makeGlyph(line[1])
+        data, anchorClass = Data[typ]
+        extraItems = 2 if typ == "ligature" else 0
+        extras = tuple(int(i) for i in line[2 : 2 + extraItems])
+        klass = int(line[2 + extraItems])
+        anchor = makeAnchor(line[3 + extraItems :], anchorClass)
+        if typ == "mark":
+            key, value = glyph, (klass, anchor)
+        else:
+            key, value = ((glyph, klass) + extras), anchor
+        assert key not in data, key
+        data[key] = value
+        maxKlass = max(maxKlass, klass)
+
+    # Mark
+    markCoverage = makeCoverage(set(markData.keys()), font, c.MarkCoverageClass)
+    markArray = c.MarkArrayClass()
+    markRecords = makeMarkRecords(markData, markCoverage, c)
+    setattr(markArray, c.MarkRecord, markRecords)
+    setattr(markArray, c.MarkCount, len(markRecords))
+    setattr(self, c.MarkCoverage, markCoverage)
+    setattr(self, c.MarkArray, markArray)
+    self.ClassCount = maxKlass + 1
+
+    # Base
+    self.classCount = 0 if not baseData else 1 + max(k[1] for k, v in baseData.items())
+    baseCoverage = makeCoverage(
+        set([k[0] for k in baseData.keys()]), font, c.BaseCoverageClass
+    )
+    baseArray = c.BaseArrayClass()
+    if c.Base == "Ligature":
+        baseRecords = makeLigatureRecords(baseData, baseCoverage, c, self.classCount)
+    else:
+        baseRecords = makeBaseRecords(baseData, baseCoverage, c, self.classCount)
+    setattr(baseArray, c.BaseRecord, baseRecords)
+    setattr(baseArray, c.BaseCount, len(baseRecords))
+    setattr(self, c.BaseCoverage, baseCoverage)
+    setattr(self, c.BaseArray, baseArray)
+
+    return self
+
+
+class MarkHelper(object):
+    def __init__(self):
+        for Which in ("Mark", "Base"):
+            for What in ("Coverage", "Array", "Count", "Record", "Anchor"):
+                key = Which + What
+                if Which == "Mark" and What in ("Count", "Record", "Anchor"):
+                    value = key
+                else:
+                    value = getattr(self, Which) + What
+                if value == "LigatureRecord":
+                    value = "LigatureAttach"
+                setattr(self, key, value)
+                if What != "Count":
+                    klass = getattr(ot, value)
+                    setattr(self, key + "Class", klass)
+
+
+class MarkToBaseHelper(MarkHelper):
+    Mark = "Mark"
+    Base = "Base"
+    Type = ot.MarkBasePos
+
+
+class MarkToMarkHelper(MarkHelper):
+    Mark = "Mark1"
+    Base = "Mark2"
+    Type = ot.MarkMarkPos
+
+
+class MarkToLigatureHelper(MarkHelper):
+    Mark = "Mark"
+    Base = "Ligature"
+    Type = ot.MarkLigPos
+
+
+def parseMarkToBase(lines, font, _lookupMap=None):
+    return parseMarkToSomething(lines, font, MarkToBaseHelper())
+
+
+def parseMarkToMark(lines, font, _lookupMap=None):
+    return parseMarkToSomething(lines, font, MarkToMarkHelper())
+
+
+def parseMarkToLigature(lines, font, _lookupMap=None):
+    return parseMarkToSomething(lines, font, MarkToLigatureHelper())
+
+
+def stripSplitComma(line):
+    return [s.strip() for s in line.split(",")] if line else []
+
+
+def intSplitComma(line):
+    return [int(i) for i in line.split(",")] if line else []
+
+
+# Copied from fontTools.subset
+class ContextHelper(object):
+    def __init__(self, klassName, Format):
+        if klassName.endswith("Subst"):
+            Typ = "Sub"
+            Type = "Subst"
+        else:
+            Typ = "Pos"
+            Type = "Pos"
+        if klassName.startswith("Chain"):
+            Chain = "Chain"
+            InputIdx = 1
+            DataLen = 3
+        else:
+            Chain = ""
+            InputIdx = 0
+            DataLen = 1
+        ChainTyp = Chain + Typ
+
+        self.Typ = Typ
+        self.Type = Type
+        self.Chain = Chain
+        self.ChainTyp = ChainTyp
+        self.InputIdx = InputIdx
+        self.DataLen = DataLen
+
+        self.LookupRecord = Type + "LookupRecord"
+
+        if Format == 1:
+            Coverage = lambda r: r.Coverage
+            ChainCoverage = lambda r: r.Coverage
+            ContextData = lambda r: (None,)
+            ChainContextData = lambda r: (None, None, None)
+            SetContextData = None
+            SetChainContextData = None
+            RuleData = lambda r: (r.Input,)
+            ChainRuleData = lambda r: (r.Backtrack, r.Input, r.LookAhead)
+
+            def SetRuleData(r, d):
+                (r.Input,) = d
+                (r.GlyphCount,) = (len(x) + 1 for x in d)
+
+            def ChainSetRuleData(r, d):
+                (r.Backtrack, r.Input, r.LookAhead) = d
+                (
+                    r.BacktrackGlyphCount,
+                    r.InputGlyphCount,
+                    r.LookAheadGlyphCount,
+                ) = (len(d[0]), len(d[1]) + 1, len(d[2]))
+
+        elif Format == 2:
+            Coverage = lambda r: r.Coverage
+            ChainCoverage = lambda r: r.Coverage
+            ContextData = lambda r: (r.ClassDef,)
+            ChainContextData = lambda r: (
+                r.BacktrackClassDef,
+                r.InputClassDef,
+                r.LookAheadClassDef,
+            )
+
+            def SetContextData(r, d):
+                (r.ClassDef,) = d
+
+            def SetChainContextData(r, d):
+                (r.BacktrackClassDef, r.InputClassDef, r.LookAheadClassDef) = d
+
+            RuleData = lambda r: (r.Class,)
+            ChainRuleData = lambda r: (r.Backtrack, r.Input, r.LookAhead)
+
+            def SetRuleData(r, d):
+                (r.Class,) = d
+                (r.GlyphCount,) = (len(x) + 1 for x in d)
+
+            def ChainSetRuleData(r, d):
+                (r.Backtrack, r.Input, r.LookAhead) = d
+                (
+                    r.BacktrackGlyphCount,
+                    r.InputGlyphCount,
+                    r.LookAheadGlyphCount,
+                ) = (len(d[0]), len(d[1]) + 1, len(d[2]))
+
+        elif Format == 3:
+            Coverage = lambda r: r.Coverage[0]
+            ChainCoverage = lambda r: r.InputCoverage[0]
+            ContextData = None
+            ChainContextData = None
+            SetContextData = None
+            SetChainContextData = None
+            RuleData = lambda r: r.Coverage
+            ChainRuleData = lambda r: (
+                r.BacktrackCoverage + r.InputCoverage + r.LookAheadCoverage
+            )
+
+            def SetRuleData(r, d):
+                (r.Coverage,) = d
+                (r.GlyphCount,) = (len(x) for x in d)
+
+            def ChainSetRuleData(r, d):
+                (r.BacktrackCoverage, r.InputCoverage, r.LookAheadCoverage) = d
+                (
+                    r.BacktrackGlyphCount,
+                    r.InputGlyphCount,
+                    r.LookAheadGlyphCount,
+                ) = (len(x) for x in d)
+
+        else:
+            assert 0, "unknown format: %s" % Format
+
+        if Chain:
+            self.Coverage = ChainCoverage
+            self.ContextData = ChainContextData
+            self.SetContextData = SetChainContextData
+            self.RuleData = ChainRuleData
+            self.SetRuleData = ChainSetRuleData
+        else:
+            self.Coverage = Coverage
+            self.ContextData = ContextData
+            self.SetContextData = SetContextData
+            self.RuleData = RuleData
+            self.SetRuleData = SetRuleData
+
+        if Format == 1:
+            self.Rule = ChainTyp + "Rule"
+            self.RuleCount = ChainTyp + "RuleCount"
+            self.RuleSet = ChainTyp + "RuleSet"
+            self.RuleSetCount = ChainTyp + "RuleSetCount"
+            self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else []
+        elif Format == 2:
+            self.Rule = ChainTyp + "ClassRule"
+            self.RuleCount = ChainTyp + "ClassRuleCount"
+            self.RuleSet = ChainTyp + "ClassSet"
+            self.RuleSetCount = ChainTyp + "ClassSetCount"
+            self.Intersect = lambda glyphs, c, r: (
+                c.intersect_class(glyphs, r)
+                if c
+                else (set(glyphs) if r == 0 else set())
+            )
+
+            self.ClassDef = "InputClassDef" if Chain else "ClassDef"
+            self.ClassDefIndex = 1 if Chain else 0
+            self.Input = "Input" if Chain else "Class"
+
+
+def parseLookupRecords(items, klassName, lookupMap=None):
+    klass = getattr(ot, klassName)
+    lst = []
+    for item in items:
+        rec = klass()
+        item = stripSplitComma(item)
+        assert len(item) == 2, item
+        idx = int(item[0])
+        assert idx > 0, idx
+        rec.SequenceIndex = idx - 1
+        setReference(mapLookup, lookupMap, item[1], setattr, rec, "LookupListIndex")
+        lst.append(rec)
+    return lst
+
+
+def makeClassDef(classDefs, font, klass=ot.Coverage):
+    if not classDefs:
+        return None
+    self = klass()
+    self.classDefs = dict(classDefs)
+    return self
+
+
+def parseClassDef(lines, font, klass=ot.ClassDef):
+    classDefs = {}
+    with lines.between("class definition"):
+        for line in lines:
+            glyph = makeGlyph(line[0])
+            assert glyph not in classDefs, glyph
+            classDefs[glyph] = int(line[1])
+    return makeClassDef(classDefs, font, klass)
+
+
+def makeCoverage(glyphs, font, klass=ot.Coverage):
+    if not glyphs:
+        return None
+    if isinstance(glyphs, set):
+        glyphs = sorted(glyphs)
+    coverage = klass()
+    coverage.glyphs = sorted(set(glyphs), key=font.getGlyphID)
+    return coverage
+
+
+def parseCoverage(lines, font, klass=ot.Coverage):
+    glyphs = []
+    with lines.between("coverage definition"):
+        for line in lines:
+            glyphs.append(makeGlyph(line[0]))
+    return makeCoverage(glyphs, font, klass)
+
+
+def bucketizeRules(self, c, rules, bucketKeys):
+    buckets = {}
+    for seq, recs in rules:
+        buckets.setdefault(seq[c.InputIdx][0], []).append(
+            (tuple(s[1 if i == c.InputIdx else 0 :] for i, s in enumerate(seq)), recs)
+        )
+
+    rulesets = []
+    for firstGlyph in bucketKeys:
+        if firstGlyph not in buckets:
+            rulesets.append(None)
+            continue
+        thisRules = []
+        for seq, recs in buckets[firstGlyph]:
+            rule = getattr(ot, c.Rule)()
+            c.SetRuleData(rule, seq)
+            setattr(rule, c.Type + "Count", len(recs))
+            setattr(rule, c.LookupRecord, recs)
+            thisRules.append(rule)
+
+        ruleset = getattr(ot, c.RuleSet)()
+        setattr(ruleset, c.Rule, thisRules)
+        setattr(ruleset, c.RuleCount, len(thisRules))
+        rulesets.append(ruleset)
+
+    setattr(self, c.RuleSet, rulesets)
+    setattr(self, c.RuleSetCount, len(rulesets))
+
+
+def parseContext(lines, font, Type, lookupMap=None):
+    self = getattr(ot, Type)()
+    typ = lines.peeks()[0].split()[0].lower()
+    if typ == "glyph":
+        self.Format = 1
+        log.debug("Parsing %s format %s", Type, self.Format)
+        c = ContextHelper(Type, self.Format)
+        rules = []
+        for line in lines:
+            assert line[0].lower() == "glyph", line[0]
+            while len(line) < 1 + c.DataLen:
+                line.append("")
+            seq = tuple(makeGlyphs(stripSplitComma(i)) for i in line[1 : 1 + c.DataLen])
+            recs = parseLookupRecords(line[1 + c.DataLen :], c.LookupRecord, lookupMap)
+            rules.append((seq, recs))
+
+        firstGlyphs = set(seq[c.InputIdx][0] for seq, recs in rules)
+        self.Coverage = makeCoverage(firstGlyphs, font)
+        bucketizeRules(self, c, rules, self.Coverage.glyphs)
+    elif typ.endswith("class"):
+        self.Format = 2
+        log.debug("Parsing %s format %s", Type, self.Format)
+        c = ContextHelper(Type, self.Format)
+        classDefs = [None] * c.DataLen
+        while lines.peeks()[0].endswith("class definition begin"):
+            typ = lines.peek()[0][: -len("class definition begin")].lower()
+            idx, klass = {
+                1: {
+                    "": (0, ot.ClassDef),
+                },
+                3: {
+                    "backtrack": (0, ot.BacktrackClassDef),
+                    "": (1, ot.InputClassDef),
+                    "lookahead": (2, ot.LookAheadClassDef),
+                },
+            }[c.DataLen][typ]
+            assert classDefs[idx] is None, idx
+            classDefs[idx] = parseClassDef(lines, font, klass=klass)
+        c.SetContextData(self, classDefs)
+        rules = []
+        for line in lines:
+            assert line[0].lower().startswith("class"), line[0]
+            while len(line) < 1 + c.DataLen:
+                line.append("")
+            seq = tuple(intSplitComma(i) for i in line[1 : 1 + c.DataLen])
+            recs = parseLookupRecords(line[1 + c.DataLen :], c.LookupRecord, lookupMap)
+            rules.append((seq, recs))
+        firstClasses = set(seq[c.InputIdx][0] for seq, recs in rules)
+        firstGlyphs = set(
+            g for g, c in classDefs[c.InputIdx].classDefs.items() if c in firstClasses
+        )
+        self.Coverage = makeCoverage(firstGlyphs, font)
+        bucketizeRules(self, c, rules, range(max(firstClasses) + 1))
+    elif typ.endswith("coverage"):
+        self.Format = 3
+        log.debug("Parsing %s format %s", Type, self.Format)
+        c = ContextHelper(Type, self.Format)
+        coverages = tuple([] for i in range(c.DataLen))
+        while lines.peeks()[0].endswith("coverage definition begin"):
+            typ = lines.peek()[0][: -len("coverage definition begin")].lower()
+            idx, klass = {
+                1: {
+                    "": (0, ot.Coverage),
+                },
+                3: {
+                    "backtrack": (0, ot.BacktrackCoverage),
+                    "input": (1, ot.InputCoverage),
+                    "lookahead": (2, ot.LookAheadCoverage),
+                },
+            }[c.DataLen][typ]
+            coverages[idx].append(parseCoverage(lines, font, klass=klass))
+        c.SetRuleData(self, coverages)
+        lines = list(lines)
+        assert len(lines) == 1
+        line = lines[0]
+        assert line[0].lower() == "coverage", line[0]
+        recs = parseLookupRecords(line[1:], c.LookupRecord, lookupMap)
+        setattr(self, c.Type + "Count", len(recs))
+        setattr(self, c.LookupRecord, recs)
+    else:
+        assert 0, typ
+    return self
+
+
+def parseContextSubst(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ContextSubst", lookupMap=lookupMap)
+
+
+def parseContextPos(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ContextPos", lookupMap=lookupMap)
+
+
+def parseChainedSubst(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ChainContextSubst", lookupMap=lookupMap)
+
+
+def parseChainedPos(lines, font, lookupMap=None):
+    return parseContext(lines, font, "ChainContextPos", lookupMap=lookupMap)
+
+
+def parseReverseChainedSubst(lines, font, _lookupMap=None):
+    self = ot.ReverseChainSingleSubst()
+    self.Format = 1
+    coverages = ([], [])
+    while lines.peeks()[0].endswith("coverage definition begin"):
+        typ = lines.peek()[0][: -len("coverage definition begin")].lower()
+        idx, klass = {
+            "backtrack": (0, ot.BacktrackCoverage),
+            "lookahead": (1, ot.LookAheadCoverage),
+        }[typ]
+        coverages[idx].append(parseCoverage(lines, font, klass=klass))
+    self.BacktrackCoverage = coverages[0]
+    self.BacktrackGlyphCount = len(self.BacktrackCoverage)
+    self.LookAheadCoverage = coverages[1]
+    self.LookAheadGlyphCount = len(self.LookAheadCoverage)
+    mapping = {}
+    for line in lines:
+        assert len(line) == 2, line
+        line = makeGlyphs(line)
+        mapping[line[0]] = line[1]
+    self.Coverage = makeCoverage(set(mapping.keys()), font)
+    self.Substitute = [mapping[k] for k in self.Coverage.glyphs]
+    self.GlyphCount = len(self.Substitute)
+    return self
+
+
+def parseLookup(lines, tableTag, font, lookupMap=None):
+    line = lines.expect("lookup")
+    _, name, typ = line
+    log.debug("Parsing lookup type %s %s", typ, name)
+    lookup = ot.Lookup()
+    lookup.LookupFlag, filterset = parseLookupFlags(lines)
+    if filterset is not None:
+        lookup.MarkFilteringSet = filterset
+    lookup.LookupType, parseLookupSubTable = {
+        "GSUB": {
+            "single": (1, parseSingleSubst),
+            "multiple": (2, parseMultiple),
+            "alternate": (3, parseAlternate),
+            "ligature": (4, parseLigature),
+            "context": (5, parseContextSubst),
+            "chained": (6, parseChainedSubst),
+            "reversechained": (8, parseReverseChainedSubst),
+        },
+        "GPOS": {
+            "single": (1, parseSinglePos),
+            "pair": (2, parsePair),
+            "kernset": (2, parseKernset),
+            "cursive": (3, parseCursive),
+            "mark to base": (4, parseMarkToBase),
+            "mark to ligature": (5, parseMarkToLigature),
+            "mark to mark": (6, parseMarkToMark),
+            "context": (7, parseContextPos),
+            "chained": (8, parseChainedPos),
+        },
+    }[tableTag][typ]
+
+    with lines.until("lookup end"):
+        subtables = []
+
+        while lines.peek():
+            with lines.until(("% subtable", "subtable end")):
+                while lines.peek():
+                    subtable = parseLookupSubTable(lines, font, lookupMap)
+                    assert lookup.LookupType == subtable.LookupType
+                    subtables.append(subtable)
+            if lines.peeks()[0] in ("% subtable", "subtable end"):
+                next(lines)
+    lines.expect("lookup end")
+
+    lookup.SubTable = subtables
+    lookup.SubTableCount = len(lookup.SubTable)
+    if lookup.SubTableCount == 0:
+        # Remove this return when following is fixed:
+        # https://github.com/fonttools/fonttools/issues/789
+        return None
+    return lookup
+
+
+def parseGSUBGPOS(lines, font, tableTag):
+    container = ttLib.getTableClass(tableTag)()
+    lookupMap = DeferredMapping()
+    featureMap = DeferredMapping()
+    assert tableTag in ("GSUB", "GPOS")
+    log.debug("Parsing %s", tableTag)
+    self = getattr(ot, tableTag)()
+    self.Version = 0x00010000
+    fields = {
+        "script table begin": (
+            "ScriptList",
+            lambda lines: parseScriptList(lines, featureMap),
+        ),
+        "feature table begin": (
+            "FeatureList",
+            lambda lines: parseFeatureList(lines, lookupMap, featureMap),
+        ),
+        "lookup": ("LookupList", None),
+    }
+    for attr, parser in fields.values():
+        setattr(self, attr, None)
+    while lines.peek() is not None:
+        typ = lines.peek()[0].lower()
+        if typ not in fields:
+            log.debug("Skipping %s", lines.peek())
+            next(lines)
+            continue
+        attr, parser = fields[typ]
+        if typ == "lookup":
+            if self.LookupList is None:
+                self.LookupList = ot.LookupList()
+                self.LookupList.Lookup = []
+            _, name, _ = lines.peek()
+            lookup = parseLookup(lines, tableTag, font, lookupMap)
+            if lookupMap is not None:
+                assert name not in lookupMap, "Duplicate lookup name: %s" % name
+                lookupMap[name] = len(self.LookupList.Lookup)
+            else:
+                assert int(name) == len(self.LookupList.Lookup), "%d %d" % (
+                    name,
+                    len(self.Lookup),
+                )
+            self.LookupList.Lookup.append(lookup)
+        else:
+            assert getattr(self, attr) is None, attr
+            setattr(self, attr, parser(lines))
+    if self.LookupList:
+        self.LookupList.LookupCount = len(self.LookupList.Lookup)
+    if lookupMap is not None:
+        lookupMap.applyDeferredMappings()
+        if os.environ.get(LOOKUP_DEBUG_ENV_VAR):
+            if "Debg" not in font:
+                font["Debg"] = newTable("Debg")
+                font["Debg"].data = {}
+            debug = (
+                font["Debg"]
+                .data.setdefault(LOOKUP_DEBUG_INFO_KEY, {})
+                .setdefault(tableTag, {})
+            )
+            for name, lookup in lookupMap.items():
+                debug[str(lookup)] = ["", name, ""]
+
+        featureMap.applyDeferredMappings()
+    container.table = self
+    return container
+
+
+def parseGSUB(lines, font):
+    return parseGSUBGPOS(lines, font, "GSUB")
+
+
+def parseGPOS(lines, font):
+    return parseGSUBGPOS(lines, font, "GPOS")
+
+
+def parseAttachList(lines, font):
+    points = {}
+    with lines.between("attachment list"):
+        for line in lines:
+            glyph = makeGlyph(line[0])
+            assert glyph not in points, glyph
+            points[glyph] = [int(i) for i in line[1:]]
+    return otl.buildAttachList(points, font.getReverseGlyphMap())
+
+
+def parseCaretList(lines, font):
+    carets = {}
+    with lines.between("carets"):
+        for line in lines:
+            glyph = makeGlyph(line[0])
+            assert glyph not in carets, glyph
+            num = int(line[1])
+            thisCarets = [int(i) for i in line[2:]]
+            assert num == len(thisCarets), line
+            carets[glyph] = thisCarets
+    return otl.buildLigCaretList(carets, {}, font.getReverseGlyphMap())
+
+
+def makeMarkFilteringSets(sets, font):
+    self = ot.MarkGlyphSetsDef()
+    self.MarkSetTableFormat = 1
+    self.MarkSetCount = 1 + max(sets.keys())
+    self.Coverage = [None] * self.MarkSetCount
+    for k, v in sorted(sets.items()):
+        self.Coverage[k] = makeCoverage(set(v), font)
+    return self
+
+
+def parseMarkFilteringSets(lines, font):
+    sets = {}
+    with lines.between("set definition"):
+        for line in lines:
+            assert len(line) == 2, line
+            glyph = makeGlyph(line[0])
+            # TODO accept set names
+            st = int(line[1])
+            if st not in sets:
+                sets[st] = []
+            sets[st].append(glyph)
+    return makeMarkFilteringSets(sets, font)
+
+
+def parseGDEF(lines, font):
+    container = ttLib.getTableClass("GDEF")()
+    log.debug("Parsing GDEF")
+    self = ot.GDEF()
+    fields = {
+        "class definition begin": (
+            "GlyphClassDef",
+            lambda lines, font: parseClassDef(lines, font, klass=ot.GlyphClassDef),
+        ),
+        "attachment list begin": ("AttachList", parseAttachList),
+        "carets begin": ("LigCaretList", parseCaretList),
+        "mark attachment class definition begin": (
+            "MarkAttachClassDef",
+            lambda lines, font: parseClassDef(lines, font, klass=ot.MarkAttachClassDef),
+        ),
+        "markfilter set definition begin": ("MarkGlyphSetsDef", parseMarkFilteringSets),
+    }
+    for attr, parser in fields.values():
+        setattr(self, attr, None)
+    while lines.peek() is not None:
+        typ = lines.peek()[0].lower()
+        if typ not in fields:
+            log.debug("Skipping %s", typ)
+            next(lines)
+            continue
+        attr, parser = fields[typ]
+        assert getattr(self, attr) is None, attr
+        setattr(self, attr, parser(lines, font))
+    self.Version = 0x00010000 if self.MarkGlyphSetsDef is None else 0x00010002
+    container.table = self
+    return container
+
+
+def parseCmap(lines, font):
+    container = ttLib.getTableClass("cmap")()
+    log.debug("Parsing cmap")
+    tables = []
+    while lines.peek() is not None:
+        lines.expect("cmap subtable %d" % len(tables))
+        platId, encId, fmt, lang = [
+            parseCmapId(lines, field)
+            for field in ("platformID", "encodingID", "format", "language")
+        ]
+        table = cmap_classes[fmt](fmt)
+        table.platformID = platId
+        table.platEncID = encId
+        table.language = lang
+        table.cmap = {}
+        line = next(lines)
+        while line[0] != "end subtable":
+            table.cmap[int(line[0], 16)] = line[1]
+            line = next(lines)
+        tables.append(table)
+    container.tableVersion = 0
+    container.tables = tables
+    return container
+
+
+def parseCmapId(lines, field):
+    line = next(lines)
+    assert field == line[0]
+    return int(line[1])
+
+
+def parseTable(lines, font, tableTag=None):
+    log.debug("Parsing table")
+    line = lines.peeks()
+    tag = None
+    if line[0].split()[0] == "FontDame":
+        tag = line[0].split()[1]
+    elif " ".join(line[0].split()[:3]) == "Font Chef Table":
+        tag = line[0].split()[3]
+    if tag is not None:
+        next(lines)
+        tag = tag.ljust(4)
+        if tableTag is None:
+            tableTag = tag
+        else:
+            assert tableTag == tag, (tableTag, tag)
+
+    assert (
+        tableTag is not None
+    ), "Don't know what table to parse and data doesn't specify"
+
+    return {
+        "GSUB": parseGSUB,
+        "GPOS": parseGPOS,
+        "GDEF": parseGDEF,
+        "cmap": parseCmap,
+    }[tableTag](lines, font)
+
+
+class Tokenizer(object):
+    def __init__(self, f):
+        # TODO BytesIO / StringIO as needed?  also, figure out whether we work on bytes or unicode
+        lines = iter(f)
+        try:
+            self.filename = f.name
+        except:
+            self.filename = None
+        self.lines = iter(lines)
+        self.line = ""
+        self.lineno = 0
+        self.stoppers = []
+        self.buffer = None
+
+    def __iter__(self):
+        return self
+
+    def _next_line(self):
+        self.lineno += 1
+        line = self.line = next(self.lines)
+        line = [s.strip() for s in line.split("\t")]
+        if len(line) == 1 and not line[0]:
+            del line[0]
+        if line and not line[-1]:
+            log.warning("trailing tab found on line %d: %s" % (self.lineno, self.line))
+            while line and not line[-1]:
+                del line[-1]
+        return line
+
+    def _next_nonempty(self):
+        while True:
+            line = self._next_line()
+            # Skip comments and empty lines
+            if line and line[0] and (line[0][0] != "%" or line[0] == "% subtable"):
+                return line
+
+    def _next_buffered(self):
+        if self.buffer:
+            ret = self.buffer
+            self.buffer = None
+            return ret
+        else:
+            return self._next_nonempty()
+
+    def __next__(self):
+        line = self._next_buffered()
+        if line[0].lower() in self.stoppers:
+            self.buffer = line
+            raise StopIteration
+        return line
+
+    def next(self):
+        return self.__next__()
+
+    def peek(self):
+        if not self.buffer:
+            try:
+                self.buffer = self._next_nonempty()
+            except StopIteration:
+                return None
+        if self.buffer[0].lower() in self.stoppers:
+            return None
+        return self.buffer
+
+    def peeks(self):
+        ret = self.peek()
+        return ret if ret is not None else ("",)
+
+    @contextmanager
+    def between(self, tag):
+        start = tag + " begin"
+        end = tag + " end"
+        self.expectendswith(start)
+        self.stoppers.append(end)
+        yield
+        del self.stoppers[-1]
+        self.expect(tag + " end")
+
+    @contextmanager
+    def until(self, tags):
+        if type(tags) is not tuple:
+            tags = (tags,)
+        self.stoppers.extend(tags)
+        yield
+        del self.stoppers[-len(tags) :]
+
+    def expect(self, s):
+        line = next(self)
+        tag = line[0].lower()
+        assert tag == s, "Expected '%s', got '%s'" % (s, tag)
+        return line
+
+    def expectendswith(self, s):
+        line = next(self)
+        tag = line[0].lower()
+        assert tag.endswith(s), "Expected '*%s', got '%s'" % (s, tag)
+        return line
+
+
+def build(f, font, tableTag=None):
+    """Convert a Monotype font layout file to an OpenType layout object
+
+    A font object must be passed, but this may be a "dummy" font; it is only
+    used for sorting glyph sets when making coverage tables and to hold the
+    OpenType layout table while it is being built.
+
+    Args:
+            f: A file object.
+            font (TTFont): A font object.
+            tableTag (string): If provided, asserts that the file contains data for the
+                    given OpenType table.
+
+    Returns:
+            An object representing the table. (e.g. ``table_G_S_U_B_``)
+    """
+    lines = Tokenizer(f)
+    return parseTable(lines, font, tableTag=tableTag)
+
+
+def main(args=None, font=None):
+    """Convert a FontDame OTL file to TTX XML
+
+    Writes XML output to stdout.
+
+    Args:
+            args: Command line arguments (``--font``, ``--table``, input files).
+    """
+    import sys
+    from fontTools import configLogger
+    from fontTools.misc.testTools import MockFont
+
+    if args is None:
+        args = sys.argv[1:]
+
+    # configure the library logger (for >= WARNING)
+    configLogger()
+    # comment this out to enable debug messages from mtiLib's logger
+    # log.setLevel(logging.DEBUG)
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools mtiLib",
+        description=main.__doc__,
+    )
+
+    parser.add_argument(
+        "--font",
+        "-f",
+        metavar="FILE",
+        dest="font",
+        help="Input TTF files (used for glyph classes and sorting coverage tables)",
+    )
+    parser.add_argument(
+        "--table",
+        "-t",
+        metavar="TABLE",
+        dest="tableTag",
+        help="Table to fill (sniffed from input file if not provided)",
+    )
+    parser.add_argument(
+        "inputs", metavar="FILE", type=str, nargs="+", help="Input FontDame .txt files"
+    )
+
+    args = parser.parse_args(args)
+
+    if font is None:
+        if args.font:
+            font = ttLib.TTFont(args.font)
+        else:
+            font = MockFont()
+
+    for f in args.inputs:
+        log.debug("Processing %s", f)
+        with open(f, "rt", encoding="utf-8") as f:
+            table = build(f, font, tableTag=args.tableTag)
+        blob = table.compile(font)  # Make sure it compiles
+        decompiled = table.__class__()
+        decompiled.decompile(blob, font)  # Make sure it decompiles!
+
+        # continue
+        from fontTools.misc import xmlWriter
+
+        tag = table.tableTag
+        writer = xmlWriter.XMLWriter(sys.stdout)
+        writer.begintag(tag)
+        writer.newline()
+        # table.toXML(writer, font)
+        decompiled.toXML(writer, font)
+        writer.endtag(tag)
+        writer.newline()
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

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

evalkit_tf437/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)

evalkit_tf437/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)

evalkit_tf437/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())