Add files using upload-large-folder tool

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

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

evalkit_tf437/lib/python3.10/site-packages/fontTools/designspaceLib/types.py

@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union, cast
+
+from fontTools.designspaceLib import (
+    AxisDescriptor,
+    DesignSpaceDocument,
+    DesignSpaceDocumentError,
+    RangeAxisSubsetDescriptor,
+    SimpleLocationDict,
+    ValueAxisSubsetDescriptor,
+    VariableFontDescriptor,
+)
+
+
+def clamp(value, minimum, maximum):
+    return min(max(value, minimum), maximum)
+
+
+@dataclass
+class Range:
+    minimum: float
+    """Inclusive minimum of the range."""
+    maximum: float
+    """Inclusive maximum of the range."""
+    default: float = 0
+    """Default value"""
+
+    def __post_init__(self):
+        self.minimum, self.maximum = sorted((self.minimum, self.maximum))
+        self.default = clamp(self.default, self.minimum, self.maximum)
+
+    def __contains__(self, value: Union[float, Range]) -> bool:
+        if isinstance(value, Range):
+            return self.minimum <= value.minimum and value.maximum <= self.maximum
+        return self.minimum <= value <= self.maximum
+
+    def intersection(self, other: Range) -> Optional[Range]:
+        if self.maximum < other.minimum or self.minimum > other.maximum:
+            return None
+        else:
+            return Range(
+                max(self.minimum, other.minimum),
+                min(self.maximum, other.maximum),
+                self.default,  # We don't care about the default in this use-case
+            )
+
+
+# A region selection is either a range or a single value, as a Designspace v5
+# axis-subset element only allows a single discrete value or a range for a
+# variable-font element.
+Region = Dict[str, Union[Range, float]]
+
+# A conditionset is a set of named ranges.
+ConditionSet = Dict[str, Range]
+
+# A rule is a list of conditionsets where any has to be relevant for the whole rule to be relevant.
+Rule = List[ConditionSet]
+Rules = Dict[str, Rule]
+
+
+def locationInRegion(location: SimpleLocationDict, region: Region) -> bool:
+    for name, value in location.items():
+        if name not in region:
+            return False
+        regionValue = region[name]
+        if isinstance(regionValue, (float, int)):
+            if value != regionValue:
+                return False
+        else:
+            if value not in regionValue:
+                return False
+    return True
+
+
+def regionInRegion(region: Region, superRegion: Region) -> bool:
+    for name, value in region.items():
+        if not name in superRegion:
+            return False
+        superValue = superRegion[name]
+        if isinstance(superValue, (float, int)):
+            if value != superValue:
+                return False
+        else:
+            if value not in superValue:
+                return False
+    return True
+
+
+def userRegionToDesignRegion(doc: DesignSpaceDocument, userRegion: Region) -> Region:
+    designRegion = {}
+    for name, value in userRegion.items():
+        axis = doc.getAxis(name)
+        if axis is None:
+            raise DesignSpaceDocumentError(
+                f"Cannot find axis named '{name}' for region."
+            )
+        if isinstance(value, (float, int)):
+            designRegion[name] = axis.map_forward(value)
+        else:
+            designRegion[name] = Range(
+                axis.map_forward(value.minimum),
+                axis.map_forward(value.maximum),
+                axis.map_forward(value.default),
+            )
+    return designRegion
+
+
+def getVFUserRegion(doc: DesignSpaceDocument, vf: VariableFontDescriptor) -> Region:
+    vfUserRegion: Region = {}
+    # For each axis, 2 cases:
+    #  - it has a range = it's an axis in the VF DS
+    #  - it's a single location = use it to know which rules should apply in the VF
+    for axisSubset in vf.axisSubsets:
+        axis = doc.getAxis(axisSubset.name)
+        if axis is None:
+            raise DesignSpaceDocumentError(
+                f"Cannot find axis named '{axisSubset.name}' for variable font '{vf.name}'."
+            )
+        if hasattr(axisSubset, "userMinimum"):
+            # Mypy doesn't support narrowing union types via hasattr()
+            # TODO(Python 3.10): use TypeGuard
+            # https://mypy.readthedocs.io/en/stable/type_narrowing.html
+            axisSubset = cast(RangeAxisSubsetDescriptor, axisSubset)
+            if not hasattr(axis, "minimum"):
+                raise DesignSpaceDocumentError(
+                    f"Cannot select a range over '{axis.name}' for variable font '{vf.name}' "
+                    "because it's a discrete axis, use only 'userValue' instead."
+                )
+            axis = cast(AxisDescriptor, axis)
+            vfUserRegion[axis.name] = Range(
+                max(axisSubset.userMinimum, axis.minimum),
+                min(axisSubset.userMaximum, axis.maximum),
+                axisSubset.userDefault or axis.default,
+            )
+        else:
+            axisSubset = cast(ValueAxisSubsetDescriptor, axisSubset)
+            vfUserRegion[axis.name] = axisSubset.userValue
+    # Any axis not mentioned explicitly has a single location = default value
+    for axis in doc.axes:
+        if axis.name not in vfUserRegion:
+            assert isinstance(
+                axis.default, (int, float)
+            ), f"Axis '{axis.name}' has no valid default value."
+            vfUserRegion[axis.name] = axis.default
+    return vfUserRegion

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

@@ -0,0 +1,12 @@
+from typing import NamedTuple
+
+
+class FeatureLibLocation(NamedTuple):
+    """A location in a feature file"""
+
+    file: str
+    line: int
+    column: int
+
+    def __str__(self):
+        return f"{self.file}:{self.line}:{self.column}"

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

@@ -0,0 +1,12 @@
+from typing import NamedTuple
+
+LOOKUP_DEBUG_INFO_KEY = "com.github.fonttools.feaLib"
+LOOKUP_DEBUG_ENV_VAR = "FONTTOOLS_LOOKUP_DEBUGGING"
+
+
+class LookupDebugInfo(NamedTuple):
+    """Information about where a lookup came from, to be embedded in a font"""
+
+    location: str
+    name: str
+    feature: list

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

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

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

@@ -0,0 +1,526 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+from fontTools import ttLib
+from fontTools.ttLib.tables.DefaultTable import DefaultTable
+from fontTools.ttLib.tables import otTables
+from fontTools.merge.base import add_method, mergeObjects
+from fontTools.merge.util import *
+import logging
+
+
+log = logging.getLogger("fontTools.merge")
+
+
+def mergeLookupLists(lst):
+    # TODO Do smarter merge.
+    return sumLists(lst)
+
+
+def mergeFeatures(lst):
+    assert lst
+    self = otTables.Feature()
+    self.FeatureParams = None
+    self.LookupListIndex = mergeLookupLists(
+        [l.LookupListIndex for l in lst if l.LookupListIndex]
+    )
+    self.LookupCount = len(self.LookupListIndex)
+    return self
+
+
+def mergeFeatureLists(lst):
+    d = {}
+    for l in lst:
+        for f in l:
+            tag = f.FeatureTag
+            if tag not in d:
+                d[tag] = []
+            d[tag].append(f.Feature)
+    ret = []
+    for tag in sorted(d.keys()):
+        rec = otTables.FeatureRecord()
+        rec.FeatureTag = tag
+        rec.Feature = mergeFeatures(d[tag])
+        ret.append(rec)
+    return ret
+
+
+def mergeLangSyses(lst):
+    assert lst
+
+    # TODO Support merging ReqFeatureIndex
+    assert all(l.ReqFeatureIndex == 0xFFFF for l in lst)
+
+    self = otTables.LangSys()
+    self.LookupOrder = None
+    self.ReqFeatureIndex = 0xFFFF
+    self.FeatureIndex = mergeFeatureLists(
+        [l.FeatureIndex for l in lst if l.FeatureIndex]
+    )
+    self.FeatureCount = len(self.FeatureIndex)
+    return self
+
+
+def mergeScripts(lst):
+    assert lst
+
+    if len(lst) == 1:
+        return lst[0]
+    langSyses = {}
+    for sr in lst:
+        for lsr in sr.LangSysRecord:
+            if lsr.LangSysTag not in langSyses:
+                langSyses[lsr.LangSysTag] = []
+            langSyses[lsr.LangSysTag].append(lsr.LangSys)
+    lsrecords = []
+    for tag, langSys_list in sorted(langSyses.items()):
+        lsr = otTables.LangSysRecord()
+        lsr.LangSys = mergeLangSyses(langSys_list)
+        lsr.LangSysTag = tag
+        lsrecords.append(lsr)
+
+    self = otTables.Script()
+    self.LangSysRecord = lsrecords
+    self.LangSysCount = len(lsrecords)
+    dfltLangSyses = [s.DefaultLangSys for s in lst if s.DefaultLangSys]
+    if dfltLangSyses:
+        self.DefaultLangSys = mergeLangSyses(dfltLangSyses)
+    else:
+        self.DefaultLangSys = None
+    return self
+
+
+def mergeScriptRecords(lst):
+    d = {}
+    for l in lst:
+        for s in l:
+            tag = s.ScriptTag
+            if tag not in d:
+                d[tag] = []
+            d[tag].append(s.Script)
+    ret = []
+    for tag in sorted(d.keys()):
+        rec = otTables.ScriptRecord()
+        rec.ScriptTag = tag
+        rec.Script = mergeScripts(d[tag])
+        ret.append(rec)
+    return ret
+
+
+otTables.ScriptList.mergeMap = {
+    "ScriptCount": lambda lst: None,  # TODO
+    "ScriptRecord": mergeScriptRecords,
+}
+otTables.BaseScriptList.mergeMap = {
+    "BaseScriptCount": lambda lst: None,  # TODO
+    # TODO: Merge duplicate entries
+    "BaseScriptRecord": lambda lst: sorted(
+        sumLists(lst), key=lambda s: s.BaseScriptTag
+    ),
+}
+
+otTables.FeatureList.mergeMap = {
+    "FeatureCount": sum,
+    "FeatureRecord": lambda lst: sorted(sumLists(lst), key=lambda s: s.FeatureTag),
+}
+
+otTables.LookupList.mergeMap = {
+    "LookupCount": sum,
+    "Lookup": sumLists,
+}
+
+otTables.Coverage.mergeMap = {
+    "Format": min,
+    "glyphs": sumLists,
+}
+
+otTables.ClassDef.mergeMap = {
+    "Format": min,
+    "classDefs": sumDicts,
+}
+
+otTables.LigCaretList.mergeMap = {
+    "Coverage": mergeObjects,
+    "LigGlyphCount": sum,
+    "LigGlyph": sumLists,
+}
+
+otTables.AttachList.mergeMap = {
+    "Coverage": mergeObjects,
+    "GlyphCount": sum,
+    "AttachPoint": sumLists,
+}
+
+# XXX Renumber MarkFilterSets of lookups
+otTables.MarkGlyphSetsDef.mergeMap = {
+    "MarkSetTableFormat": equal,
+    "MarkSetCount": sum,
+    "Coverage": sumLists,
+}
+
+otTables.Axis.mergeMap = {
+    "*": mergeObjects,
+}
+
+# XXX Fix BASE table merging
+otTables.BaseTagList.mergeMap = {
+    "BaseTagCount": sum,
+    "BaselineTag": sumLists,
+}
+
+otTables.GDEF.mergeMap = otTables.GSUB.mergeMap = otTables.GPOS.mergeMap = (
+    otTables.BASE.mergeMap
+) = otTables.JSTF.mergeMap = otTables.MATH.mergeMap = {
+    "*": mergeObjects,
+    "Version": max,
+}
+
+ttLib.getTableClass("GDEF").mergeMap = ttLib.getTableClass("GSUB").mergeMap = (
+    ttLib.getTableClass("GPOS").mergeMap
+) = ttLib.getTableClass("BASE").mergeMap = ttLib.getTableClass(
+    "JSTF"
+).mergeMap = ttLib.getTableClass(
+    "MATH"
+).mergeMap = {
+    "tableTag": onlyExisting(equal),  # XXX clean me up
+    "table": mergeObjects,
+}
+
+
+@add_method(ttLib.getTableClass("GSUB"))
+def merge(self, m, tables):
+    assert len(tables) == len(m.duplicateGlyphsPerFont)
+    for i, (table, dups) in enumerate(zip(tables, m.duplicateGlyphsPerFont)):
+        if not dups:
+            continue
+        if table is None or table is NotImplemented:
+            log.warning(
+                "Have non-identical duplicates to resolve for '%s' but no GSUB. Are duplicates intended?: %s",
+                m.fonts[i]._merger__name,
+                dups,
+            )
+            continue
+
+        synthFeature = None
+        synthLookup = None
+        for script in table.table.ScriptList.ScriptRecord:
+            if script.ScriptTag == "DFLT":
+                continue  # XXX
+            for langsys in [script.Script.DefaultLangSys] + [
+                l.LangSys for l in script.Script.LangSysRecord
+            ]:
+                if langsys is None:
+                    continue  # XXX Create!
+                feature = [v for v in langsys.FeatureIndex if v.FeatureTag == "locl"]
+                assert len(feature) <= 1
+                if feature:
+                    feature = feature[0]
+                else:
+                    if not synthFeature:
+                        synthFeature = otTables.FeatureRecord()
+                        synthFeature.FeatureTag = "locl"
+                        f = synthFeature.Feature = otTables.Feature()
+                        f.FeatureParams = None
+                        f.LookupCount = 0
+                        f.LookupListIndex = []
+                        table.table.FeatureList.FeatureRecord.append(synthFeature)
+                        table.table.FeatureList.FeatureCount += 1
+                    feature = synthFeature
+                    langsys.FeatureIndex.append(feature)
+                    langsys.FeatureIndex.sort(key=lambda v: v.FeatureTag)
+
+                if not synthLookup:
+                    subtable = otTables.SingleSubst()
+                    subtable.mapping = dups
+                    synthLookup = otTables.Lookup()
+                    synthLookup.LookupFlag = 0
+                    synthLookup.LookupType = 1
+                    synthLookup.SubTableCount = 1
+                    synthLookup.SubTable = [subtable]
+                    if table.table.LookupList is None:
+                        # mtiLib uses None as default value for LookupList,
+                        # while feaLib points to an empty array with count 0
+                        # TODO: make them do the same
+                        table.table.LookupList = otTables.LookupList()
+                        table.table.LookupList.Lookup = []
+                        table.table.LookupList.LookupCount = 0
+                    table.table.LookupList.Lookup.append(synthLookup)
+                    table.table.LookupList.LookupCount += 1
+
+                if feature.Feature.LookupListIndex[:1] != [synthLookup]:
+                    feature.Feature.LookupListIndex[:0] = [synthLookup]
+                    feature.Feature.LookupCount += 1
+
+    DefaultTable.merge(self, m, tables)
+    return self
+
+
+@add_method(
+    otTables.SingleSubst,
+    otTables.MultipleSubst,
+    otTables.AlternateSubst,
+    otTables.LigatureSubst,
+    otTables.ReverseChainSingleSubst,
+    otTables.SinglePos,
+    otTables.PairPos,
+    otTables.CursivePos,
+    otTables.MarkBasePos,
+    otTables.MarkLigPos,
+    otTables.MarkMarkPos,
+)
+def mapLookups(self, lookupMap):
+    pass
+
+
+# Copied and trimmed down from subset.py
+@add_method(
+    otTables.ContextSubst,
+    otTables.ChainContextSubst,
+    otTables.ContextPos,
+    otTables.ChainContextPos,
+)
+def __merge_classify_context(self):
+    class ContextHelper(object):
+        def __init__(self, klass, Format):
+            if klass.__name__.endswith("Subst"):
+                Typ = "Sub"
+                Type = "Subst"
+            else:
+                Typ = "Pos"
+                Type = "Pos"
+            if klass.__name__.startswith("Chain"):
+                Chain = "Chain"
+            else:
+                Chain = ""
+            ChainTyp = Chain + Typ
+
+            self.Typ = Typ
+            self.Type = Type
+            self.Chain = Chain
+            self.ChainTyp = ChainTyp
+
+            self.LookupRecord = Type + "LookupRecord"
+
+            if Format == 1:
+                self.Rule = ChainTyp + "Rule"
+                self.RuleSet = ChainTyp + "RuleSet"
+            elif Format == 2:
+                self.Rule = ChainTyp + "ClassRule"
+                self.RuleSet = ChainTyp + "ClassSet"
+
+    if self.Format not in [1, 2, 3]:
+        return None  # Don't shoot the messenger; let it go
+    if not hasattr(self.__class__, "_merge__ContextHelpers"):
+        self.__class__._merge__ContextHelpers = {}
+    if self.Format not in self.__class__._merge__ContextHelpers:
+        helper = ContextHelper(self.__class__, self.Format)
+        self.__class__._merge__ContextHelpers[self.Format] = helper
+    return self.__class__._merge__ContextHelpers[self.Format]
+
+
+@add_method(
+    otTables.ContextSubst,
+    otTables.ChainContextSubst,
+    otTables.ContextPos,
+    otTables.ChainContextPos,
+)
+def mapLookups(self, lookupMap):
+    c = self.__merge_classify_context()
+
+    if self.Format in [1, 2]:
+        for rs in getattr(self, c.RuleSet):
+            if not rs:
+                continue
+            for r in getattr(rs, c.Rule):
+                if not r:
+                    continue
+                for ll in getattr(r, c.LookupRecord):
+                    if not ll:
+                        continue
+                    ll.LookupListIndex = lookupMap[ll.LookupListIndex]
+    elif self.Format == 3:
+        for ll in getattr(self, c.LookupRecord):
+            if not ll:
+                continue
+            ll.LookupListIndex = lookupMap[ll.LookupListIndex]
+    else:
+        assert 0, "unknown format: %s" % self.Format
+
+
+@add_method(otTables.ExtensionSubst, otTables.ExtensionPos)
+def mapLookups(self, lookupMap):
+    if self.Format == 1:
+        self.ExtSubTable.mapLookups(lookupMap)
+    else:
+        assert 0, "unknown format: %s" % self.Format
+
+
+@add_method(otTables.Lookup)
+def mapLookups(self, lookupMap):
+    for st in self.SubTable:
+        if not st:
+            continue
+        st.mapLookups(lookupMap)
+
+
+@add_method(otTables.LookupList)
+def mapLookups(self, lookupMap):
+    for l in self.Lookup:
+        if not l:
+            continue
+        l.mapLookups(lookupMap)
+
+
+@add_method(otTables.Lookup)
+def mapMarkFilteringSets(self, markFilteringSetMap):
+    if self.LookupFlag & 0x0010:
+        self.MarkFilteringSet = markFilteringSetMap[self.MarkFilteringSet]
+
+
+@add_method(otTables.LookupList)
+def mapMarkFilteringSets(self, markFilteringSetMap):
+    for l in self.Lookup:
+        if not l:
+            continue
+        l.mapMarkFilteringSets(markFilteringSetMap)
+
+
+@add_method(otTables.Feature)
+def mapLookups(self, lookupMap):
+    self.LookupListIndex = [lookupMap[i] for i in self.LookupListIndex]
+
+
+@add_method(otTables.FeatureList)
+def mapLookups(self, lookupMap):
+    for f in self.FeatureRecord:
+        if not f or not f.Feature:
+            continue
+        f.Feature.mapLookups(lookupMap)
+
+
+@add_method(otTables.DefaultLangSys, otTables.LangSys)
+def mapFeatures(self, featureMap):
+    self.FeatureIndex = [featureMap[i] for i in self.FeatureIndex]
+    if self.ReqFeatureIndex != 65535:
+        self.ReqFeatureIndex = featureMap[self.ReqFeatureIndex]
+
+
+@add_method(otTables.Script)
+def mapFeatures(self, featureMap):
+    if self.DefaultLangSys:
+        self.DefaultLangSys.mapFeatures(featureMap)
+    for l in self.LangSysRecord:
+        if not l or not l.LangSys:
+            continue
+        l.LangSys.mapFeatures(featureMap)
+
+
+@add_method(otTables.ScriptList)
+def mapFeatures(self, featureMap):
+    for s in self.ScriptRecord:
+        if not s or not s.Script:
+            continue
+        s.Script.mapFeatures(featureMap)
+
+
+def layoutPreMerge(font):
+    # Map indices to references
+
+    GDEF = font.get("GDEF")
+    GSUB = font.get("GSUB")
+    GPOS = font.get("GPOS")
+
+    for t in [GSUB, GPOS]:
+        if not t:
+            continue
+
+        if t.table.LookupList:
+            lookupMap = {i: v for i, v in enumerate(t.table.LookupList.Lookup)}
+            t.table.LookupList.mapLookups(lookupMap)
+            t.table.FeatureList.mapLookups(lookupMap)
+
+            if (
+                GDEF
+                and GDEF.table.Version >= 0x00010002
+                and GDEF.table.MarkGlyphSetsDef
+            ):
+                markFilteringSetMap = {
+                    i: v for i, v in enumerate(GDEF.table.MarkGlyphSetsDef.Coverage)
+                }
+                t.table.LookupList.mapMarkFilteringSets(markFilteringSetMap)
+
+        if t.table.FeatureList and t.table.ScriptList:
+            featureMap = {i: v for i, v in enumerate(t.table.FeatureList.FeatureRecord)}
+            t.table.ScriptList.mapFeatures(featureMap)
+
+    # TODO FeatureParams nameIDs
+
+
+def layoutPostMerge(font):
+    # Map references back to indices
+
+    GDEF = font.get("GDEF")
+    GSUB = font.get("GSUB")
+    GPOS = font.get("GPOS")
+
+    for t in [GSUB, GPOS]:
+        if not t:
+            continue
+
+        if t.table.FeatureList and t.table.ScriptList:
+            # Collect unregistered (new) features.
+            featureMap = GregariousIdentityDict(t.table.FeatureList.FeatureRecord)
+            t.table.ScriptList.mapFeatures(featureMap)
+
+            # Record used features.
+            featureMap = AttendanceRecordingIdentityDict(
+                t.table.FeatureList.FeatureRecord
+            )
+            t.table.ScriptList.mapFeatures(featureMap)
+            usedIndices = featureMap.s
+
+            # Remove unused features
+            t.table.FeatureList.FeatureRecord = [
+                f
+                for i, f in enumerate(t.table.FeatureList.FeatureRecord)
+                if i in usedIndices
+            ]
+
+            # Map back to indices.
+            featureMap = NonhashableDict(t.table.FeatureList.FeatureRecord)
+            t.table.ScriptList.mapFeatures(featureMap)
+
+            t.table.FeatureList.FeatureCount = len(t.table.FeatureList.FeatureRecord)
+
+        if t.table.LookupList:
+            # Collect unregistered (new) lookups.
+            lookupMap = GregariousIdentityDict(t.table.LookupList.Lookup)
+            t.table.FeatureList.mapLookups(lookupMap)
+            t.table.LookupList.mapLookups(lookupMap)
+
+            # Record used lookups.
+            lookupMap = AttendanceRecordingIdentityDict(t.table.LookupList.Lookup)
+            t.table.FeatureList.mapLookups(lookupMap)
+            t.table.LookupList.mapLookups(lookupMap)
+            usedIndices = lookupMap.s
+
+            # Remove unused lookups
+            t.table.LookupList.Lookup = [
+                l for i, l in enumerate(t.table.LookupList.Lookup) if i in usedIndices
+            ]
+
+            # Map back to indices.
+            lookupMap = NonhashableDict(t.table.LookupList.Lookup)
+            t.table.FeatureList.mapLookups(lookupMap)
+            t.table.LookupList.mapLookups(lookupMap)
+
+            t.table.LookupList.LookupCount = len(t.table.LookupList.Lookup)
+
+            if GDEF and GDEF.table.Version >= 0x00010002:
+                markFilteringSetMap = NonhashableDict(
+                    GDEF.table.MarkGlyphSetsDef.Coverage
+                )
+                t.table.LookupList.mapMarkFilteringSets(markFilteringSetMap)
+
+    # TODO FeatureParams nameIDs

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

@@ -0,0 +1,85 @@
+# Copyright 2013 Google, Inc. All Rights Reserved.
+#
+# Google Author(s): Behdad Esfahbod, Roozbeh Pournader
+
+
+class Options(object):
+    class UnknownOptionError(Exception):
+        pass
+
+    def __init__(self, **kwargs):
+        self.verbose = False
+        self.timing = False
+        self.drop_tables = []
+        self.input_file = None
+        self.output_file = "merged.ttf"
+        self.import_file = None
+
+        self.set(**kwargs)
+
+    def set(self, **kwargs):
+        for k, v in kwargs.items():
+            if not hasattr(self, k):
+                raise self.UnknownOptionError("Unknown option '%s'" % k)
+            setattr(self, k, v)
+
+    def parse_opts(self, argv, ignore_unknown=[]):
+        ret = []
+        opts = {}
+        for a in argv:
+            orig_a = a
+            if not a.startswith("--"):
+                ret.append(a)
+                continue
+            a = a[2:]
+            i = a.find("=")
+            op = "="
+            if i == -1:
+                if a.startswith("no-"):
+                    k = a[3:]
+                    v = False
+                else:
+                    k = a
+                    v = True
+            else:
+                k = a[:i]
+                if k[-1] in "-+":
+                    op = k[-1] + "="  # Ops is '-=' or '+=' now.
+                    k = k[:-1]
+                v = a[i + 1 :]
+            ok = k
+            k = k.replace("-", "_")
+            if not hasattr(self, k):
+                if ignore_unknown is True or ok in ignore_unknown:
+                    ret.append(orig_a)
+                    continue
+                else:
+                    raise self.UnknownOptionError("Unknown option '%s'" % a)
+
+            ov = getattr(self, k)
+            if isinstance(ov, bool):
+                v = bool(v)
+            elif isinstance(ov, int):
+                v = int(v)
+            elif isinstance(ov, list):
+                vv = v.split(",")
+                if vv == [""]:
+                    vv = []
+                vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv]
+                if op == "=":
+                    v = vv
+                elif op == "+=":
+                    v = ov
+                    v.extend(vv)
+                elif op == "-=":
+                    v = ov
+                    for x in vv:
+                        if x in v:
+                            v.remove(x)
+                else:
+                    assert 0
+
+            opts[k] = v
+        self.set(**opts)
+
+        return ret

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

@@ -0,0 +1,424 @@
+"""Routines for calculating bounding boxes, point in rectangle calculations and
+so on.
+"""
+
+from fontTools.misc.roundTools import otRound
+from fontTools.misc.vector import Vector as _Vector
+import math
+import warnings
+
+
+def calcBounds(array):
+    """Calculate the bounding rectangle of a 2D points array.
+
+    Args:
+        array: A sequence of 2D tuples.
+
+    Returns:
+        A four-item tuple representing the bounding rectangle ``(xMin, yMin, xMax, yMax)``.
+    """
+    if not array:
+        return 0, 0, 0, 0
+    xs = [x for x, y in array]
+    ys = [y for x, y in array]
+    return min(xs), min(ys), max(xs), max(ys)
+
+
+def calcIntBounds(array, round=otRound):
+    """Calculate the integer bounding rectangle of a 2D points array.
+
+    Values are rounded to closest integer towards ``+Infinity`` using the
+    :func:`fontTools.misc.fixedTools.otRound` function by default, unless
+    an optional ``round`` function is passed.
+
+    Args:
+        array: A sequence of 2D tuples.
+        round: A rounding function of type ``f(x: float) -> int``.
+
+    Returns:
+        A four-item tuple of integers representing the bounding rectangle:
+        ``(xMin, yMin, xMax, yMax)``.
+    """
+    return tuple(round(v) for v in calcBounds(array))
+
+
+def updateBounds(bounds, p, min=min, max=max):
+    """Add a point to a bounding rectangle.
+
+    Args:
+        bounds: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax), or None``.
+        p: A 2D tuple representing a point.
+        min,max: functions to compute the minimum and maximum.
+
+    Returns:
+        The updated bounding rectangle ``(xMin, yMin, xMax, yMax)``.
+    """
+    (x, y) = p
+    if bounds is None:
+        return x, y, x, y
+    xMin, yMin, xMax, yMax = bounds
+    return min(xMin, x), min(yMin, y), max(xMax, x), max(yMax, y)
+
+
+def pointInRect(p, rect):
+    """Test if a point is inside a bounding rectangle.
+
+    Args:
+        p: A 2D tuple representing a point.
+        rect: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax)``.
+
+    Returns:
+        ``True`` if the point is inside the rectangle, ``False`` otherwise.
+    """
+    (x, y) = p
+    xMin, yMin, xMax, yMax = rect
+    return (xMin <= x <= xMax) and (yMin <= y <= yMax)
+
+
+def pointsInRect(array, rect):
+    """Determine which points are inside a bounding rectangle.
+
+    Args:
+        array: A sequence of 2D tuples.
+        rect: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax)``.
+
+    Returns:
+        A list containing the points inside the rectangle.
+    """
+    if len(array) < 1:
+        return []
+    xMin, yMin, xMax, yMax = rect
+    return [(xMin <= x <= xMax) and (yMin <= y <= yMax) for x, y in array]
+
+
+def vectorLength(vector):
+    """Calculate the length of the given vector.
+
+    Args:
+        vector: A 2D tuple.
+
+    Returns:
+        The Euclidean length of the vector.
+    """
+    x, y = vector
+    return math.sqrt(x**2 + y**2)
+
+
+def asInt16(array):
+    """Round a list of floats to 16-bit signed integers.
+
+    Args:
+        array: List of float values.
+
+    Returns:
+        A list of rounded integers.
+    """
+    return [int(math.floor(i + 0.5)) for i in array]
+
+
+def normRect(rect):
+    """Normalize a bounding box rectangle.
+
+    This function "turns the rectangle the right way up", so that the following
+    holds::
+
+        xMin <= xMax and yMin <= yMax
+
+    Args:
+        rect: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax)``.
+
+    Returns:
+        A normalized bounding rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    return min(xMin, xMax), min(yMin, yMax), max(xMin, xMax), max(yMin, yMax)
+
+
+def scaleRect(rect, x, y):
+    """Scale a bounding box rectangle.
+
+    Args:
+        rect: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax)``.
+        x: Factor to scale the rectangle along the X axis.
+        Y: Factor to scale the rectangle along the Y axis.
+
+    Returns:
+        A scaled bounding rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    return xMin * x, yMin * y, xMax * x, yMax * y
+
+
+def offsetRect(rect, dx, dy):
+    """Offset a bounding box rectangle.
+
+    Args:
+        rect: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax)``.
+        dx: Amount to offset the rectangle along the X axis.
+        dY: Amount to offset the rectangle along the Y axis.
+
+    Returns:
+        An offset bounding rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    return xMin + dx, yMin + dy, xMax + dx, yMax + dy
+
+
+def insetRect(rect, dx, dy):
+    """Inset a bounding box rectangle on all sides.
+
+    Args:
+        rect: A bounding rectangle expressed as a tuple
+            ``(xMin, yMin, xMax, yMax)``.
+        dx: Amount to inset the rectangle along the X axis.
+        dY: Amount to inset the rectangle along the Y axis.
+
+    Returns:
+        An inset bounding rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    return xMin + dx, yMin + dy, xMax - dx, yMax - dy
+
+
+def sectRect(rect1, rect2):
+    """Test for rectangle-rectangle intersection.
+
+    Args:
+        rect1: First bounding rectangle, expressed as tuples
+            ``(xMin, yMin, xMax, yMax)``.
+        rect2: Second bounding rectangle.
+
+    Returns:
+        A boolean and a rectangle.
+        If the input rectangles intersect, returns ``True`` and the intersecting
+        rectangle. Returns ``False`` and ``(0, 0, 0, 0)`` if the input
+        rectangles don't intersect.
+    """
+    (xMin1, yMin1, xMax1, yMax1) = rect1
+    (xMin2, yMin2, xMax2, yMax2) = rect2
+    xMin, yMin, xMax, yMax = (
+        max(xMin1, xMin2),
+        max(yMin1, yMin2),
+        min(xMax1, xMax2),
+        min(yMax1, yMax2),
+    )
+    if xMin >= xMax or yMin >= yMax:
+        return False, (0, 0, 0, 0)
+    return True, (xMin, yMin, xMax, yMax)
+
+
+def unionRect(rect1, rect2):
+    """Determine union of bounding rectangles.
+
+    Args:
+        rect1: First bounding rectangle, expressed as tuples
+            ``(xMin, yMin, xMax, yMax)``.
+        rect2: Second bounding rectangle.
+
+    Returns:
+        The smallest rectangle in which both input rectangles are fully
+        enclosed.
+    """
+    (xMin1, yMin1, xMax1, yMax1) = rect1
+    (xMin2, yMin2, xMax2, yMax2) = rect2
+    xMin, yMin, xMax, yMax = (
+        min(xMin1, xMin2),
+        min(yMin1, yMin2),
+        max(xMax1, xMax2),
+        max(yMax1, yMax2),
+    )
+    return (xMin, yMin, xMax, yMax)
+
+
+def rectCenter(rect):
+    """Determine rectangle center.
+
+    Args:
+        rect: Bounding rectangle, expressed as tuples
+            ``(xMin, yMin, xMax, yMax)``.
+
+    Returns:
+        A 2D tuple representing the point at the center of the rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    return (xMin + xMax) / 2, (yMin + yMax) / 2
+
+
+def rectArea(rect):
+    """Determine rectangle area.
+
+    Args:
+        rect: Bounding rectangle, expressed as tuples
+            ``(xMin, yMin, xMax, yMax)``.
+
+    Returns:
+        The area of the rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    return (yMax - yMin) * (xMax - xMin)
+
+
+def intRect(rect):
+    """Round a rectangle to integer values.
+
+    Guarantees that the resulting rectangle is NOT smaller than the original.
+
+    Args:
+        rect: Bounding rectangle, expressed as tuples
+            ``(xMin, yMin, xMax, yMax)``.
+
+    Returns:
+        A rounded bounding rectangle.
+    """
+    (xMin, yMin, xMax, yMax) = rect
+    xMin = int(math.floor(xMin))
+    yMin = int(math.floor(yMin))
+    xMax = int(math.ceil(xMax))
+    yMax = int(math.ceil(yMax))
+    return (xMin, yMin, xMax, yMax)
+
+
+def quantizeRect(rect, factor=1):
+    """
+    >>> bounds = (72.3, -218.4, 1201.3, 919.1)
+    >>> quantizeRect(bounds)
+    (72, -219, 1202, 920)
+    >>> quantizeRect(bounds, factor=10)
+    (70, -220, 1210, 920)
+    >>> quantizeRect(bounds, factor=100)
+    (0, -300, 1300, 1000)
+    """
+    if factor < 1:
+        raise ValueError(f"Expected quantization factor >= 1, found: {factor!r}")
+    xMin, yMin, xMax, yMax = normRect(rect)
+    return (
+        int(math.floor(xMin / factor) * factor),
+        int(math.floor(yMin / factor) * factor),
+        int(math.ceil(xMax / factor) * factor),
+        int(math.ceil(yMax / factor) * factor),
+    )
+
+
+class Vector(_Vector):
+    def __init__(self, *args, **kwargs):
+        warnings.warn(
+            "fontTools.misc.arrayTools.Vector has been deprecated, please use "
+            "fontTools.misc.vector.Vector instead.",
+            DeprecationWarning,
+        )
+
+
+def pairwise(iterable, reverse=False):
+    """Iterate over current and next items in iterable.
+
+    Args:
+        iterable: An iterable
+        reverse: If true, iterate in reverse order.
+
+    Returns:
+        A iterable yielding two elements per iteration.
+
+    Example:
+
+        >>> tuple(pairwise([]))
+        ()
+        >>> tuple(pairwise([], reverse=True))
+        ()
+        >>> tuple(pairwise([0]))
+        ((0, 0),)
+        >>> tuple(pairwise([0], reverse=True))
+        ((0, 0),)
+        >>> tuple(pairwise([0, 1]))
+        ((0, 1), (1, 0))
+        >>> tuple(pairwise([0, 1], reverse=True))
+        ((1, 0), (0, 1))
+        >>> tuple(pairwise([0, 1, 2]))
+        ((0, 1), (1, 2), (2, 0))
+        >>> tuple(pairwise([0, 1, 2], reverse=True))
+        ((2, 1), (1, 0), (0, 2))
+        >>> tuple(pairwise(['a', 'b', 'c', 'd']))
+        (('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'a'))
+        >>> tuple(pairwise(['a', 'b', 'c', 'd'], reverse=True))
+        (('d', 'c'), ('c', 'b'), ('b', 'a'), ('a', 'd'))
+    """
+    if not iterable:
+        return
+    if reverse:
+        it = reversed(iterable)
+    else:
+        it = iter(iterable)
+    first = next(it, None)
+    a = first
+    for b in it:
+        yield (a, b)
+        a = b
+    yield (a, first)
+
+
+def _test():
+    """
+    >>> import math
+    >>> calcBounds([])
+    (0, 0, 0, 0)
+    >>> calcBounds([(0, 40), (0, 100), (50, 50), (80, 10)])
+    (0, 10, 80, 100)
+    >>> updateBounds((0, 0, 0, 0), (100, 100))
+    (0, 0, 100, 100)
+    >>> pointInRect((50, 50), (0, 0, 100, 100))
+    True
+    >>> pointInRect((0, 0), (0, 0, 100, 100))
+    True
+    >>> pointInRect((100, 100), (0, 0, 100, 100))
+    True
+    >>> not pointInRect((101, 100), (0, 0, 100, 100))
+    True
+    >>> list(pointsInRect([(50, 50), (0, 0), (100, 100), (101, 100)], (0, 0, 100, 100)))
+    [True, True, True, False]
+    >>> vectorLength((3, 4))
+    5.0
+    >>> vectorLength((1, 1)) == math.sqrt(2)
+    True
+    >>> list(asInt16([0, 0.1, 0.5, 0.9]))
+    [0, 0, 1, 1]
+    >>> normRect((0, 10, 100, 200))
+    (0, 10, 100, 200)
+    >>> normRect((100, 200, 0, 10))
+    (0, 10, 100, 200)
+    >>> scaleRect((10, 20, 50, 150), 1.5, 2)
+    (15.0, 40, 75.0, 300)
+    >>> offsetRect((10, 20, 30, 40), 5, 6)
+    (15, 26, 35, 46)
+    >>> insetRect((10, 20, 50, 60), 5, 10)
+    (15, 30, 45, 50)
+    >>> insetRect((10, 20, 50, 60), -5, -10)
+    (5, 10, 55, 70)
+    >>> intersects, rect = sectRect((0, 10, 20, 30), (0, 40, 20, 50))
+    >>> not intersects
+    True
+    >>> intersects, rect = sectRect((0, 10, 20, 30), (5, 20, 35, 50))
+    >>> intersects
+    1
+    >>> rect
+    (5, 20, 20, 30)
+    >>> unionRect((0, 10, 20, 30), (0, 40, 20, 50))
+    (0, 10, 20, 50)
+    >>> rectCenter((0, 0, 100, 200))
+    (50.0, 100.0)
+    >>> rectCenter((0, 0, 100, 199.0))
+    (50.0, 99.5)
+    >>> intRect((0.9, 2.9, 3.1, 4.1))
+    (0, 2, 4, 5)
+    """
+
+
+if __name__ == "__main__":
+    import sys
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

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

@@ -0,0 +1,53 @@
+"""Collection of utilities for command-line interfaces and console scripts."""
+
+import os
+import re
+
+
+numberAddedRE = re.compile(r"#\d+$")
+
+
+def makeOutputFileName(
+    input, outputDir=None, extension=None, overWrite=False, suffix=""
+):
+    """Generates a suitable file name for writing output.
+
+    Often tools will want to take a file, do some kind of transformation to it,
+    and write it out again. This function determines an appropriate name for the
+    output file, through one or more of the following steps:
+
+    - changing the output directory
+    - appending suffix before file extension
+    - replacing the file extension
+    - suffixing the filename with a number (``#1``, ``#2``, etc.) to avoid
+      overwriting an existing file.
+
+    Args:
+        input: Name of input file.
+        outputDir: Optionally, a new directory to write the file into.
+        suffix: Optionally, a string suffix is appended to file name before
+            the extension.
+        extension: Optionally, a replacement for the current file extension.
+        overWrite: Overwriting an existing file is permitted if true; if false
+            and the proposed filename exists, a new name will be generated by
+            adding an appropriate number suffix.
+
+    Returns:
+        str: Suitable output filename
+    """
+    dirName, fileName = os.path.split(input)
+    fileName, ext = os.path.splitext(fileName)
+    if outputDir:
+        dirName = outputDir
+    fileName = numberAddedRE.split(fileName)[0]
+    if extension is None:
+        extension = os.path.splitext(input)[1]
+    output = os.path.join(dirName, fileName + suffix + extension)
+    n = 1
+    if not overWrite:
+        while os.path.exists(output):
+            output = os.path.join(
+                dirName, fileName + suffix + "#" + repr(n) + extension
+            )
+            n += 1
+    return output

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

@@ -0,0 +1,27 @@
+""" Exports a no-op 'cython' namespace similar to
+https://github.com/cython/cython/blob/master/Cython/Shadow.py
+
+This allows to optionally compile @cython decorated functions
+(when cython is available at built time), or run the same code
+as pure-python, without runtime dependency on cython module.
+
+We only define the symbols that we use. E.g. see fontTools.cu2qu
+"""
+
+from types import SimpleNamespace
+
+
+def _empty_decorator(x):
+    return x
+
+
+compiled = False
+
+for name in ("double", "complex", "int"):
+    globals()[name] = None
+
+for name in ("cfunc", "inline"):
+    globals()[name] = _empty_decorator
+
+locals = lambda **_: _empty_decorator
+returns = lambda _: _empty_decorator

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

@@ -0,0 +1,83 @@
+"""Misc dict tools."""
+
+__all__ = ["hashdict"]
+
+
+# https://stackoverflow.com/questions/1151658/python-hashable-dicts
+class hashdict(dict):
+    """
+    hashable dict implementation, suitable for use as a key into
+    other dicts.
+
+        >>> h1 = hashdict({"apples": 1, "bananas":2})
+        >>> h2 = hashdict({"bananas": 3, "mangoes": 5})
+        >>> h1+h2
+        hashdict(apples=1, bananas=3, mangoes=5)
+        >>> d1 = {}
+        >>> d1[h1] = "salad"
+        >>> d1[h1]
+        'salad'
+        >>> d1[h2]
+        Traceback (most recent call last):
+        ...
+        KeyError: hashdict(bananas=3, mangoes=5)
+
+    based on answers from
+       http://stackoverflow.com/questions/1151658/python-hashable-dicts
+
+    """
+
+    def __key(self):
+        return tuple(sorted(self.items()))
+
+    def __repr__(self):
+        return "{0}({1})".format(
+            self.__class__.__name__,
+            ", ".join("{0}={1}".format(str(i[0]), repr(i[1])) for i in self.__key()),
+        )
+
+    def __hash__(self):
+        return hash(self.__key())
+
+    def __setitem__(self, key, value):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    def __delitem__(self, key):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    def clear(self):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    def pop(self, *args, **kwargs):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    def popitem(self, *args, **kwargs):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    def setdefault(self, *args, **kwargs):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    def update(self, *args, **kwargs):
+        raise TypeError(
+            "{0} does not support item assignment".format(self.__class__.__name__)
+        )
+
+    # update is not ok because it mutates the object
+    # __add__ is ok because it creates a new object
+    # while the new object is under construction, it's ok to mutate it
+    def __add__(self, right):
+        result = hashdict(self)
+        dict.update(result, right)
+        return result

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

@@ -0,0 +1,253 @@
+"""
+The `OpenType specification <https://docs.microsoft.com/en-us/typography/opentype/spec/otff#data-types>`_
+defines two fixed-point data types:
+
+``Fixed``
+	A 32-bit signed fixed-point number with a 16 bit twos-complement
+	magnitude component and 16 fractional bits.
+``F2DOT14``
+	A 16-bit signed fixed-point number with a 2 bit twos-complement
+	magnitude component and 14 fractional bits.
+
+To support reading and writing data with these data types, this module provides
+functions for converting between fixed-point, float and string representations.
+
+.. data:: MAX_F2DOT14
+
+	The maximum value that can still fit in an F2Dot14. (1.99993896484375)
+"""
+
+from .roundTools import otRound, nearestMultipleShortestRepr
+import logging
+
+log = logging.getLogger(__name__)
+
+__all__ = [
+    "MAX_F2DOT14",
+    "fixedToFloat",
+    "floatToFixed",
+    "floatToFixedToFloat",
+    "floatToFixedToStr",
+    "fixedToStr",
+    "strToFixed",
+    "strToFixedToFloat",
+    "ensureVersionIsLong",
+    "versionToFixed",
+]
+
+
+MAX_F2DOT14 = 0x7FFF / (1 << 14)
+
+
+def fixedToFloat(value, precisionBits):
+    """Converts a fixed-point number to a float given the number of
+    precision bits.
+
+    Args:
+            value (int): Number in fixed-point format.
+            precisionBits (int): Number of precision bits.
+
+    Returns:
+            Floating point value.
+
+    Examples::
+
+            >>> import math
+            >>> f = fixedToFloat(-10139, precisionBits=14)
+            >>> math.isclose(f, -0.61883544921875)
+            True
+    """
+    return value / (1 << precisionBits)
+
+
+def floatToFixed(value, precisionBits):
+    """Converts a float to a fixed-point number given the number of
+    precision bits.
+
+    Args:
+            value (float): Floating point value.
+            precisionBits (int): Number of precision bits.
+
+    Returns:
+            int: Fixed-point representation.
+
+    Examples::
+
+            >>> floatToFixed(-0.61883544921875, precisionBits=14)
+            -10139
+            >>> floatToFixed(-0.61884, precisionBits=14)
+            -10139
+    """
+    return otRound(value * (1 << precisionBits))
+
+
+def floatToFixedToFloat(value, precisionBits):
+    """Converts a float to a fixed-point number and back again.
+
+    By converting the float to fixed, rounding it, and converting it back
+    to float again, this returns a floating point values which is exactly
+    representable in fixed-point format.
+
+    Note: this **is** equivalent to ``fixedToFloat(floatToFixed(value))``.
+
+    Args:
+            value (float): The input floating point value.
+            precisionBits (int): Number of precision bits.
+
+    Returns:
+            float: The transformed and rounded value.
+
+    Examples::
+            >>> import math
+            >>> f1 = -0.61884
+            >>> f2 = floatToFixedToFloat(-0.61884, precisionBits=14)
+            >>> f1 != f2
+            True
+            >>> math.isclose(f2, -0.61883544921875)
+            True
+    """
+    scale = 1 << precisionBits
+    return otRound(value * scale) / scale
+
+
+def fixedToStr(value, precisionBits):
+    """Converts a fixed-point number to a string representing a decimal float.
+
+    This chooses the float that has the shortest decimal representation (the least
+    number of fractional decimal digits).
+
+    For example, to convert a fixed-point number in a 2.14 format, use
+    ``precisionBits=14``::
+
+            >>> fixedToStr(-10139, precisionBits=14)
+            '-0.61884'
+
+    This is pretty slow compared to the simple division used in ``fixedToFloat``.
+    Use sporadically when you need to serialize or print the fixed-point number in
+    a human-readable form.
+    It uses nearestMultipleShortestRepr under the hood.
+
+    Args:
+            value (int): The fixed-point value to convert.
+            precisionBits (int): Number of precision bits, *up to a maximum of 16*.
+
+    Returns:
+            str: A string representation of the value.
+    """
+    scale = 1 << precisionBits
+    return nearestMultipleShortestRepr(value / scale, factor=1.0 / scale)
+
+
+def strToFixed(string, precisionBits):
+    """Converts a string representing a decimal float to a fixed-point number.
+
+    Args:
+            string (str): A string representing a decimal float.
+            precisionBits (int): Number of precision bits, *up to a maximum of 16*.
+
+    Returns:
+            int: Fixed-point representation.
+
+    Examples::
+
+            >>> ## to convert a float string to a 2.14 fixed-point number:
+            >>> strToFixed('-0.61884', precisionBits=14)
+            -10139
+    """
+    value = float(string)
+    return otRound(value * (1 << precisionBits))
+
+
+def strToFixedToFloat(string, precisionBits):
+    """Convert a string to a decimal float with fixed-point rounding.
+
+    This first converts string to a float, then turns it into a fixed-point
+    number with ``precisionBits`` fractional binary digits, then back to a
+    float again.
+
+    This is simply a shorthand for fixedToFloat(floatToFixed(float(s))).
+
+    Args:
+            string (str): A string representing a decimal float.
+            precisionBits (int): Number of precision bits.
+
+    Returns:
+            float: The transformed and rounded value.
+
+    Examples::
+
+            >>> import math
+            >>> s = '-0.61884'
+            >>> bits = 14
+            >>> f = strToFixedToFloat(s, precisionBits=bits)
+            >>> math.isclose(f, -0.61883544921875)
+            True
+            >>> f == fixedToFloat(floatToFixed(float(s), precisionBits=bits), precisionBits=bits)
+            True
+    """
+    value = float(string)
+    scale = 1 << precisionBits
+    return otRound(value * scale) / scale
+
+
+def floatToFixedToStr(value, precisionBits):
+    """Convert float to string with fixed-point rounding.
+
+    This uses the shortest decimal representation (ie. the least
+    number of fractional decimal digits) to represent the equivalent
+    fixed-point number with ``precisionBits`` fractional binary digits.
+    It uses nearestMultipleShortestRepr under the hood.
+
+    >>> floatToFixedToStr(-0.61883544921875, precisionBits=14)
+    '-0.61884'
+
+    Args:
+            value (float): The float value to convert.
+            precisionBits (int): Number of precision bits, *up to a maximum of 16*.
+
+    Returns:
+            str: A string representation of the value.
+
+    """
+    scale = 1 << precisionBits
+    return nearestMultipleShortestRepr(value, factor=1.0 / scale)
+
+
+def ensureVersionIsLong(value):
+    """Ensure a table version is an unsigned long.
+
+    OpenType table version numbers are expressed as a single unsigned long
+    comprising of an unsigned short major version and unsigned short minor
+    version. This function detects if the value to be used as a version number
+    looks too small (i.e. is less than ``0x10000``), and converts it to
+    fixed-point using :func:`floatToFixed` if so.
+
+    Args:
+            value (Number): a candidate table version number.
+
+    Returns:
+            int: A table version number, possibly corrected to fixed-point.
+    """
+    if value < 0x10000:
+        newValue = floatToFixed(value, 16)
+        log.warning(
+            "Table version value is a float: %.4f; " "fix to use hex instead: 0x%08x",
+            value,
+            newValue,
+        )
+        value = newValue
+    return value
+
+
+def versionToFixed(value):
+    """Ensure a table version number is fixed-point.
+
+    Args:
+            value (str): a candidate table version number.
+
+    Returns:
+            int: A table version number, possibly corrected to fixed-point.
+    """
+    value = int(value, 0) if value.startswith("0") else float(value)
+    value = ensureVersionIsLong(value)
+    return value

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

@@ -0,0 +1,12 @@
+from itertools import *
+
+# Python 3.12:
+if "batched" not in globals():
+    # https://docs.python.org/3/library/itertools.html#itertools.batched
+    def batched(iterable, n):
+        # batched('ABCDEFG', 3) --> ABC DEF G
+        if n < 1:
+            raise ValueError("n must be at least one")
+        it = iter(iterable)
+        while batch := tuple(islice(it, n)):
+            yield batch

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

@@ -0,0 +1,543 @@
+import sys
+import logging
+import timeit
+from functools import wraps
+from collections.abc import Mapping, Callable
+import warnings
+from logging import PercentStyle
+
+
+# default logging level used by Timer class
+TIME_LEVEL = logging.DEBUG
+
+# per-level format strings used by the default formatter
+# (the level name is not printed for INFO and DEBUG messages)
+DEFAULT_FORMATS = {
+    "*": "%(levelname)s: %(message)s",
+    "INFO": "%(message)s",
+    "DEBUG": "%(message)s",
+}
+
+
+class LevelFormatter(logging.Formatter):
+    """Log formatter with level-specific formatting.
+
+    Formatter class which optionally takes a dict of logging levels to
+    format strings, allowing to customise the log records appearance for
+    specific levels.
+
+
+    Attributes:
+            fmt: A dictionary mapping logging levels to format strings.
+                    The ``*`` key identifies the default format string.
+            datefmt: As per py:class:`logging.Formatter`
+            style: As per py:class:`logging.Formatter`
+
+    >>> import sys
+    >>> handler = logging.StreamHandler(sys.stdout)
+    >>> formatter = LevelFormatter(
+    ...     fmt={
+    ...         '*':     '[%(levelname)s] %(message)s',
+    ...         'DEBUG': '%(name)s [%(levelname)s] %(message)s',
+    ...         'INFO':  '%(message)s',
+    ...     })
+    >>> handler.setFormatter(formatter)
+    >>> log = logging.getLogger('test')
+    >>> log.setLevel(logging.DEBUG)
+    >>> log.addHandler(handler)
+    >>> log.debug('this uses a custom format string')
+    test [DEBUG] this uses a custom format string
+    >>> log.info('this also uses a custom format string')
+    this also uses a custom format string
+    >>> log.warning("this one uses the default format string")
+    [WARNING] this one uses the default format string
+    """
+
+    def __init__(self, fmt=None, datefmt=None, style="%"):
+        if style != "%":
+            raise ValueError(
+                "only '%' percent style is supported in both python 2 and 3"
+            )
+        if fmt is None:
+            fmt = DEFAULT_FORMATS
+        if isinstance(fmt, str):
+            default_format = fmt
+            custom_formats = {}
+        elif isinstance(fmt, Mapping):
+            custom_formats = dict(fmt)
+            default_format = custom_formats.pop("*", None)
+        else:
+            raise TypeError("fmt must be a str or a dict of str: %r" % fmt)
+        super(LevelFormatter, self).__init__(default_format, datefmt)
+        self.default_format = self._fmt
+        self.custom_formats = {}
+        for level, fmt in custom_formats.items():
+            level = logging._checkLevel(level)
+            self.custom_formats[level] = fmt
+
+    def format(self, record):
+        if self.custom_formats:
+            fmt = self.custom_formats.get(record.levelno, self.default_format)
+            if self._fmt != fmt:
+                self._fmt = fmt
+                # for python >= 3.2, _style needs to be set if _fmt changes
+                if PercentStyle:
+                    self._style = PercentStyle(fmt)
+        return super(LevelFormatter, self).format(record)
+
+
+def configLogger(**kwargs):
+    """A more sophisticated logging system configuation manager.
+
+    This is more or less the same as :py:func:`logging.basicConfig`,
+    with some additional options and defaults.
+
+    The default behaviour is to create a ``StreamHandler`` which writes to
+    sys.stderr, set a formatter using the ``DEFAULT_FORMATS`` strings, and add
+    the handler to the top-level library logger ("fontTools").
+
+    A number of optional keyword arguments may be specified, which can alter
+    the default behaviour.
+
+    Args:
+
+            logger: Specifies the logger name or a Logger instance to be
+                    configured. (Defaults to "fontTools" logger). Unlike ``basicConfig``,
+                    this function can be called multiple times to reconfigure a logger.
+                    If the logger or any of its children already exists before the call is
+                    made, they will be reset before the new configuration is applied.
+            filename: Specifies that a ``FileHandler`` be created, using the
+                    specified filename, rather than a ``StreamHandler``.
+            filemode: Specifies the mode to open the file, if filename is
+                    specified. (If filemode is unspecified, it defaults to ``a``).
+            format: Use the specified format string for the handler. This
+                    argument also accepts a dictionary of format strings keyed by
+                    level name, to allow customising the records appearance for
+                    specific levels. The special ``'*'`` key is for 'any other' level.
+            datefmt: Use the specified date/time format.
+            level: Set the logger level to the specified level.
+            stream: Use the specified stream to initialize the StreamHandler. Note
+                    that this argument is incompatible with ``filename`` - if both
+                    are present, ``stream`` is ignored.
+            handlers: If specified, this should be an iterable of already created
+                    handlers, which will be added to the logger. Any handler in the
+                    list which does not have a formatter assigned will be assigned the
+                    formatter created in this function.
+            filters: If specified, this should be an iterable of already created
+                    filters. If the ``handlers`` do not already have filters assigned,
+                    these filters will be added to them.
+            propagate: All loggers have a ``propagate`` attribute which determines
+                    whether to continue searching for handlers up the logging hierarchy.
+                    If not provided, the "propagate" attribute will be set to ``False``.
+    """
+    # using kwargs to enforce keyword-only arguments in py2.
+    handlers = kwargs.pop("handlers", None)
+    if handlers is None:
+        if "stream" in kwargs and "filename" in kwargs:
+            raise ValueError(
+                "'stream' and 'filename' should not be " "specified together"
+            )
+    else:
+        if "stream" in kwargs or "filename" in kwargs:
+            raise ValueError(
+                "'stream' or 'filename' should not be "
+                "specified together with 'handlers'"
+            )
+    if handlers is None:
+        filename = kwargs.pop("filename", None)
+        mode = kwargs.pop("filemode", "a")
+        if filename:
+            h = logging.FileHandler(filename, mode)
+        else:
+            stream = kwargs.pop("stream", None)
+            h = logging.StreamHandler(stream)
+        handlers = [h]
+    # By default, the top-level library logger is configured.
+    logger = kwargs.pop("logger", "fontTools")
+    if not logger or isinstance(logger, str):
+        # empty "" or None means the 'root' logger
+        logger = logging.getLogger(logger)
+    # before (re)configuring, reset named logger and its children (if exist)
+    _resetExistingLoggers(parent=logger.name)
+    # use DEFAULT_FORMATS if 'format' is None
+    fs = kwargs.pop("format", None)
+    dfs = kwargs.pop("datefmt", None)
+    # XXX: '%' is the only format style supported on both py2 and 3
+    style = kwargs.pop("style", "%")
+    fmt = LevelFormatter(fs, dfs, style)
+    filters = kwargs.pop("filters", [])
+    for h in handlers:
+        if h.formatter is None:
+            h.setFormatter(fmt)
+        if not h.filters:
+            for f in filters:
+                h.addFilter(f)
+        logger.addHandler(h)
+    if logger.name != "root":
+        # stop searching up the hierarchy for handlers
+        logger.propagate = kwargs.pop("propagate", False)
+    # set a custom severity level
+    level = kwargs.pop("level", None)
+    if level is not None:
+        logger.setLevel(level)
+    if kwargs:
+        keys = ", ".join(kwargs.keys())
+        raise ValueError("Unrecognised argument(s): %s" % keys)
+
+
+def _resetExistingLoggers(parent="root"):
+    """Reset the logger named 'parent' and all its children to their initial
+    state, if they already exist in the current configuration.
+    """
+    root = logging.root
+    # get sorted list of all existing loggers
+    existing = sorted(root.manager.loggerDict.keys())
+    if parent == "root":
+        # all the existing loggers are children of 'root'
+        loggers_to_reset = [parent] + existing
+    elif parent not in existing:
+        # nothing to do
+        return
+    elif parent in existing:
+        loggers_to_reset = [parent]
+        # collect children, starting with the entry after parent name
+        i = existing.index(parent) + 1
+        prefixed = parent + "."
+        pflen = len(prefixed)
+        num_existing = len(existing)
+        while i < num_existing:
+            if existing[i][:pflen] == prefixed:
+                loggers_to_reset.append(existing[i])
+            i += 1
+    for name in loggers_to_reset:
+        if name == "root":
+            root.setLevel(logging.WARNING)
+            for h in root.handlers[:]:
+                root.removeHandler(h)
+            for f in root.filters[:]:
+                root.removeFilters(f)
+            root.disabled = False
+        else:
+            logger = root.manager.loggerDict[name]
+            logger.level = logging.NOTSET
+            logger.handlers = []
+            logger.filters = []
+            logger.propagate = True
+            logger.disabled = False
+
+
+class Timer(object):
+    """Keeps track of overall time and split/lap times.
+
+    >>> import time
+    >>> timer = Timer()
+    >>> time.sleep(0.01)
+    >>> print("First lap:", timer.split())
+    First lap: ...
+    >>> time.sleep(0.02)
+    >>> print("Second lap:", timer.split())
+    Second lap: ...
+    >>> print("Overall time:", timer.time())
+    Overall time: ...
+
+    Can be used as a context manager inside with-statements.
+
+    >>> with Timer() as t:
+    ...     time.sleep(0.01)
+    >>> print("%0.3f seconds" % t.elapsed)
+    0... seconds
+
+    If initialised with a logger, it can log the elapsed time automatically
+    upon exiting the with-statement.
+
+    >>> import logging
+    >>> log = logging.getLogger("my-fancy-timer-logger")
+    >>> configLogger(logger=log, level="DEBUG", format="%(message)s", stream=sys.stdout)
+    >>> with Timer(log, 'do something'):
+    ...     time.sleep(0.01)
+    Took ... to do something
+
+    The same Timer instance, holding a reference to a logger, can be reused
+    in multiple with-statements, optionally with different messages or levels.
+
+    >>> timer = Timer(log)
+    >>> with timer():
+    ...     time.sleep(0.01)
+    elapsed time: ...s
+    >>> with timer('redo it', level=logging.INFO):
+    ...     time.sleep(0.02)
+    Took ... to redo it
+
+    It can also be used as a function decorator to log the time elapsed to run
+    the decorated function.
+
+    >>> @timer()
+    ... def test1():
+    ...    time.sleep(0.01)
+    >>> @timer('run test 2', level=logging.INFO)
+    ... def test2():
+    ...    time.sleep(0.02)
+    >>> test1()
+    Took ... to run 'test1'
+    >>> test2()
+    Took ... to run test 2
+    """
+
+    # timeit.default_timer choses the most accurate clock for each platform
+    _time = timeit.default_timer
+    default_msg = "elapsed time: %(time).3fs"
+    default_format = "Took %(time).3fs to %(msg)s"
+
+    def __init__(self, logger=None, msg=None, level=None, start=None):
+        self.reset(start)
+        if logger is None:
+            for arg in ("msg", "level"):
+                if locals().get(arg) is not None:
+                    raise ValueError("'%s' can't be specified without a 'logger'" % arg)
+        self.logger = logger
+        self.level = level if level is not None else TIME_LEVEL
+        self.msg = msg
+
+    def reset(self, start=None):
+        """Reset timer to 'start_time' or the current time."""
+        if start is None:
+            self.start = self._time()
+        else:
+            self.start = start
+        self.last = self.start
+        self.elapsed = 0.0
+
+    def time(self):
+        """Return the overall time (in seconds) since the timer started."""
+        return self._time() - self.start
+
+    def split(self):
+        """Split and return the lap time (in seconds) in between splits."""
+        current = self._time()
+        self.elapsed = current - self.last
+        self.last = current
+        return self.elapsed
+
+    def formatTime(self, msg, time):
+        """Format 'time' value in 'msg' and return formatted string.
+        If 'msg' contains a '%(time)' format string, try to use that.
+        Otherwise, use the predefined 'default_format'.
+        If 'msg' is empty or None, fall back to 'default_msg'.
+        """
+        if not msg:
+            msg = self.default_msg
+        if msg.find("%(time)") < 0:
+            msg = self.default_format % {"msg": msg, "time": time}
+        else:
+            try:
+                msg = msg % {"time": time}
+            except (KeyError, ValueError):
+                pass  # skip if the format string is malformed
+        return msg
+
+    def __enter__(self):
+        """Start a new lap"""
+        self.last = self._time()
+        self.elapsed = 0.0
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """End the current lap. If timer has a logger, log the time elapsed,
+        using the format string in self.msg (or the default one).
+        """
+        time = self.split()
+        if self.logger is None or exc_type:
+            # if there's no logger attached, or if any exception occurred in
+            # the with-statement, exit without logging the time
+            return
+        message = self.formatTime(self.msg, time)
+        # Allow log handlers to see the individual parts to facilitate things
+        # like a server accumulating aggregate stats.
+        msg_parts = {"msg": self.msg, "time": time}
+        self.logger.log(self.level, message, msg_parts)
+
+    def __call__(self, func_or_msg=None, **kwargs):
+        """If the first argument is a function, return a decorator which runs
+        the wrapped function inside Timer's context manager.
+        Otherwise, treat the first argument as a 'msg' string and return an updated
+        Timer instance, referencing the same logger.
+        A 'level' keyword can also be passed to override self.level.
+        """
+        if isinstance(func_or_msg, Callable):
+            func = func_or_msg
+            # use the function name when no explicit 'msg' is provided
+            if not self.msg:
+                self.msg = "run '%s'" % func.__name__
+
+            @wraps(func)
+            def wrapper(*args, **kwds):
+                with self:
+                    return func(*args, **kwds)
+
+            return wrapper
+        else:
+            msg = func_or_msg or kwargs.get("msg")
+            level = kwargs.get("level", self.level)
+            return self.__class__(self.logger, msg, level)
+
+    def __float__(self):
+        return self.elapsed
+
+    def __int__(self):
+        return int(self.elapsed)
+
+    def __str__(self):
+        return "%.3f" % self.elapsed
+
+
+class ChannelsFilter(logging.Filter):
+    """Provides a hierarchical filter for log entries based on channel names.
+
+    Filters out records emitted from a list of enabled channel names,
+    including their children. It works the same as the ``logging.Filter``
+    class, but allows the user to specify multiple channel names.
+
+    >>> import sys
+    >>> handler = logging.StreamHandler(sys.stdout)
+    >>> handler.setFormatter(logging.Formatter("%(message)s"))
+    >>> filter = ChannelsFilter("A.B", "C.D")
+    >>> handler.addFilter(filter)
+    >>> root = logging.getLogger()
+    >>> root.addHandler(handler)
+    >>> root.setLevel(level=logging.DEBUG)
+    >>> logging.getLogger('A.B').debug('this record passes through')
+    this record passes through
+    >>> logging.getLogger('A.B.C').debug('records from children also pass')
+    records from children also pass
+    >>> logging.getLogger('C.D').debug('this one as well')
+    this one as well
+    >>> logging.getLogger('A.B.').debug('also this one')
+    also this one
+    >>> logging.getLogger('A.F').debug('but this one does not!')
+    >>> logging.getLogger('C.DE').debug('neither this one!')
+    """
+
+    def __init__(self, *names):
+        self.names = names
+        self.num = len(names)
+        self.lengths = {n: len(n) for n in names}
+
+    def filter(self, record):
+        if self.num == 0:
+            return True
+        for name in self.names:
+            nlen = self.lengths[name]
+            if name == record.name:
+                return True
+            elif record.name.find(name, 0, nlen) == 0 and record.name[nlen] == ".":
+                return True
+        return False
+
+
+class CapturingLogHandler(logging.Handler):
+    def __init__(self, logger, level):
+        super(CapturingLogHandler, self).__init__(level=level)
+        self.records = []
+        if isinstance(logger, str):
+            self.logger = logging.getLogger(logger)
+        else:
+            self.logger = logger
+
+    def __enter__(self):
+        self.original_disabled = self.logger.disabled
+        self.original_level = self.logger.level
+        self.original_propagate = self.logger.propagate
+
+        self.logger.addHandler(self)
+        self.logger.setLevel(self.level)
+        self.logger.disabled = False
+        self.logger.propagate = False
+
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.logger.removeHandler(self)
+        self.logger.setLevel(self.original_level)
+        self.logger.disabled = self.original_disabled
+        self.logger.propagate = self.original_propagate
+
+        return self
+
+    def emit(self, record):
+        self.records.append(record)
+
+    def assertRegex(self, regexp, msg=None):
+        import re
+
+        pattern = re.compile(regexp)
+        for r in self.records:
+            if pattern.search(r.getMessage()):
+                return True
+        if msg is None:
+            msg = "Pattern '%s' not found in logger records" % regexp
+        assert 0, msg
+
+
+class LogMixin(object):
+    """Mixin class that adds logging functionality to another class.
+
+    You can define a new class that subclasses from ``LogMixin`` as well as
+    other base classes through multiple inheritance.
+    All instances of that class will have a ``log`` property that returns
+    a ``logging.Logger`` named after their respective ``<module>.<class>``.
+
+    For example:
+
+    >>> class BaseClass(object):
+    ...     pass
+    >>> class MyClass(LogMixin, BaseClass):
+    ...     pass
+    >>> a = MyClass()
+    >>> isinstance(a.log, logging.Logger)
+    True
+    >>> print(a.log.name)
+    fontTools.misc.loggingTools.MyClass
+    >>> class AnotherClass(MyClass):
+    ...     pass
+    >>> b = AnotherClass()
+    >>> isinstance(b.log, logging.Logger)
+    True
+    >>> print(b.log.name)
+    fontTools.misc.loggingTools.AnotherClass
+    """
+
+    @property
+    def log(self):
+        if not hasattr(self, "_log"):
+            name = ".".join((self.__class__.__module__, self.__class__.__name__))
+            self._log = logging.getLogger(name)
+        return self._log
+
+
+def deprecateArgument(name, msg, category=UserWarning):
+    """Raise a warning about deprecated function argument 'name'."""
+    warnings.warn("%r is deprecated; %s" % (name, msg), category=category, stacklevel=3)
+
+
+def deprecateFunction(msg, category=UserWarning):
+    """Decorator to raise a warning when a deprecated function is called."""
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            warnings.warn(
+                "%r is deprecated; %s" % (func.__name__, msg),
+                category=category,
+                stacklevel=2,
+            )
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+if __name__ == "__main__":
+    import doctest
+
+    sys.exit(doctest.testmod(optionflags=doctest.ELLIPSIS).failed)

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

@@ -0,0 +1,261 @@
+from io import BytesIO
+import struct
+from fontTools.misc import sstruct
+from fontTools.misc.textTools import bytesjoin, tostr
+from collections import OrderedDict
+from collections.abc import MutableMapping
+
+
+class ResourceError(Exception):
+    pass
+
+
+class ResourceReader(MutableMapping):
+    """Reader for Mac OS resource forks.
+
+    Parses a resource fork and returns resources according to their type.
+    If run on OS X, this will open the resource fork in the filesystem.
+    Otherwise, it will open the file itself and attempt to read it as
+    though it were a resource fork.
+
+    The returned object can be indexed by type and iterated over,
+    returning in each case a list of py:class:`Resource` objects
+    representing all the resources of a certain type.
+
+    """
+
+    def __init__(self, fileOrPath):
+        """Open a file
+
+        Args:
+                fileOrPath: Either an object supporting a ``read`` method, an
+                        ``os.PathLike`` object, or a string.
+        """
+        self._resources = OrderedDict()
+        if hasattr(fileOrPath, "read"):
+            self.file = fileOrPath
+        else:
+            try:
+                # try reading from the resource fork (only works on OS X)
+                self.file = self.openResourceFork(fileOrPath)
+                self._readFile()
+                return
+            except (ResourceError, IOError):
+                # if it fails, use the data fork
+                self.file = self.openDataFork(fileOrPath)
+        self._readFile()
+
+    @staticmethod
+    def openResourceFork(path):
+        if hasattr(path, "__fspath__"):  # support os.PathLike objects
+            path = path.__fspath__()
+        with open(path + "/..namedfork/rsrc", "rb") as resfork:
+            data = resfork.read()
+        infile = BytesIO(data)
+        infile.name = path
+        return infile
+
+    @staticmethod
+    def openDataFork(path):
+        with open(path, "rb") as datafork:
+            data = datafork.read()
+        infile = BytesIO(data)
+        infile.name = path
+        return infile
+
+    def _readFile(self):
+        self._readHeaderAndMap()
+        self._readTypeList()
+
+    def _read(self, numBytes, offset=None):
+        if offset is not None:
+            try:
+                self.file.seek(offset)
+            except OverflowError:
+                raise ResourceError("Failed to seek offset ('offset' is too large)")
+            if self.file.tell() != offset:
+                raise ResourceError("Failed to seek offset (reached EOF)")
+        try:
+            data = self.file.read(numBytes)
+        except OverflowError:
+            raise ResourceError("Cannot read resource ('numBytes' is too large)")
+        if len(data) != numBytes:
+            raise ResourceError("Cannot read resource (not enough data)")
+        return data
+
+    def _readHeaderAndMap(self):
+        self.file.seek(0)
+        headerData = self._read(ResourceForkHeaderSize)
+        sstruct.unpack(ResourceForkHeader, headerData, self)
+        # seek to resource map, skip reserved
+        mapOffset = self.mapOffset + 22
+        resourceMapData = self._read(ResourceMapHeaderSize, mapOffset)
+        sstruct.unpack(ResourceMapHeader, resourceMapData, self)
+        self.absTypeListOffset = self.mapOffset + self.typeListOffset
+        self.absNameListOffset = self.mapOffset + self.nameListOffset
+
+    def _readTypeList(self):
+        absTypeListOffset = self.absTypeListOffset
+        numTypesData = self._read(2, absTypeListOffset)
+        (self.numTypes,) = struct.unpack(">H", numTypesData)
+        absTypeListOffset2 = absTypeListOffset + 2
+        for i in range(self.numTypes + 1):
+            resTypeItemOffset = absTypeListOffset2 + ResourceTypeItemSize * i
+            resTypeItemData = self._read(ResourceTypeItemSize, resTypeItemOffset)
+            item = sstruct.unpack(ResourceTypeItem, resTypeItemData)
+            resType = tostr(item["type"], encoding="mac-roman")
+            refListOffset = absTypeListOffset + item["refListOffset"]
+            numRes = item["numRes"] + 1
+            resources = self._readReferenceList(resType, refListOffset, numRes)
+            self._resources[resType] = resources
+
+    def _readReferenceList(self, resType, refListOffset, numRes):
+        resources = []
+        for i in range(numRes):
+            refOffset = refListOffset + ResourceRefItemSize * i
+            refData = self._read(ResourceRefItemSize, refOffset)
+            res = Resource(resType)
+            res.decompile(refData, self)
+            resources.append(res)
+        return resources
+
+    def __getitem__(self, resType):
+        return self._resources[resType]
+
+    def __delitem__(self, resType):
+        del self._resources[resType]
+
+    def __setitem__(self, resType, resources):
+        self._resources[resType] = resources
+
+    def __len__(self):
+        return len(self._resources)
+
+    def __iter__(self):
+        return iter(self._resources)
+
+    def keys(self):
+        return self._resources.keys()
+
+    @property
+    def types(self):
+        """A list of the types of resources in the resource fork."""
+        return list(self._resources.keys())
+
+    def countResources(self, resType):
+        """Return the number of resources of a given type."""
+        try:
+            return len(self[resType])
+        except KeyError:
+            return 0
+
+    def getIndices(self, resType):
+        """Returns a list of indices of resources of a given type."""
+        numRes = self.countResources(resType)
+        if numRes:
+            return list(range(1, numRes + 1))
+        else:
+            return []
+
+    def getNames(self, resType):
+        """Return list of names of all resources of a given type."""
+        return [res.name for res in self.get(resType, []) if res.name is not None]
+
+    def getIndResource(self, resType, index):
+        """Return resource of given type located at an index ranging from 1
+        to the number of resources for that type, or None if not found.
+        """
+        if index < 1:
+            return None
+        try:
+            res = self[resType][index - 1]
+        except (KeyError, IndexError):
+            return None
+        return res
+
+    def getNamedResource(self, resType, name):
+        """Return the named resource of given type, else return None."""
+        name = tostr(name, encoding="mac-roman")
+        for res in self.get(resType, []):
+            if res.name == name:
+                return res
+        return None
+
+    def close(self):
+        if not self.file.closed:
+            self.file.close()
+
+
+class Resource(object):
+    """Represents a resource stored within a resource fork.
+
+    Attributes:
+            type: resource type.
+            data: resource data.
+            id: ID.
+            name: resource name.
+            attr: attributes.
+    """
+
+    def __init__(
+        self, resType=None, resData=None, resID=None, resName=None, resAttr=None
+    ):
+        self.type = resType
+        self.data = resData
+        self.id = resID
+        self.name = resName
+        self.attr = resAttr
+
+    def decompile(self, refData, reader):
+        sstruct.unpack(ResourceRefItem, refData, self)
+        # interpret 3-byte dataOffset as (padded) ULONG to unpack it with struct
+        (self.dataOffset,) = struct.unpack(">L", bytesjoin([b"\0", self.dataOffset]))
+        absDataOffset = reader.dataOffset + self.dataOffset
+        (dataLength,) = struct.unpack(">L", reader._read(4, absDataOffset))
+        self.data = reader._read(dataLength)
+        if self.nameOffset == -1:
+            return
+        absNameOffset = reader.absNameListOffset + self.nameOffset
+        (nameLength,) = struct.unpack("B", reader._read(1, absNameOffset))
+        (name,) = struct.unpack(">%ss" % nameLength, reader._read(nameLength))
+        self.name = tostr(name, encoding="mac-roman")
+
+
+ResourceForkHeader = """
+		> # big endian
+		dataOffset:     L
+		mapOffset:      L
+		dataLen:        L
+		mapLen:         L
+"""
+
+ResourceForkHeaderSize = sstruct.calcsize(ResourceForkHeader)
+
+ResourceMapHeader = """
+		> # big endian
+		attr:              H
+		typeListOffset:    H
+		nameListOffset:    H
+"""
+
+ResourceMapHeaderSize = sstruct.calcsize(ResourceMapHeader)
+
+ResourceTypeItem = """
+		> # big endian
+		type:              4s
+		numRes:            H
+		refListOffset:     H
+"""
+
+ResourceTypeItemSize = sstruct.calcsize(ResourceTypeItem)
+
+ResourceRefItem = """
+		> # big endian
+		id:                h
+		nameOffset:        h
+		attr:              B
+		dataOffset:        3s
+		reserved:          L
+"""
+
+ResourceRefItemSize = sstruct.calcsize(ResourceRefItem)

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

@@ -0,0 +1,1496 @@
+"""psCharStrings.py -- module implementing various kinds of CharStrings:
+CFF dictionary data and Type1/Type2 CharStrings.
+"""
+
+from fontTools.misc.fixedTools import (
+    fixedToFloat,
+    floatToFixed,
+    floatToFixedToStr,
+    strToFixedToFloat,
+)
+from fontTools.misc.textTools import bytechr, byteord, bytesjoin, strjoin
+from fontTools.pens.boundsPen import BoundsPen
+import struct
+import logging
+
+
+log = logging.getLogger(__name__)
+
+
+def read_operator(self, b0, data, index):
+    if b0 == 12:
+        op = (b0, byteord(data[index]))
+        index = index + 1
+    else:
+        op = b0
+    try:
+        operator = self.operators[op]
+    except KeyError:
+        return None, index
+    value = self.handle_operator(operator)
+    return value, index
+
+
+def read_byte(self, b0, data, index):
+    return b0 - 139, index
+
+
+def read_smallInt1(self, b0, data, index):
+    b1 = byteord(data[index])
+    return (b0 - 247) * 256 + b1 + 108, index + 1
+
+
+def read_smallInt2(self, b0, data, index):
+    b1 = byteord(data[index])
+    return -(b0 - 251) * 256 - b1 - 108, index + 1
+
+
+def read_shortInt(self, b0, data, index):
+    (value,) = struct.unpack(">h", data[index : index + 2])
+    return value, index + 2
+
+
+def read_longInt(self, b0, data, index):
+    (value,) = struct.unpack(">l", data[index : index + 4])
+    return value, index + 4
+
+
+def read_fixed1616(self, b0, data, index):
+    (value,) = struct.unpack(">l", data[index : index + 4])
+    return fixedToFloat(value, precisionBits=16), index + 4
+
+
+def read_reserved(self, b0, data, index):
+    assert NotImplementedError
+    return NotImplemented, index
+
+
+def read_realNumber(self, b0, data, index):
+    number = ""
+    while True:
+        b = byteord(data[index])
+        index = index + 1
+        nibble0 = (b & 0xF0) >> 4
+        nibble1 = b & 0x0F
+        if nibble0 == 0xF:
+            break
+        number = number + realNibbles[nibble0]
+        if nibble1 == 0xF:
+            break
+        number = number + realNibbles[nibble1]
+    return float(number), index
+
+
+t1OperandEncoding = [None] * 256
+t1OperandEncoding[0:32] = (32) * [read_operator]
+t1OperandEncoding[32:247] = (247 - 32) * [read_byte]
+t1OperandEncoding[247:251] = (251 - 247) * [read_smallInt1]
+t1OperandEncoding[251:255] = (255 - 251) * [read_smallInt2]
+t1OperandEncoding[255] = read_longInt
+assert len(t1OperandEncoding) == 256
+
+t2OperandEncoding = t1OperandEncoding[:]
+t2OperandEncoding[28] = read_shortInt
+t2OperandEncoding[255] = read_fixed1616
+
+cffDictOperandEncoding = t2OperandEncoding[:]
+cffDictOperandEncoding[29] = read_longInt
+cffDictOperandEncoding[30] = read_realNumber
+cffDictOperandEncoding[255] = read_reserved
+
+
+realNibbles = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    ".",
+    "E",
+    "E-",
+    None,
+    "-",
+]
+realNibblesDict = {v: i for i, v in enumerate(realNibbles)}
+
+maxOpStack = 193
+
+
+def buildOperatorDict(operatorList):
+    oper = {}
+    opc = {}
+    for item in operatorList:
+        if len(item) == 2:
+            oper[item[0]] = item[1]
+        else:
+            oper[item[0]] = item[1:]
+        if isinstance(item[0], tuple):
+            opc[item[1]] = item[0]
+        else:
+            opc[item[1]] = (item[0],)
+    return oper, opc
+
+
+t2Operators = [
+    # 	opcode		name
+    (1, "hstem"),
+    (3, "vstem"),
+    (4, "vmoveto"),
+    (5, "rlineto"),
+    (6, "hlineto"),
+    (7, "vlineto"),
+    (8, "rrcurveto"),
+    (10, "callsubr"),
+    (11, "return"),
+    (14, "endchar"),
+    (15, "vsindex"),
+    (16, "blend"),
+    (18, "hstemhm"),
+    (19, "hintmask"),
+    (20, "cntrmask"),
+    (21, "rmoveto"),
+    (22, "hmoveto"),
+    (23, "vstemhm"),
+    (24, "rcurveline"),
+    (25, "rlinecurve"),
+    (26, "vvcurveto"),
+    (27, "hhcurveto"),
+    # 	(28,		'shortint'),  # not really an operator
+    (29, "callgsubr"),
+    (30, "vhcurveto"),
+    (31, "hvcurveto"),
+    ((12, 0), "ignore"),  # dotsection. Yes, there a few very early OTF/CFF
+    # fonts with this deprecated operator. Just ignore it.
+    ((12, 3), "and"),
+    ((12, 4), "or"),
+    ((12, 5), "not"),
+    ((12, 8), "store"),
+    ((12, 9), "abs"),
+    ((12, 10), "add"),
+    ((12, 11), "sub"),
+    ((12, 12), "div"),
+    ((12, 13), "load"),
+    ((12, 14), "neg"),
+    ((12, 15), "eq"),
+    ((12, 18), "drop"),
+    ((12, 20), "put"),
+    ((12, 21), "get"),
+    ((12, 22), "ifelse"),
+    ((12, 23), "random"),
+    ((12, 24), "mul"),
+    ((12, 26), "sqrt"),
+    ((12, 27), "dup"),
+    ((12, 28), "exch"),
+    ((12, 29), "index"),
+    ((12, 30), "roll"),
+    ((12, 34), "hflex"),
+    ((12, 35), "flex"),
+    ((12, 36), "hflex1"),
+    ((12, 37), "flex1"),
+]
+
+
+def getIntEncoder(format):
+    if format == "cff":
+        twoByteOp = bytechr(28)
+        fourByteOp = bytechr(29)
+    elif format == "t1":
+        twoByteOp = None
+        fourByteOp = bytechr(255)
+    else:
+        assert format == "t2"
+        twoByteOp = bytechr(28)
+        fourByteOp = None
+
+    def encodeInt(
+        value,
+        fourByteOp=fourByteOp,
+        bytechr=bytechr,
+        pack=struct.pack,
+        unpack=struct.unpack,
+        twoByteOp=twoByteOp,
+    ):
+        if -107 <= value <= 107:
+            code = bytechr(value + 139)
+        elif 108 <= value <= 1131:
+            value = value - 108
+            code = bytechr((value >> 8) + 247) + bytechr(value & 0xFF)
+        elif -1131 <= value <= -108:
+            value = -value - 108
+            code = bytechr((value >> 8) + 251) + bytechr(value & 0xFF)
+        elif twoByteOp is not None and -32768 <= value <= 32767:
+            code = twoByteOp + pack(">h", value)
+        elif fourByteOp is None:
+            # Backwards compatible hack: due to a previous bug in FontTools,
+            # 16.16 fixed numbers were written out as 4-byte ints. When
+            # these numbers were small, they were wrongly written back as
+            # small ints instead of 4-byte ints, breaking round-tripping.
+            # This here workaround doesn't do it any better, since we can't
+            # distinguish anymore between small ints that were supposed to
+            # be small fixed numbers and small ints that were just small
+            # ints. Hence the warning.
+            log.warning(
+                "4-byte T2 number got passed to the "
+                "IntType handler. This should happen only when reading in "
+                "old XML files.\n"
+            )
+            code = bytechr(255) + pack(">l", value)
+        else:
+            code = fourByteOp + pack(">l", value)
+        return code
+
+    return encodeInt
+
+
+encodeIntCFF = getIntEncoder("cff")
+encodeIntT1 = getIntEncoder("t1")
+encodeIntT2 = getIntEncoder("t2")
+
+
+def encodeFixed(f, pack=struct.pack):
+    """For T2 only"""
+    value = floatToFixed(f, precisionBits=16)
+    if value & 0xFFFF == 0:  # check if the fractional part is zero
+        return encodeIntT2(value >> 16)  # encode only the integer part
+    else:
+        return b"\xff" + pack(">l", value)  # encode the entire fixed point value
+
+
+realZeroBytes = bytechr(30) + bytechr(0xF)
+
+
+def encodeFloat(f):
+    # For CFF only, used in cffLib
+    if f == 0.0:  # 0.0 == +0.0 == -0.0
+        return realZeroBytes
+    # Note: 14 decimal digits seems to be the limitation for CFF real numbers
+    # in macOS. However, we use 8 here to match the implementation of AFDKO.
+    s = "%.8G" % f
+    if s[:2] == "0.":
+        s = s[1:]
+    elif s[:3] == "-0.":
+        s = "-" + s[2:]
+    elif s.endswith("000"):
+        significantDigits = s.rstrip("0")
+        s = "%sE%d" % (significantDigits, len(s) - len(significantDigits))
+    else:
+        dotIndex = s.find(".")
+        eIndex = s.find("E")
+        if dotIndex != -1 and eIndex != -1:
+            integerPart = s[:dotIndex]
+            fractionalPart = s[dotIndex + 1 : eIndex]
+            exponent = int(s[eIndex + 1 :])
+            newExponent = exponent - len(fractionalPart)
+            if newExponent == 1:
+                s = "%s%s0" % (integerPart, fractionalPart)
+            else:
+                s = "%s%sE%d" % (integerPart, fractionalPart, newExponent)
+    if s.startswith((".0", "-.0")):
+        sign, s = s.split(".", 1)
+        s = "%s%sE-%d" % (sign, s.lstrip("0"), len(s))
+    nibbles = []
+    while s:
+        c = s[0]
+        s = s[1:]
+        if c == "E":
+            c2 = s[:1]
+            if c2 == "-":
+                s = s[1:]
+                c = "E-"
+            elif c2 == "+":
+                s = s[1:]
+            if s.startswith("0"):
+                s = s[1:]
+        nibbles.append(realNibblesDict[c])
+    nibbles.append(0xF)
+    if len(nibbles) % 2:
+        nibbles.append(0xF)
+    d = bytechr(30)
+    for i in range(0, len(nibbles), 2):
+        d = d + bytechr(nibbles[i] << 4 | nibbles[i + 1])
+    return d
+
+
+class CharStringCompileError(Exception):
+    pass
+
+
+class SimpleT2Decompiler(object):
+    def __init__(self, localSubrs, globalSubrs, private=None, blender=None):
+        self.localSubrs = localSubrs
+        self.localBias = calcSubrBias(localSubrs)
+        self.globalSubrs = globalSubrs
+        self.globalBias = calcSubrBias(globalSubrs)
+        self.private = private
+        self.blender = blender
+        self.reset()
+
+    def reset(self):
+        self.callingStack = []
+        self.operandStack = []
+        self.hintCount = 0
+        self.hintMaskBytes = 0
+        self.numRegions = 0
+        self.vsIndex = 0
+
+    def execute(self, charString):
+        self.callingStack.append(charString)
+        needsDecompilation = charString.needsDecompilation()
+        if needsDecompilation:
+            program = []
+            pushToProgram = program.append
+        else:
+            pushToProgram = lambda x: None
+        pushToStack = self.operandStack.append
+        index = 0
+        while True:
+            token, isOperator, index = charString.getToken(index)
+            if token is None:
+                break  # we're done!
+            pushToProgram(token)
+            if isOperator:
+                handlerName = "op_" + token
+                handler = getattr(self, handlerName, None)
+                if handler is not None:
+                    rv = handler(index)
+                    if rv:
+                        hintMaskBytes, index = rv
+                        pushToProgram(hintMaskBytes)
+                else:
+                    self.popall()
+            else:
+                pushToStack(token)
+        if needsDecompilation:
+            charString.setProgram(program)
+        del self.callingStack[-1]
+
+    def pop(self):
+        value = self.operandStack[-1]
+        del self.operandStack[-1]
+        return value
+
+    def popall(self):
+        stack = self.operandStack[:]
+        self.operandStack[:] = []
+        return stack
+
+    def push(self, value):
+        self.operandStack.append(value)
+
+    def op_return(self, index):
+        if self.operandStack:
+            pass
+
+    def op_endchar(self, index):
+        pass
+
+    def op_ignore(self, index):
+        pass
+
+    def op_callsubr(self, index):
+        subrIndex = self.pop()
+        subr = self.localSubrs[subrIndex + self.localBias]
+        self.execute(subr)
+
+    def op_callgsubr(self, index):
+        subrIndex = self.pop()
+        subr = self.globalSubrs[subrIndex + self.globalBias]
+        self.execute(subr)
+
+    def op_hstem(self, index):
+        self.countHints()
+
+    def op_vstem(self, index):
+        self.countHints()
+
+    def op_hstemhm(self, index):
+        self.countHints()
+
+    def op_vstemhm(self, index):
+        self.countHints()
+
+    def op_hintmask(self, index):
+        if not self.hintMaskBytes:
+            self.countHints()
+            self.hintMaskBytes = (self.hintCount + 7) // 8
+        hintMaskBytes, index = self.callingStack[-1].getBytes(index, self.hintMaskBytes)
+        return hintMaskBytes, index
+
+    op_cntrmask = op_hintmask
+
+    def countHints(self):
+        args = self.popall()
+        self.hintCount = self.hintCount + len(args) // 2
+
+    # misc
+    def op_and(self, index):
+        raise NotImplementedError
+
+    def op_or(self, index):
+        raise NotImplementedError
+
+    def op_not(self, index):
+        raise NotImplementedError
+
+    def op_store(self, index):
+        raise NotImplementedError
+
+    def op_abs(self, index):
+        raise NotImplementedError
+
+    def op_add(self, index):
+        raise NotImplementedError
+
+    def op_sub(self, index):
+        raise NotImplementedError
+
+    def op_div(self, index):
+        raise NotImplementedError
+
+    def op_load(self, index):
+        raise NotImplementedError
+
+    def op_neg(self, index):
+        raise NotImplementedError
+
+    def op_eq(self, index):
+        raise NotImplementedError
+
+    def op_drop(self, index):
+        raise NotImplementedError
+
+    def op_put(self, index):
+        raise NotImplementedError
+
+    def op_get(self, index):
+        raise NotImplementedError
+
+    def op_ifelse(self, index):
+        raise NotImplementedError
+
+    def op_random(self, index):
+        raise NotImplementedError
+
+    def op_mul(self, index):
+        raise NotImplementedError
+
+    def op_sqrt(self, index):
+        raise NotImplementedError
+
+    def op_dup(self, index):
+        raise NotImplementedError
+
+    def op_exch(self, index):
+        raise NotImplementedError
+
+    def op_index(self, index):
+        raise NotImplementedError
+
+    def op_roll(self, index):
+        raise NotImplementedError
+
+    def op_blend(self, index):
+        if self.numRegions == 0:
+            self.numRegions = self.private.getNumRegions()
+        numBlends = self.pop()
+        numOps = numBlends * (self.numRegions + 1)
+        if self.blender is None:
+            del self.operandStack[
+                -(numOps - numBlends) :
+            ]  # Leave the default operands on the stack.
+        else:
+            argi = len(self.operandStack) - numOps
+            end_args = tuplei = argi + numBlends
+            while argi < end_args:
+                next_ti = tuplei + self.numRegions
+                deltas = self.operandStack[tuplei:next_ti]
+                delta = self.blender(self.vsIndex, deltas)
+                self.operandStack[argi] += delta
+                tuplei = next_ti
+                argi += 1
+            self.operandStack[end_args:] = []
+
+    def op_vsindex(self, index):
+        vi = self.pop()
+        self.vsIndex = vi
+        self.numRegions = self.private.getNumRegions(vi)
+
+
+t1Operators = [
+    # 	opcode		name
+    (1, "hstem"),
+    (3, "vstem"),
+    (4, "vmoveto"),
+    (5, "rlineto"),
+    (6, "hlineto"),
+    (7, "vlineto"),
+    (8, "rrcurveto"),
+    (9, "closepath"),
+    (10, "callsubr"),
+    (11, "return"),
+    (13, "hsbw"),
+    (14, "endchar"),
+    (21, "rmoveto"),
+    (22, "hmoveto"),
+    (30, "vhcurveto"),
+    (31, "hvcurveto"),
+    ((12, 0), "dotsection"),
+    ((12, 1), "vstem3"),
+    ((12, 2), "hstem3"),
+    ((12, 6), "seac"),
+    ((12, 7), "sbw"),
+    ((12, 12), "div"),
+    ((12, 16), "callothersubr"),
+    ((12, 17), "pop"),
+    ((12, 33), "setcurrentpoint"),
+]
+
+
+class T2WidthExtractor(SimpleT2Decompiler):
+    def __init__(
+        self,
+        localSubrs,
+        globalSubrs,
+        nominalWidthX,
+        defaultWidthX,
+        private=None,
+        blender=None,
+    ):
+        SimpleT2Decompiler.__init__(self, localSubrs, globalSubrs, private, blender)
+        self.nominalWidthX = nominalWidthX
+        self.defaultWidthX = defaultWidthX
+
+    def reset(self):
+        SimpleT2Decompiler.reset(self)
+        self.gotWidth = 0
+        self.width = 0
+
+    def popallWidth(self, evenOdd=0):
+        args = self.popall()
+        if not self.gotWidth:
+            if evenOdd ^ (len(args) % 2):
+                # For CFF2 charstrings, this should never happen
+                assert (
+                    self.defaultWidthX is not None
+                ), "CFF2 CharStrings must not have an initial width value"
+                self.width = self.nominalWidthX + args[0]
+                args = args[1:]
+            else:
+                self.width = self.defaultWidthX
+            self.gotWidth = 1
+        return args
+
+    def countHints(self):
+        args = self.popallWidth()
+        self.hintCount = self.hintCount + len(args) // 2
+
+    def op_rmoveto(self, index):
+        self.popallWidth()
+
+    def op_hmoveto(self, index):
+        self.popallWidth(1)
+
+    def op_vmoveto(self, index):
+        self.popallWidth(1)
+
+    def op_endchar(self, index):
+        self.popallWidth()
+
+
+class T2OutlineExtractor(T2WidthExtractor):
+    def __init__(
+        self,
+        pen,
+        localSubrs,
+        globalSubrs,
+        nominalWidthX,
+        defaultWidthX,
+        private=None,
+        blender=None,
+    ):
+        T2WidthExtractor.__init__(
+            self,
+            localSubrs,
+            globalSubrs,
+            nominalWidthX,
+            defaultWidthX,
+            private,
+            blender,
+        )
+        self.pen = pen
+        self.subrLevel = 0
+
+    def reset(self):
+        T2WidthExtractor.reset(self)
+        self.currentPoint = (0, 0)
+        self.sawMoveTo = 0
+        self.subrLevel = 0
+
+    def execute(self, charString):
+        self.subrLevel += 1
+        super().execute(charString)
+        self.subrLevel -= 1
+        if self.subrLevel == 0:
+            self.endPath()
+
+    def _nextPoint(self, point):
+        x, y = self.currentPoint
+        point = x + point[0], y + point[1]
+        self.currentPoint = point
+        return point
+
+    def rMoveTo(self, point):
+        self.pen.moveTo(self._nextPoint(point))
+        self.sawMoveTo = 1
+
+    def rLineTo(self, point):
+        if not self.sawMoveTo:
+            self.rMoveTo((0, 0))
+        self.pen.lineTo(self._nextPoint(point))
+
+    def rCurveTo(self, pt1, pt2, pt3):
+        if not self.sawMoveTo:
+            self.rMoveTo((0, 0))
+        nextPoint = self._nextPoint
+        self.pen.curveTo(nextPoint(pt1), nextPoint(pt2), nextPoint(pt3))
+
+    def closePath(self):
+        if self.sawMoveTo:
+            self.pen.closePath()
+        self.sawMoveTo = 0
+
+    def endPath(self):
+        # In T2 there are no open paths, so always do a closePath when
+        # finishing a sub path. We avoid spurious calls to closePath()
+        # because its a real T1 op we're emulating in T2 whereas
+        # endPath() is just a means to that emulation
+        if self.sawMoveTo:
+            self.closePath()
+
+    #
+    # hint operators
+    #
+    # def op_hstem(self, index):
+    # 	self.countHints()
+    # def op_vstem(self, index):
+    # 	self.countHints()
+    # def op_hstemhm(self, index):
+    # 	self.countHints()
+    # def op_vstemhm(self, index):
+    # 	self.countHints()
+    # def op_hintmask(self, index):
+    # 	self.countHints()
+    # def op_cntrmask(self, index):
+    # 	self.countHints()
+
+    #
+    # path constructors, moveto
+    #
+    def op_rmoveto(self, index):
+        self.endPath()
+        self.rMoveTo(self.popallWidth())
+
+    def op_hmoveto(self, index):
+        self.endPath()
+        self.rMoveTo((self.popallWidth(1)[0], 0))
+
+    def op_vmoveto(self, index):
+        self.endPath()
+        self.rMoveTo((0, self.popallWidth(1)[0]))
+
+    def op_endchar(self, index):
+        self.endPath()
+        args = self.popallWidth()
+        if args:
+            from fontTools.encodings.StandardEncoding import StandardEncoding
+
+            # endchar can do seac accent bulding; The T2 spec says it's deprecated,
+            # but recent software that shall remain nameless does output it.
+            adx, ady, bchar, achar = args
+            baseGlyph = StandardEncoding[bchar]
+            self.pen.addComponent(baseGlyph, (1, 0, 0, 1, 0, 0))
+            accentGlyph = StandardEncoding[achar]
+            self.pen.addComponent(accentGlyph, (1, 0, 0, 1, adx, ady))
+
+    #
+    # path constructors, lines
+    #
+    def op_rlineto(self, index):
+        args = self.popall()
+        for i in range(0, len(args), 2):
+            point = args[i : i + 2]
+            self.rLineTo(point)
+
+    def op_hlineto(self, index):
+        self.alternatingLineto(1)
+
+    def op_vlineto(self, index):
+        self.alternatingLineto(0)
+
+    #
+    # path constructors, curves
+    #
+    def op_rrcurveto(self, index):
+        """{dxa dya dxb dyb dxc dyc}+ rrcurveto"""
+        args = self.popall()
+        for i in range(0, len(args), 6):
+            (
+                dxa,
+                dya,
+                dxb,
+                dyb,
+                dxc,
+                dyc,
+            ) = args[i : i + 6]
+            self.rCurveTo((dxa, dya), (dxb, dyb), (dxc, dyc))
+
+    def op_rcurveline(self, index):
+        """{dxa dya dxb dyb dxc dyc}+ dxd dyd rcurveline"""
+        args = self.popall()
+        for i in range(0, len(args) - 2, 6):
+            dxb, dyb, dxc, dyc, dxd, dyd = args[i : i + 6]
+            self.rCurveTo((dxb, dyb), (dxc, dyc), (dxd, dyd))
+        self.rLineTo(args[-2:])
+
+    def op_rlinecurve(self, index):
+        """{dxa dya}+ dxb dyb dxc dyc dxd dyd rlinecurve"""
+        args = self.popall()
+        lineArgs = args[:-6]
+        for i in range(0, len(lineArgs), 2):
+            self.rLineTo(lineArgs[i : i + 2])
+        dxb, dyb, dxc, dyc, dxd, dyd = args[-6:]
+        self.rCurveTo((dxb, dyb), (dxc, dyc), (dxd, dyd))
+
+    def op_vvcurveto(self, index):
+        "dx1? {dya dxb dyb dyc}+ vvcurveto"
+        args = self.popall()
+        if len(args) % 2:
+            dx1 = args[0]
+            args = args[1:]
+        else:
+            dx1 = 0
+        for i in range(0, len(args), 4):
+            dya, dxb, dyb, dyc = args[i : i + 4]
+            self.rCurveTo((dx1, dya), (dxb, dyb), (0, dyc))
+            dx1 = 0
+
+    def op_hhcurveto(self, index):
+        """dy1? {dxa dxb dyb dxc}+ hhcurveto"""
+        args = self.popall()
+        if len(args) % 2:
+            dy1 = args[0]
+            args = args[1:]
+        else:
+            dy1 = 0
+        for i in range(0, len(args), 4):
+            dxa, dxb, dyb, dxc = args[i : i + 4]
+            self.rCurveTo((dxa, dy1), (dxb, dyb), (dxc, 0))
+            dy1 = 0
+
+    def op_vhcurveto(self, index):
+        """dy1 dx2 dy2 dx3 {dxa dxb dyb dyc dyd dxe dye dxf}* dyf? vhcurveto (30)
+        {dya dxb dyb dxc dxd dxe dye dyf}+ dxf? vhcurveto
+        """
+        args = self.popall()
+        while args:
+            args = self.vcurveto(args)
+            if args:
+                args = self.hcurveto(args)
+
+    def op_hvcurveto(self, index):
+        """dx1 dx2 dy2 dy3 {dya dxb dyb dxc dxd dxe dye dyf}* dxf?
+        {dxa dxb dyb dyc dyd dxe dye dxf}+ dyf?
+        """
+        args = self.popall()
+        while args:
+            args = self.hcurveto(args)
+            if args:
+                args = self.vcurveto(args)
+
+    #
+    # path constructors, flex
+    #
+    def op_hflex(self, index):
+        dx1, dx2, dy2, dx3, dx4, dx5, dx6 = self.popall()
+        dy1 = dy3 = dy4 = dy6 = 0
+        dy5 = -dy2
+        self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
+        self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
+
+    def op_flex(self, index):
+        dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4, dx5, dy5, dx6, dy6, fd = self.popall()
+        self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
+        self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
+
+    def op_hflex1(self, index):
+        dx1, dy1, dx2, dy2, dx3, dx4, dx5, dy5, dx6 = self.popall()
+        dy3 = dy4 = 0
+        dy6 = -(dy1 + dy2 + dy3 + dy4 + dy5)
+
+        self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
+        self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
+
+    def op_flex1(self, index):
+        dx1, dy1, dx2, dy2, dx3, dy3, dx4, dy4, dx5, dy5, d6 = self.popall()
+        dx = dx1 + dx2 + dx3 + dx4 + dx5
+        dy = dy1 + dy2 + dy3 + dy4 + dy5
+        if abs(dx) > abs(dy):
+            dx6 = d6
+            dy6 = -dy
+        else:
+            dx6 = -dx
+            dy6 = d6
+        self.rCurveTo((dx1, dy1), (dx2, dy2), (dx3, dy3))
+        self.rCurveTo((dx4, dy4), (dx5, dy5), (dx6, dy6))
+
+    # misc
+    def op_and(self, index):
+        raise NotImplementedError
+
+    def op_or(self, index):
+        raise NotImplementedError
+
+    def op_not(self, index):
+        raise NotImplementedError
+
+    def op_store(self, index):
+        raise NotImplementedError
+
+    def op_abs(self, index):
+        raise NotImplementedError
+
+    def op_add(self, index):
+        raise NotImplementedError
+
+    def op_sub(self, index):
+        raise NotImplementedError
+
+    def op_div(self, index):
+        num2 = self.pop()
+        num1 = self.pop()
+        d1 = num1 // num2
+        d2 = num1 / num2
+        if d1 == d2:
+            self.push(d1)
+        else:
+            self.push(d2)
+
+    def op_load(self, index):
+        raise NotImplementedError
+
+    def op_neg(self, index):
+        raise NotImplementedError
+
+    def op_eq(self, index):
+        raise NotImplementedError
+
+    def op_drop(self, index):
+        raise NotImplementedError
+
+    def op_put(self, index):
+        raise NotImplementedError
+
+    def op_get(self, index):
+        raise NotImplementedError
+
+    def op_ifelse(self, index):
+        raise NotImplementedError
+
+    def op_random(self, index):
+        raise NotImplementedError
+
+    def op_mul(self, index):
+        raise NotImplementedError
+
+    def op_sqrt(self, index):
+        raise NotImplementedError
+
+    def op_dup(self, index):
+        raise NotImplementedError
+
+    def op_exch(self, index):
+        raise NotImplementedError
+
+    def op_index(self, index):
+        raise NotImplementedError
+
+    def op_roll(self, index):
+        raise NotImplementedError
+
+    #
+    # miscellaneous helpers
+    #
+    def alternatingLineto(self, isHorizontal):
+        args = self.popall()
+        for arg in args:
+            if isHorizontal:
+                point = (arg, 0)
+            else:
+                point = (0, arg)
+            self.rLineTo(point)
+            isHorizontal = not isHorizontal
+
+    def vcurveto(self, args):
+        dya, dxb, dyb, dxc = args[:4]
+        args = args[4:]
+        if len(args) == 1:
+            dyc = args[0]
+            args = []
+        else:
+            dyc = 0
+        self.rCurveTo((0, dya), (dxb, dyb), (dxc, dyc))
+        return args
+
+    def hcurveto(self, args):
+        dxa, dxb, dyb, dyc = args[:4]
+        args = args[4:]
+        if len(args) == 1:
+            dxc = args[0]
+            args = []
+        else:
+            dxc = 0
+        self.rCurveTo((dxa, 0), (dxb, dyb), (dxc, dyc))
+        return args
+
+
+class T1OutlineExtractor(T2OutlineExtractor):
+    def __init__(self, pen, subrs):
+        self.pen = pen
+        self.subrs = subrs
+        self.reset()
+
+    def reset(self):
+        self.flexing = 0
+        self.width = 0
+        self.sbx = 0
+        T2OutlineExtractor.reset(self)
+
+    def endPath(self):
+        if self.sawMoveTo:
+            self.pen.endPath()
+        self.sawMoveTo = 0
+
+    def popallWidth(self, evenOdd=0):
+        return self.popall()
+
+    def exch(self):
+        stack = self.operandStack
+        stack[-1], stack[-2] = stack[-2], stack[-1]
+
+    #
+    # path constructors
+    #
+    def op_rmoveto(self, index):
+        if self.flexing:
+            return
+        self.endPath()
+        self.rMoveTo(self.popall())
+
+    def op_hmoveto(self, index):
+        if self.flexing:
+            # We must add a parameter to the stack if we are flexing
+            self.push(0)
+            return
+        self.endPath()
+        self.rMoveTo((self.popall()[0], 0))
+
+    def op_vmoveto(self, index):
+        if self.flexing:
+            # We must add a parameter to the stack if we are flexing
+            self.push(0)
+            self.exch()
+            return
+        self.endPath()
+        self.rMoveTo((0, self.popall()[0]))
+
+    def op_closepath(self, index):
+        self.closePath()
+
+    def op_setcurrentpoint(self, index):
+        args = self.popall()
+        x, y = args
+        self.currentPoint = x, y
+
+    def op_endchar(self, index):
+        self.endPath()
+
+    def op_hsbw(self, index):
+        sbx, wx = self.popall()
+        self.width = wx
+        self.sbx = sbx
+        self.currentPoint = sbx, self.currentPoint[1]
+
+    def op_sbw(self, index):
+        self.popall()  # XXX
+
+    #
+    def op_callsubr(self, index):
+        subrIndex = self.pop()
+        subr = self.subrs[subrIndex]
+        self.execute(subr)
+
+    def op_callothersubr(self, index):
+        subrIndex = self.pop()
+        nArgs = self.pop()
+        # print nArgs, subrIndex, "callothersubr"
+        if subrIndex == 0 and nArgs == 3:
+            self.doFlex()
+            self.flexing = 0
+        elif subrIndex == 1 and nArgs == 0:
+            self.flexing = 1
+        # ignore...
+
+    def op_pop(self, index):
+        pass  # ignore...
+
+    def doFlex(self):
+        finaly = self.pop()
+        finalx = self.pop()
+        self.pop()  # flex height is unused
+
+        p3y = self.pop()
+        p3x = self.pop()
+        bcp4y = self.pop()
+        bcp4x = self.pop()
+        bcp3y = self.pop()
+        bcp3x = self.pop()
+        p2y = self.pop()
+        p2x = self.pop()
+        bcp2y = self.pop()
+        bcp2x = self.pop()
+        bcp1y = self.pop()
+        bcp1x = self.pop()
+        rpy = self.pop()
+        rpx = self.pop()
+
+        # call rrcurveto
+        self.push(bcp1x + rpx)
+        self.push(bcp1y + rpy)
+        self.push(bcp2x)
+        self.push(bcp2y)
+        self.push(p2x)
+        self.push(p2y)
+        self.op_rrcurveto(None)
+
+        # call rrcurveto
+        self.push(bcp3x)
+        self.push(bcp3y)
+        self.push(bcp4x)
+        self.push(bcp4y)
+        self.push(p3x)
+        self.push(p3y)
+        self.op_rrcurveto(None)
+
+        # Push back final coords so subr 0 can find them
+        self.push(finalx)
+        self.push(finaly)
+
+    def op_dotsection(self, index):
+        self.popall()  # XXX
+
+    def op_hstem3(self, index):
+        self.popall()  # XXX
+
+    def op_seac(self, index):
+        "asb adx ady bchar achar seac"
+        from fontTools.encodings.StandardEncoding import StandardEncoding
+
+        asb, adx, ady, bchar, achar = self.popall()
+        baseGlyph = StandardEncoding[bchar]
+        self.pen.addComponent(baseGlyph, (1, 0, 0, 1, 0, 0))
+        accentGlyph = StandardEncoding[achar]
+        adx = adx + self.sbx - asb  # seac weirdness
+        self.pen.addComponent(accentGlyph, (1, 0, 0, 1, adx, ady))
+
+    def op_vstem3(self, index):
+        self.popall()  # XXX
+
+
+class T2CharString(object):
+    operandEncoding = t2OperandEncoding
+    operators, opcodes = buildOperatorDict(t2Operators)
+    decompilerClass = SimpleT2Decompiler
+    outlineExtractor = T2OutlineExtractor
+
+    def __init__(self, bytecode=None, program=None, private=None, globalSubrs=None):
+        if program is None:
+            program = []
+        self.bytecode = bytecode
+        self.program = program
+        self.private = private
+        self.globalSubrs = globalSubrs if globalSubrs is not None else []
+        self._cur_vsindex = None
+
+    def getNumRegions(self, vsindex=None):
+        pd = self.private
+        assert pd is not None
+        if vsindex is not None:
+            self._cur_vsindex = vsindex
+        elif self._cur_vsindex is None:
+            self._cur_vsindex = pd.vsindex if hasattr(pd, "vsindex") else 0
+        return pd.getNumRegions(self._cur_vsindex)
+
+    def __repr__(self):
+        if self.bytecode is None:
+            return "<%s (source) at %x>" % (self.__class__.__name__, id(self))
+        else:
+            return "<%s (bytecode) at %x>" % (self.__class__.__name__, id(self))
+
+    def getIntEncoder(self):
+        return encodeIntT2
+
+    def getFixedEncoder(self):
+        return encodeFixed
+
+    def decompile(self):
+        if not self.needsDecompilation():
+            return
+        subrs = getattr(self.private, "Subrs", [])
+        decompiler = self.decompilerClass(subrs, self.globalSubrs, self.private)
+        decompiler.execute(self)
+
+    def draw(self, pen, blender=None):
+        subrs = getattr(self.private, "Subrs", [])
+        extractor = self.outlineExtractor(
+            pen,
+            subrs,
+            self.globalSubrs,
+            self.private.nominalWidthX,
+            self.private.defaultWidthX,
+            self.private,
+            blender,
+        )
+        extractor.execute(self)
+        self.width = extractor.width
+
+    def calcBounds(self, glyphSet):
+        boundsPen = BoundsPen(glyphSet)
+        self.draw(boundsPen)
+        return boundsPen.bounds
+
+    def compile(self, isCFF2=False):
+        if self.bytecode is not None:
+            return
+        opcodes = self.opcodes
+        program = self.program
+
+        if isCFF2:
+            # If present, remove return and endchar operators.
+            if program and program[-1] in ("return", "endchar"):
+                program = program[:-1]
+        elif program and not isinstance(program[-1], str):
+            raise CharStringCompileError(
+                "T2CharString or Subr has items on the stack after last operator."
+            )
+
+        bytecode = []
+        encodeInt = self.getIntEncoder()
+        encodeFixed = self.getFixedEncoder()
+        i = 0
+        end = len(program)
+        while i < end:
+            token = program[i]
+            i = i + 1
+            if isinstance(token, str):
+                try:
+                    bytecode.extend(bytechr(b) for b in opcodes[token])
+                except KeyError:
+                    raise CharStringCompileError("illegal operator: %s" % token)
+                if token in ("hintmask", "cntrmask"):
+                    bytecode.append(program[i])  # hint mask
+                    i = i + 1
+            elif isinstance(token, int):
+                bytecode.append(encodeInt(token))
+            elif isinstance(token, float):
+                bytecode.append(encodeFixed(token))
+            else:
+                assert 0, "unsupported type: %s" % type(token)
+        try:
+            bytecode = bytesjoin(bytecode)
+        except TypeError:
+            log.error(bytecode)
+            raise
+        self.setBytecode(bytecode)
+
+    def needsDecompilation(self):
+        return self.bytecode is not None
+
+    def setProgram(self, program):
+        self.program = program
+        self.bytecode = None
+
+    def setBytecode(self, bytecode):
+        self.bytecode = bytecode
+        self.program = None
+
+    def getToken(self, index, len=len, byteord=byteord, isinstance=isinstance):
+        if self.bytecode is not None:
+            if index >= len(self.bytecode):
+                return None, 0, 0
+            b0 = byteord(self.bytecode[index])
+            index = index + 1
+            handler = self.operandEncoding[b0]
+            token, index = handler(self, b0, self.bytecode, index)
+        else:
+            if index >= len(self.program):
+                return None, 0, 0
+            token = self.program[index]
+            index = index + 1
+        isOperator = isinstance(token, str)
+        return token, isOperator, index
+
+    def getBytes(self, index, nBytes):
+        if self.bytecode is not None:
+            newIndex = index + nBytes
+            bytes = self.bytecode[index:newIndex]
+            index = newIndex
+        else:
+            bytes = self.program[index]
+            index = index + 1
+        assert len(bytes) == nBytes
+        return bytes, index
+
+    def handle_operator(self, operator):
+        return operator
+
+    def toXML(self, xmlWriter, ttFont=None):
+        from fontTools.misc.textTools import num2binary
+
+        if self.bytecode is not None:
+            xmlWriter.dumphex(self.bytecode)
+        else:
+            index = 0
+            args = []
+            while True:
+                token, isOperator, index = self.getToken(index)
+                if token is None:
+                    break
+                if isOperator:
+                    if token in ("hintmask", "cntrmask"):
+                        hintMask, isOperator, index = self.getToken(index)
+                        bits = []
+                        for byte in hintMask:
+                            bits.append(num2binary(byteord(byte), 8))
+                        hintMask = strjoin(bits)
+                        line = " ".join(args + [token, hintMask])
+                    else:
+                        line = " ".join(args + [token])
+                    xmlWriter.write(line)
+                    xmlWriter.newline()
+                    args = []
+                else:
+                    if isinstance(token, float):
+                        token = floatToFixedToStr(token, precisionBits=16)
+                    else:
+                        token = str(token)
+                    args.append(token)
+            if args:
+                # NOTE: only CFF2 charstrings/subrs can have numeric arguments on
+                # the stack after the last operator. Compiling this would fail if
+                # this is part of CFF 1.0 table.
+                line = " ".join(args)
+                xmlWriter.write(line)
+
+    def fromXML(self, name, attrs, content):
+        from fontTools.misc.textTools import binary2num, readHex
+
+        if attrs.get("raw"):
+            self.setBytecode(readHex(content))
+            return
+        content = strjoin(content)
+        content = content.split()
+        program = []
+        end = len(content)
+        i = 0
+        while i < end:
+            token = content[i]
+            i = i + 1
+            try:
+                token = int(token)
+            except ValueError:
+                try:
+                    token = strToFixedToFloat(token, precisionBits=16)
+                except ValueError:
+                    program.append(token)
+                    if token in ("hintmask", "cntrmask"):
+                        mask = content[i]
+                        maskBytes = b""
+                        for j in range(0, len(mask), 8):
+                            maskBytes = maskBytes + bytechr(binary2num(mask[j : j + 8]))
+                        program.append(maskBytes)
+                        i = i + 1
+                else:
+                    program.append(token)
+            else:
+                program.append(token)
+        self.setProgram(program)
+
+
+class T1CharString(T2CharString):
+    operandEncoding = t1OperandEncoding
+    operators, opcodes = buildOperatorDict(t1Operators)
+
+    def __init__(self, bytecode=None, program=None, subrs=None):
+        super().__init__(bytecode, program)
+        self.subrs = subrs
+
+    def getIntEncoder(self):
+        return encodeIntT1
+
+    def getFixedEncoder(self):
+        def encodeFixed(value):
+            raise TypeError("Type 1 charstrings don't support floating point operands")
+
+    def decompile(self):
+        if self.bytecode is None:
+            return
+        program = []
+        index = 0
+        while True:
+            token, isOperator, index = self.getToken(index)
+            if token is None:
+                break
+            program.append(token)
+        self.setProgram(program)
+
+    def draw(self, pen):
+        extractor = T1OutlineExtractor(pen, self.subrs)
+        extractor.execute(self)
+        self.width = extractor.width
+
+
+class DictDecompiler(object):
+    operandEncoding = cffDictOperandEncoding
+
+    def __init__(self, strings, parent=None):
+        self.stack = []
+        self.strings = strings
+        self.dict = {}
+        self.parent = parent
+
+    def getDict(self):
+        assert len(self.stack) == 0, "non-empty stack"
+        return self.dict
+
+    def decompile(self, data):
+        index = 0
+        lenData = len(data)
+        push = self.stack.append
+        while index < lenData:
+            b0 = byteord(data[index])
+            index = index + 1
+            handler = self.operandEncoding[b0]
+            value, index = handler(self, b0, data, index)
+            if value is not None:
+                push(value)
+
+    def pop(self):
+        value = self.stack[-1]
+        del self.stack[-1]
+        return value
+
+    def popall(self):
+        args = self.stack[:]
+        del self.stack[:]
+        return args
+
+    def handle_operator(self, operator):
+        operator, argType = operator
+        if isinstance(argType, tuple):
+            value = ()
+            for i in range(len(argType) - 1, -1, -1):
+                arg = argType[i]
+                arghandler = getattr(self, "arg_" + arg)
+                value = (arghandler(operator),) + value
+        else:
+            arghandler = getattr(self, "arg_" + argType)
+            value = arghandler(operator)
+        if operator == "blend":
+            self.stack.extend(value)
+        else:
+            self.dict[operator] = value
+
+    def arg_number(self, name):
+        if isinstance(self.stack[0], list):
+            out = self.arg_blend_number(self.stack)
+        else:
+            out = self.pop()
+        return out
+
+    def arg_blend_number(self, name):
+        out = []
+        blendArgs = self.pop()
+        numMasters = len(blendArgs)
+        out.append(blendArgs)
+        out.append("blend")
+        dummy = self.popall()
+        return blendArgs
+
+    def arg_SID(self, name):
+        return self.strings[self.pop()]
+
+    def arg_array(self, name):
+        return self.popall()
+
+    def arg_blendList(self, name):
+        """
+        There may be non-blend args at the top of the stack. We first calculate
+        where the blend args start in the stack. These are the last
+        numMasters*numBlends) +1 args.
+        The blend args starts with numMasters relative coordinate values, the  BlueValues in the list from the default master font. This is followed by
+        numBlends list of values. Each of  value in one of these lists is the
+        Variable Font delta for the matching region.
+
+        We re-arrange this to be a list of numMaster entries. Each entry starts with the corresponding default font relative value, and is followed by
+        the delta values. We then convert the default values, the first item in each entry, to an absolute value.
+        """
+        vsindex = self.dict.get("vsindex", 0)
+        numMasters = (
+            self.parent.getNumRegions(vsindex) + 1
+        )  # only a PrivateDict has blended ops.
+        numBlends = self.pop()
+        args = self.popall()
+        numArgs = len(args)
+        # The spec says that there should be no non-blended Blue Values,.
+        assert numArgs == numMasters * numBlends
+        value = [None] * numBlends
+        numDeltas = numMasters - 1
+        i = 0
+        prevVal = 0
+        while i < numBlends:
+            newVal = args[i] + prevVal
+            prevVal = newVal
+            masterOffset = numBlends + (i * numDeltas)
+            blendList = [newVal] + args[masterOffset : masterOffset + numDeltas]
+            value[i] = blendList
+            i += 1
+        return value
+
+    def arg_delta(self, name):
+        valueList = self.popall()
+        out = []
+        if valueList and isinstance(valueList[0], list):
+            # arg_blendList() has already converted these to absolute values.
+            out = valueList
+        else:
+            current = 0
+            for v in valueList:
+                current = current + v
+                out.append(current)
+        return out
+
+
+def calcSubrBias(subrs):
+    nSubrs = len(subrs)
+    if nSubrs < 1240:
+        bias = 107
+    elif nSubrs < 33900:
+        bias = 1131
+    else:
+        bias = 32768
+    return bias

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

@@ -0,0 +1,398 @@
+from fontTools.misc.textTools import bytechr, byteord, bytesjoin, tobytes, tostr
+from fontTools.misc import eexec
+from .psOperators import (
+    PSOperators,
+    ps_StandardEncoding,
+    ps_array,
+    ps_boolean,
+    ps_dict,
+    ps_integer,
+    ps_literal,
+    ps_mark,
+    ps_name,
+    ps_operator,
+    ps_procedure,
+    ps_procmark,
+    ps_real,
+    ps_string,
+)
+import re
+from collections.abc import Callable
+from string import whitespace
+import logging
+
+
+log = logging.getLogger(__name__)
+
+ps_special = b"()<>[]{}%"  # / is one too, but we take care of that one differently
+
+skipwhiteRE = re.compile(bytesjoin([b"[", whitespace, b"]*"]))
+endofthingPat = bytesjoin([b"[^][(){}<>/%", whitespace, b"]*"])
+endofthingRE = re.compile(endofthingPat)
+commentRE = re.compile(b"%[^\n\r]*")
+
+# XXX This not entirely correct as it doesn't allow *nested* embedded parens:
+stringPat = rb"""
+	\(
+		(
+			(
+				[^()]*   \   [()]
+			)
+			|
+			(
+				[^()]*  \(   [^()]*  \)
+			)
+		)*
+		[^()]*
+	\)
+"""
+stringPat = b"".join(stringPat.split())
+stringRE = re.compile(stringPat)
+
+hexstringRE = re.compile(bytesjoin([b"<[", whitespace, b"0-9A-Fa-f]*>"]))
+
+
+class PSTokenError(Exception):
+    pass
+
+
+class PSError(Exception):
+    pass
+
+
+class PSTokenizer(object):
+    def __init__(self, buf=b"", encoding="ascii"):
+        # Force self.buf to be a byte string
+        buf = tobytes(buf)
+        self.buf = buf
+        self.len = len(buf)
+        self.pos = 0
+        self.closed = False
+        self.encoding = encoding
+
+    def read(self, n=-1):
+        """Read at most 'n' bytes from the buffer, or less if the read
+        hits EOF before obtaining 'n' bytes.
+        If 'n' is negative or omitted, read all data until EOF is reached.
+        """
+        if self.closed:
+            raise ValueError("I/O operation on closed file")
+        if n is None or n < 0:
+            newpos = self.len
+        else:
+            newpos = min(self.pos + n, self.len)
+        r = self.buf[self.pos : newpos]
+        self.pos = newpos
+        return r
+
+    def close(self):
+        if not self.closed:
+            self.closed = True
+            del self.buf, self.pos
+
+    def getnexttoken(
+        self,
+        # localize some stuff, for performance
+        len=len,
+        ps_special=ps_special,
+        stringmatch=stringRE.match,
+        hexstringmatch=hexstringRE.match,
+        commentmatch=commentRE.match,
+        endmatch=endofthingRE.match,
+    ):
+        self.skipwhite()
+        if self.pos >= self.len:
+            return None, None
+        pos = self.pos
+        buf = self.buf
+        char = bytechr(byteord(buf[pos]))
+        if char in ps_special:
+            if char in b"{}[]":
+                tokentype = "do_special"
+                token = char
+            elif char == b"%":
+                tokentype = "do_comment"
+                _, nextpos = commentmatch(buf, pos).span()
+                token = buf[pos:nextpos]
+            elif char == b"(":
+                tokentype = "do_string"
+                m = stringmatch(buf, pos)
+                if m is None:
+                    raise PSTokenError("bad string at character %d" % pos)
+                _, nextpos = m.span()
+                token = buf[pos:nextpos]
+            elif char == b"<":
+                tokentype = "do_hexstring"
+                m = hexstringmatch(buf, pos)
+                if m is None:
+                    raise PSTokenError("bad hexstring at character %d" % pos)
+                _, nextpos = m.span()
+                token = buf[pos:nextpos]
+            else:
+                raise PSTokenError("bad token at character %d" % pos)
+        else:
+            if char == b"/":
+                tokentype = "do_literal"
+                m = endmatch(buf, pos + 1)
+            else:
+                tokentype = ""
+                m = endmatch(buf, pos)
+            if m is None:
+                raise PSTokenError("bad token at character %d" % pos)
+            _, nextpos = m.span()
+            token = buf[pos:nextpos]
+        self.pos = pos + len(token)
+        token = tostr(token, encoding=self.encoding)
+        return tokentype, token
+
+    def skipwhite(self, whitematch=skipwhiteRE.match):
+        _, nextpos = whitematch(self.buf, self.pos).span()
+        self.pos = nextpos
+
+    def starteexec(self):
+        self.pos = self.pos + 1
+        self.dirtybuf = self.buf[self.pos :]
+        self.buf, R = eexec.decrypt(self.dirtybuf, 55665)
+        self.len = len(self.buf)
+        self.pos = 4
+
+    def stopeexec(self):
+        if not hasattr(self, "dirtybuf"):
+            return
+        self.buf = self.dirtybuf
+        del self.dirtybuf
+
+
+class PSInterpreter(PSOperators):
+    def __init__(self, encoding="ascii"):
+        systemdict = {}
+        userdict = {}
+        self.encoding = encoding
+        self.dictstack = [systemdict, userdict]
+        self.stack = []
+        self.proclevel = 0
+        self.procmark = ps_procmark()
+        self.fillsystemdict()
+
+    def fillsystemdict(self):
+        systemdict = self.dictstack[0]
+        systemdict["["] = systemdict["mark"] = self.mark = ps_mark()
+        systemdict["]"] = ps_operator("]", self.do_makearray)
+        systemdict["true"] = ps_boolean(1)
+        systemdict["false"] = ps_boolean(0)
+        systemdict["StandardEncoding"] = ps_array(ps_StandardEncoding)
+        systemdict["FontDirectory"] = ps_dict({})
+        self.suckoperators(systemdict, self.__class__)
+
+    def suckoperators(self, systemdict, klass):
+        for name in dir(klass):
+            attr = getattr(self, name)
+            if isinstance(attr, Callable) and name[:3] == "ps_":
+                name = name[3:]
+                systemdict[name] = ps_operator(name, attr)
+        for baseclass in klass.__bases__:
+            self.suckoperators(systemdict, baseclass)
+
+    def interpret(self, data, getattr=getattr):
+        tokenizer = self.tokenizer = PSTokenizer(data, self.encoding)
+        getnexttoken = tokenizer.getnexttoken
+        do_token = self.do_token
+        handle_object = self.handle_object
+        try:
+            while 1:
+                tokentype, token = getnexttoken()
+                if not token:
+                    break
+                if tokentype:
+                    handler = getattr(self, tokentype)
+                    object = handler(token)
+                else:
+                    object = do_token(token)
+                if object is not None:
+                    handle_object(object)
+            tokenizer.close()
+            self.tokenizer = None
+        except:
+            if self.tokenizer is not None:
+                log.debug(
+                    "ps error:\n"
+                    "- - - - - - -\n"
+                    "%s\n"
+                    ">>>\n"
+                    "%s\n"
+                    "- - - - - - -",
+                    self.tokenizer.buf[self.tokenizer.pos - 50 : self.tokenizer.pos],
+                    self.tokenizer.buf[self.tokenizer.pos : self.tokenizer.pos + 50],
+                )
+            raise
+
+    def handle_object(self, object):
+        if not (self.proclevel or object.literal or object.type == "proceduretype"):
+            if object.type != "operatortype":
+                object = self.resolve_name(object.value)
+            if object.literal:
+                self.push(object)
+            else:
+                if object.type == "proceduretype":
+                    self.call_procedure(object)
+                else:
+                    object.function()
+        else:
+            self.push(object)
+
+    def call_procedure(self, proc):
+        handle_object = self.handle_object
+        for item in proc.value:
+            handle_object(item)
+
+    def resolve_name(self, name):
+        dictstack = self.dictstack
+        for i in range(len(dictstack) - 1, -1, -1):
+            if name in dictstack[i]:
+                return dictstack[i][name]
+        raise PSError("name error: " + str(name))
+
+    def do_token(
+        self,
+        token,
+        int=int,
+        float=float,
+        ps_name=ps_name,
+        ps_integer=ps_integer,
+        ps_real=ps_real,
+    ):
+        try:
+            num = int(token)
+        except (ValueError, OverflowError):
+            try:
+                num = float(token)
+            except (ValueError, OverflowError):
+                if "#" in token:
+                    hashpos = token.find("#")
+                    try:
+                        base = int(token[:hashpos])
+                        num = int(token[hashpos + 1 :], base)
+                    except (ValueError, OverflowError):
+                        return ps_name(token)
+                    else:
+                        return ps_integer(num)
+                else:
+                    return ps_name(token)
+            else:
+                return ps_real(num)
+        else:
+            return ps_integer(num)
+
+    def do_comment(self, token):
+        pass
+
+    def do_literal(self, token):
+        return ps_literal(token[1:])
+
+    def do_string(self, token):
+        return ps_string(token[1:-1])
+
+    def do_hexstring(self, token):
+        hexStr = "".join(token[1:-1].split())
+        if len(hexStr) % 2:
+            hexStr = hexStr + "0"
+        cleanstr = []
+        for i in range(0, len(hexStr), 2):
+            cleanstr.append(chr(int(hexStr[i : i + 2], 16)))
+        cleanstr = "".join(cleanstr)
+        return ps_string(cleanstr)
+
+    def do_special(self, token):
+        if token == "{":
+            self.proclevel = self.proclevel + 1
+            return self.procmark
+        elif token == "}":
+            proc = []
+            while 1:
+                topobject = self.pop()
+                if topobject == self.procmark:
+                    break
+                proc.append(topobject)
+            self.proclevel = self.proclevel - 1
+            proc.reverse()
+            return ps_procedure(proc)
+        elif token == "[":
+            return self.mark
+        elif token == "]":
+            return ps_name("]")
+        else:
+            raise PSTokenError("huh?")
+
+    def push(self, object):
+        self.stack.append(object)
+
+    def pop(self, *types):
+        stack = self.stack
+        if not stack:
+            raise PSError("stack underflow")
+        object = stack[-1]
+        if types:
+            if object.type not in types:
+                raise PSError(
+                    "typecheck, expected %s, found %s" % (repr(types), object.type)
+                )
+        del stack[-1]
+        return object
+
+    def do_makearray(self):
+        array = []
+        while 1:
+            topobject = self.pop()
+            if topobject == self.mark:
+                break
+            array.append(topobject)
+        array.reverse()
+        self.push(ps_array(array))
+
+    def close(self):
+        """Remove circular references."""
+        del self.stack
+        del self.dictstack
+
+
+def unpack_item(item):
+    tp = type(item.value)
+    if tp == dict:
+        newitem = {}
+        for key, value in item.value.items():
+            newitem[key] = unpack_item(value)
+    elif tp == list:
+        newitem = [None] * len(item.value)
+        for i in range(len(item.value)):
+            newitem[i] = unpack_item(item.value[i])
+        if item.type == "proceduretype":
+            newitem = tuple(newitem)
+    else:
+        newitem = item.value
+    return newitem
+
+
+def suckfont(data, encoding="ascii"):
+    m = re.search(rb"/FontName\s+/([^ \t\n\r]+)\s+def", data)
+    if m:
+        fontName = m.group(1)
+        fontName = fontName.decode()
+    else:
+        fontName = None
+    interpreter = PSInterpreter(encoding=encoding)
+    interpreter.interpret(
+        b"/Helvetica 4 dict dup /Encoding StandardEncoding put definefont pop"
+    )
+    interpreter.interpret(data)
+    fontdir = interpreter.dictstack[0]["FontDirectory"].value
+    if fontName in fontdir:
+        rawfont = fontdir[fontName]
+    else:
+        # fall back, in case fontName wasn't found
+        fontNames = list(fontdir.keys())
+        if len(fontNames) > 1:
+            fontNames.remove("Helvetica")
+        fontNames.sort()
+        rawfont = fontdir[fontNames[0]]
+    interpreter.close()
+    return unpack_item(rawfont)

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

@@ -0,0 +1,96 @@
+"""Python 2/3 compat layer leftovers."""
+
+import decimal as _decimal
+import math as _math
+import warnings
+from contextlib import redirect_stderr, redirect_stdout
+from io import BytesIO
+from io import StringIO as UnicodeIO
+from types import SimpleNamespace
+
+from .textTools import Tag, bytechr, byteord, bytesjoin, strjoin, tobytes, tostr
+
+warnings.warn(
+    "The py23 module has been deprecated and will be removed in a future release. "
+    "Please update your code.",
+    DeprecationWarning,
+)
+
+__all__ = [
+    "basestring",
+    "bytechr",
+    "byteord",
+    "BytesIO",
+    "bytesjoin",
+    "open",
+    "Py23Error",
+    "range",
+    "RecursionError",
+    "round",
+    "SimpleNamespace",
+    "StringIO",
+    "strjoin",
+    "Tag",
+    "tobytes",
+    "tostr",
+    "tounicode",
+    "unichr",
+    "unicode",
+    "UnicodeIO",
+    "xrange",
+    "zip",
+]
+
+
+class Py23Error(NotImplementedError):
+    pass
+
+
+RecursionError = RecursionError
+StringIO = UnicodeIO
+
+basestring = str
+isclose = _math.isclose
+isfinite = _math.isfinite
+open = open
+range = range
+round = round3 = round
+unichr = chr
+unicode = str
+zip = zip
+
+tounicode = tostr
+
+
+def xrange(*args, **kwargs):
+    raise Py23Error("'xrange' is not defined. Use 'range' instead.")
+
+
+def round2(number, ndigits=None):
+    """
+    Implementation of Python 2 built-in round() function.
+    Rounds a number to a given precision in decimal digits (default
+    0 digits). The result is a floating point number. Values are rounded
+    to the closest multiple of 10 to the power minus ndigits; if two
+    multiples are equally close, rounding is done away from 0.
+    ndigits may be negative.
+    See Python 2 documentation:
+    https://docs.python.org/2/library/functions.html?highlight=round#round
+    """
+    if ndigits is None:
+        ndigits = 0
+
+    if ndigits < 0:
+        exponent = 10 ** (-ndigits)
+        quotient, remainder = divmod(number, exponent)
+        if remainder >= exponent // 2 and number >= 0:
+            quotient += 1
+        return float(quotient * exponent)
+    else:
+        exponent = _decimal.Decimal("10") ** (-ndigits)
+
+        d = _decimal.Decimal.from_float(number).quantize(
+            exponent, rounding=_decimal.ROUND_HALF_UP
+        )
+
+        return float(d)

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

@@ -0,0 +1,110 @@
+"""
+Various round-to-integer helpers.
+"""
+
+import math
+import functools
+import logging
+
+log = logging.getLogger(__name__)
+
+__all__ = [
+    "noRound",
+    "otRound",
+    "maybeRound",
+    "roundFunc",
+    "nearestMultipleShortestRepr",
+]
+
+
+def noRound(value):
+    return value
+
+
+def otRound(value):
+    """Round float value to nearest integer towards ``+Infinity``.
+
+    The OpenType spec (in the section on `"normalization" of OpenType Font Variations <https://docs.microsoft.com/en-us/typography/opentype/spec/otvaroverview#coordinate-scales-and-normalization>`_)
+    defines the required method for converting floating point values to
+    fixed-point. In particular it specifies the following rounding strategy:
+
+            for fractional values of 0.5 and higher, take the next higher integer;
+            for other fractional values, truncate.
+
+    This function rounds the floating-point value according to this strategy
+    in preparation for conversion to fixed-point.
+
+    Args:
+            value (float): The input floating-point value.
+
+    Returns
+            float: The rounded value.
+    """
+    # See this thread for how we ended up with this implementation:
+    # https://github.com/fonttools/fonttools/issues/1248#issuecomment-383198166
+    return int(math.floor(value + 0.5))
+
+
+def maybeRound(v, tolerance, round=otRound):
+    rounded = round(v)
+    return rounded if abs(rounded - v) <= tolerance else v
+
+
+def roundFunc(tolerance, round=otRound):
+    if tolerance < 0:
+        raise ValueError("Rounding tolerance must be positive")
+
+    if tolerance == 0:
+        return noRound
+
+    if tolerance >= 0.5:
+        return round
+
+    return functools.partial(maybeRound, tolerance=tolerance, round=round)
+
+
+def nearestMultipleShortestRepr(value: float, factor: float) -> str:
+    """Round to nearest multiple of factor and return shortest decimal representation.
+
+    This chooses the float that is closer to a multiple of the given factor while
+    having the shortest decimal representation (the least number of fractional decimal
+    digits).
+
+    For example, given the following:
+
+    >>> nearestMultipleShortestRepr(-0.61883544921875, 1.0/(1<<14))
+    '-0.61884'
+
+    Useful when you need to serialize or print a fixed-point number (or multiples
+    thereof, such as F2Dot14 fractions of 180 degrees in COLRv1 PaintRotate) in
+    a human-readable form.
+
+    Args:
+        value (value): The value to be rounded and serialized.
+        factor (float): The value which the result is a close multiple of.
+
+    Returns:
+        str: A compact string representation of the value.
+    """
+    if not value:
+        return "0.0"
+
+    value = otRound(value / factor) * factor
+    eps = 0.5 * factor
+    lo = value - eps
+    hi = value + eps
+    # If the range of valid choices spans an integer, return the integer.
+    if int(lo) != int(hi):
+        return str(float(round(value)))
+
+    fmt = "%.8f"
+    lo = fmt % lo
+    hi = fmt % hi
+    assert len(lo) == len(hi) and lo != hi
+    for i in range(len(lo)):
+        if lo[i] != hi[i]:
+            break
+    period = lo.find(".")
+    assert period < i
+    fmt = "%%.%df" % (i - period)
+    return fmt % value

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

@@ -0,0 +1,247 @@
+from fontTools.pens.basePen import BasePen
+from functools import partial
+from itertools import count
+import sympy as sp
+import sys
+
+n = 3  # Max Bezier degree; 3 for cubic, 2 for quadratic
+
+t, x, y = sp.symbols("t x y", real=True)
+c = sp.symbols("c", real=False)  # Complex representation instead of x/y
+
+X = tuple(sp.symbols("x:%d" % (n + 1), real=True))
+Y = tuple(sp.symbols("y:%d" % (n + 1), real=True))
+P = tuple(zip(*(sp.symbols("p:%d[%s]" % (n + 1, w), real=True) for w in "01")))
+C = tuple(sp.symbols("c:%d" % (n + 1), real=False))
+
+# Cubic Bernstein basis functions
+BinomialCoefficient = [(1, 0)]
+for i in range(1, n + 1):
+    last = BinomialCoefficient[-1]
+    this = tuple(last[j - 1] + last[j] for j in range(len(last))) + (0,)
+    BinomialCoefficient.append(this)
+BinomialCoefficient = tuple(tuple(item[:-1]) for item in BinomialCoefficient)
+del last, this
+
+BernsteinPolynomial = tuple(
+    tuple(c * t**i * (1 - t) ** (n - i) for i, c in enumerate(coeffs))
+    for n, coeffs in enumerate(BinomialCoefficient)
+)
+
+BezierCurve = tuple(
+    tuple(
+        sum(P[i][j] * bernstein for i, bernstein in enumerate(bernsteins))
+        for j in range(2)
+    )
+    for n, bernsteins in enumerate(BernsteinPolynomial)
+)
+BezierCurveC = tuple(
+    sum(C[i] * bernstein for i, bernstein in enumerate(bernsteins))
+    for n, bernsteins in enumerate(BernsteinPolynomial)
+)
+
+
+def green(f, curveXY):
+    f = -sp.integrate(sp.sympify(f), y)
+    f = f.subs({x: curveXY[0], y: curveXY[1]})
+    f = sp.integrate(f * sp.diff(curveXY[0], t), (t, 0, 1))
+    return f
+
+
+class _BezierFuncsLazy(dict):
+    def __init__(self, symfunc):
+        self._symfunc = symfunc
+        self._bezfuncs = {}
+
+    def __missing__(self, i):
+        args = ["p%d" % d for d in range(i + 1)]
+        f = green(self._symfunc, BezierCurve[i])
+        f = sp.gcd_terms(f.collect(sum(P, ())))  # Optimize
+        return sp.lambdify(args, f)
+
+
+class GreenPen(BasePen):
+    _BezierFuncs = {}
+
+    @classmethod
+    def _getGreenBezierFuncs(celf, func):
+        funcstr = str(func)
+        if not funcstr in celf._BezierFuncs:
+            celf._BezierFuncs[funcstr] = _BezierFuncsLazy(func)
+        return celf._BezierFuncs[funcstr]
+
+    def __init__(self, func, glyphset=None):
+        BasePen.__init__(self, glyphset)
+        self._funcs = self._getGreenBezierFuncs(func)
+        self.value = 0
+
+    def _moveTo(self, p0):
+        self._startPoint = p0
+
+    def _closePath(self):
+        p0 = self._getCurrentPoint()
+        if p0 != self._startPoint:
+            self._lineTo(self._startPoint)
+
+    def _endPath(self):
+        p0 = self._getCurrentPoint()
+        if p0 != self._startPoint:
+            # Green theorem is not defined on open contours.
+            raise NotImplementedError
+
+    def _lineTo(self, p1):
+        p0 = self._getCurrentPoint()
+        self.value += self._funcs[1](p0, p1)
+
+    def _qCurveToOne(self, p1, p2):
+        p0 = self._getCurrentPoint()
+        self.value += self._funcs[2](p0, p1, p2)
+
+    def _curveToOne(self, p1, p2, p3):
+        p0 = self._getCurrentPoint()
+        self.value += self._funcs[3](p0, p1, p2, p3)
+
+
+# Sample pens.
+# Do not use this in real code.
+# Use fontTools.pens.momentsPen.MomentsPen instead.
+AreaPen = partial(GreenPen, func=1)
+MomentXPen = partial(GreenPen, func=x)
+MomentYPen = partial(GreenPen, func=y)
+MomentXXPen = partial(GreenPen, func=x * x)
+MomentYYPen = partial(GreenPen, func=y * y)
+MomentXYPen = partial(GreenPen, func=x * y)
+
+
+def printGreenPen(penName, funcs, file=sys.stdout, docstring=None):
+    if docstring is not None:
+        print('"""%s"""' % docstring)
+
+    print(
+        """from fontTools.pens.basePen import BasePen, OpenContourError
+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
+
+
+__all__ = ["%s"]
+
+class %s(BasePen):
+
+	def __init__(self, glyphset=None):
+		BasePen.__init__(self, glyphset)
+"""
+        % (penName, penName),
+        file=file,
+    )
+    for name, f in funcs:
+        print("		self.%s = 0" % name, file=file)
+    print(
+        """
+	def _moveTo(self, p0):
+		self._startPoint = p0
+
+	def _closePath(self):
+		p0 = self._getCurrentPoint()
+		if p0 != self._startPoint:
+			self._lineTo(self._startPoint)
+
+	def _endPath(self):
+		p0 = self._getCurrentPoint()
+		if p0 != self._startPoint:
+			raise OpenContourError(
+							"Glyph statistics is not defined on open contours."
+			)
+""",
+        end="",
+        file=file,
+    )
+
+    for n in (1, 2, 3):
+        subs = {P[i][j]: [X, Y][j][i] for i in range(n + 1) for j in range(2)}
+        greens = [green(f, BezierCurve[n]) for name, f in funcs]
+        greens = [sp.gcd_terms(f.collect(sum(P, ()))) for f in greens]  # Optimize
+        greens = [f.subs(subs) for f in greens]  # Convert to p to x/y
+        defs, exprs = sp.cse(
+            greens,
+            optimizations="basic",
+            symbols=(sp.Symbol("r%d" % i) for i in count()),
+        )
+
+        print()
+        for name, value in defs:
+            print("	@cython.locals(%s=cython.double)" % name, file=file)
+        if n == 1:
+            print(
+                """\
+	@cython.locals(x0=cython.double, y0=cython.double)
+	@cython.locals(x1=cython.double, y1=cython.double)
+	def _lineTo(self, p1):
+		x0,y0 = self._getCurrentPoint()
+		x1,y1 = p1
+""",
+                file=file,
+            )
+        elif n == 2:
+            print(
+                """\
+	@cython.locals(x0=cython.double, y0=cython.double)
+	@cython.locals(x1=cython.double, y1=cython.double)
+	@cython.locals(x2=cython.double, y2=cython.double)
+	def _qCurveToOne(self, p1, p2):
+		x0,y0 = self._getCurrentPoint()
+		x1,y1 = p1
+		x2,y2 = p2
+""",
+                file=file,
+            )
+        elif n == 3:
+            print(
+                """\
+	@cython.locals(x0=cython.double, y0=cython.double)
+	@cython.locals(x1=cython.double, y1=cython.double)
+	@cython.locals(x2=cython.double, y2=cython.double)
+	@cython.locals(x3=cython.double, y3=cython.double)
+	def _curveToOne(self, p1, p2, p3):
+		x0,y0 = self._getCurrentPoint()
+		x1,y1 = p1
+		x2,y2 = p2
+		x3,y3 = p3
+""",
+                file=file,
+            )
+        for name, value in defs:
+            print("		%s = %s" % (name, value), file=file)
+
+        print(file=file)
+        for name, value in zip([f[0] for f in funcs], exprs):
+            print("		self.%s += %s" % (name, value), file=file)
+
+    print(
+        """
+if __name__ == '__main__':
+	from fontTools.misc.symfont import x, y, printGreenPen
+	printGreenPen('%s', ["""
+        % penName,
+        file=file,
+    )
+    for name, f in funcs:
+        print("		      ('%s', %s)," % (name, str(f)), file=file)
+    print("		     ])", file=file)
+
+
+if __name__ == "__main__":
+    pen = AreaPen()
+    pen.moveTo((100, 100))
+    pen.lineTo((100, 200))
+    pen.lineTo((200, 200))
+    pen.curveTo((200, 250), (300, 300), (250, 350))
+    pen.lineTo((200, 100))
+    pen.closePath()
+    print(pen.value)

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

@@ -0,0 +1,154 @@
+"""fontTools.misc.textTools.py -- miscellaneous routines."""
+
+import ast
+import string
+
+
+# alias kept for backward compatibility
+safeEval = ast.literal_eval
+
+
+class Tag(str):
+    @staticmethod
+    def transcode(blob):
+        if isinstance(blob, bytes):
+            blob = blob.decode("latin-1")
+        return blob
+
+    def __new__(self, content):
+        return str.__new__(self, self.transcode(content))
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __eq__(self, other):
+        return str.__eq__(self, self.transcode(other))
+
+    def __hash__(self):
+        return str.__hash__(self)
+
+    def tobytes(self):
+        return self.encode("latin-1")
+
+
+def readHex(content):
+    """Convert a list of hex strings to binary data."""
+    return deHexStr(strjoin(chunk for chunk in content if isinstance(chunk, str)))
+
+
+def deHexStr(hexdata):
+    """Convert a hex string to binary data."""
+    hexdata = strjoin(hexdata.split())
+    if len(hexdata) % 2:
+        hexdata = hexdata + "0"
+    data = []
+    for i in range(0, len(hexdata), 2):
+        data.append(bytechr(int(hexdata[i : i + 2], 16)))
+    return bytesjoin(data)
+
+
+def hexStr(data):
+    """Convert binary data to a hex string."""
+    h = string.hexdigits
+    r = ""
+    for c in data:
+        i = byteord(c)
+        r = r + h[(i >> 4) & 0xF] + h[i & 0xF]
+    return r
+
+
+def num2binary(l, bits=32):
+    items = []
+    binary = ""
+    for i in range(bits):
+        if l & 0x1:
+            binary = "1" + binary
+        else:
+            binary = "0" + binary
+        l = l >> 1
+        if not ((i + 1) % 8):
+            items.append(binary)
+            binary = ""
+    if binary:
+        items.append(binary)
+    items.reverse()
+    assert l in (0, -1), "number doesn't fit in number of bits"
+    return " ".join(items)
+
+
+def binary2num(bin):
+    bin = strjoin(bin.split())
+    l = 0
+    for digit in bin:
+        l = l << 1
+        if digit != "0":
+            l = l | 0x1
+    return l
+
+
+def caselessSort(alist):
+    """Return a sorted copy of a list. If there are only strings
+    in the list, it will not consider case.
+    """
+
+    try:
+        return sorted(alist, key=lambda a: (a.lower(), a))
+    except TypeError:
+        return sorted(alist)
+
+
+def pad(data, size):
+    r"""Pad byte string 'data' with null bytes until its length is a
+    multiple of 'size'.
+
+    >>> len(pad(b'abcd', 4))
+    4
+    >>> len(pad(b'abcde', 2))
+    6
+    >>> len(pad(b'abcde', 4))
+    8
+    >>> pad(b'abcdef', 4) == b'abcdef\x00\x00'
+    True
+    """
+    data = tobytes(data)
+    if size > 1:
+        remainder = len(data) % size
+        if remainder:
+            data += b"\0" * (size - remainder)
+    return data
+
+
+def tostr(s, encoding="ascii", errors="strict"):
+    if not isinstance(s, str):
+        return s.decode(encoding, errors)
+    else:
+        return s
+
+
+def tobytes(s, encoding="ascii", errors="strict"):
+    if isinstance(s, str):
+        return s.encode(encoding, errors)
+    else:
+        return bytes(s)
+
+
+def bytechr(n):
+    return bytes([n])
+
+
+def byteord(c):
+    return c if isinstance(c, int) else ord(c)
+
+
+def strjoin(iterable, joiner=""):
+    return tostr(joiner).join(iterable)
+
+
+def bytesjoin(iterable, joiner=b""):
+    return tobytes(joiner).join(tobytes(item) for item in iterable)
+
+
+if __name__ == "__main__":
+    import doctest, sys
+
+    sys.exit(doctest.testmod().failed)

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

@@ -0,0 +1,88 @@
+"""fontTools.misc.timeTools.py -- tools for working with OpenType timestamps.
+"""
+
+import os
+import time
+from datetime import datetime, timezone
+import calendar
+
+
+epoch_diff = calendar.timegm((1904, 1, 1, 0, 0, 0, 0, 0, 0))
+
+DAYNAMES = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+MONTHNAMES = [
+    None,
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+]
+
+
+def asctime(t=None):
+    """
+    Convert a tuple or struct_time representing a time as returned by gmtime()
+    or localtime() to a 24-character string of the following form:
+
+    >>> asctime(time.gmtime(0))
+    'Thu Jan  1 00:00:00 1970'
+
+    If t is not provided, the current time as returned by localtime() is used.
+    Locale information is not used by asctime().
+
+    This is meant to normalise the output of the built-in time.asctime() across
+    different platforms and Python versions.
+    In Python 3.x, the day of the month is right-justified, whereas on Windows
+    Python 2.7 it is padded with zeros.
+
+    See https://github.com/fonttools/fonttools/issues/455
+    """
+    if t is None:
+        t = time.localtime()
+    s = "%s %s %2s %s" % (
+        DAYNAMES[t.tm_wday],
+        MONTHNAMES[t.tm_mon],
+        t.tm_mday,
+        time.strftime("%H:%M:%S %Y", t),
+    )
+    return s
+
+
+def timestampToString(value):
+    return asctime(time.gmtime(max(0, value + epoch_diff)))
+
+
+def timestampFromString(value):
+    wkday, mnth = value[:7].split()
+    t = datetime.strptime(value[7:], " %d %H:%M:%S %Y")
+    t = t.replace(month=MONTHNAMES.index(mnth), tzinfo=timezone.utc)
+    wkday_idx = DAYNAMES.index(wkday)
+    assert t.weekday() == wkday_idx, '"' + value + '" has inconsistent weekday'
+    return int(t.timestamp()) - epoch_diff
+
+
+def timestampNow():
+    # https://reproducible-builds.org/specs/source-date-epoch/
+    source_date_epoch = os.environ.get("SOURCE_DATE_EPOCH")
+    if source_date_epoch is not None:
+        return int(source_date_epoch) - epoch_diff
+    return int(time.time() - epoch_diff)
+
+
+def timestampSinceEpoch(value):
+    return int(value - epoch_diff)
+
+
+if __name__ == "__main__":
+    import sys
+    import doctest
+
+    sys.exit(doctest.testmod().failed)

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

@@ -0,0 +1,45 @@
+"""Generic tools for working with trees."""
+
+from math import ceil, log
+
+
+def build_n_ary_tree(leaves, n):
+    """Build N-ary tree from sequence of leaf nodes.
+
+    Return a list of lists where each non-leaf node is a list containing
+    max n nodes.
+    """
+    if not leaves:
+        return []
+
+    assert n > 1
+
+    depth = ceil(log(len(leaves), n))
+
+    if depth <= 1:
+        return list(leaves)
+
+    # Fully populate complete subtrees of root until we have enough leaves left
+    root = []
+    unassigned = None
+    full_step = n ** (depth - 1)
+    for i in range(0, len(leaves), full_step):
+        subtree = leaves[i : i + full_step]
+        if len(subtree) < full_step:
+            unassigned = subtree
+            break
+        while len(subtree) > n:
+            subtree = [subtree[k : k + n] for k in range(0, len(subtree), n)]
+        root.append(subtree)
+
+    if unassigned:
+        # Recurse to fill the last subtree, which is the only partially populated one
+        subtree = build_n_ary_tree(unassigned, n)
+        if len(subtree) <= n - len(root):
+            # replace last subtree with its children if they can still fit
+            root.extend(subtree)
+        else:
+            root.append(subtree)
+        assert len(root) <= n
+
+    return root

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

@@ -0,0 +1,147 @@
+from numbers import Number
+import math
+import operator
+import warnings
+
+
+__all__ = ["Vector"]
+
+
+class Vector(tuple):
+    """A math-like vector.
+
+    Represents an n-dimensional numeric vector. ``Vector`` objects support
+    vector addition and subtraction, scalar multiplication and division,
+    negation, rounding, and comparison tests.
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, values, keep=False):
+        if keep is not False:
+            warnings.warn(
+                "the 'keep' argument has been deprecated",
+                DeprecationWarning,
+            )
+        if type(values) == Vector:
+            # No need to create a new object
+            return values
+        return super().__new__(cls, values)
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+    def _vectorOp(self, other, op):
+        if isinstance(other, Vector):
+            assert len(self) == len(other)
+            return self.__class__(op(a, b) for a, b in zip(self, other))
+        if isinstance(other, Number):
+            return self.__class__(op(v, other) for v in self)
+        raise NotImplementedError()
+
+    def _scalarOp(self, other, op):
+        if isinstance(other, Number):
+            return self.__class__(op(v, other) for v in self)
+        raise NotImplementedError()
+
+    def _unaryOp(self, op):
+        return self.__class__(op(v) for v in self)
+
+    def __add__(self, other):
+        return self._vectorOp(other, operator.add)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self._vectorOp(other, operator.sub)
+
+    def __rsub__(self, other):
+        return self._vectorOp(other, _operator_rsub)
+
+    def __mul__(self, other):
+        return self._scalarOp(other, operator.mul)
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, other):
+        return self._scalarOp(other, operator.truediv)
+
+    def __rtruediv__(self, other):
+        return self._scalarOp(other, _operator_rtruediv)
+
+    def __pos__(self):
+        return self._unaryOp(operator.pos)
+
+    def __neg__(self):
+        return self._unaryOp(operator.neg)
+
+    def __round__(self, *, round=round):
+        return self._unaryOp(round)
+
+    def __eq__(self, other):
+        if isinstance(other, list):
+            # bw compat Vector([1, 2, 3]) == [1, 2, 3]
+            other = tuple(other)
+        return super().__eq__(other)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __bool__(self):
+        return any(self)
+
+    __nonzero__ = __bool__
+
+    def __abs__(self):
+        return math.sqrt(sum(x * x for x in self))
+
+    def length(self):
+        """Return the length of the vector. Equivalent to abs(vector)."""
+        return abs(self)
+
+    def normalized(self):
+        """Return the normalized vector of the vector."""
+        return self / abs(self)
+
+    def dot(self, other):
+        """Performs vector dot product, returning the sum of
+        ``a[0] * b[0], a[1] * b[1], ...``"""
+        assert len(self) == len(other)
+        return sum(a * b for a, b in zip(self, other))
+
+    # Deprecated methods/properties
+
+    def toInt(self):
+        warnings.warn(
+            "the 'toInt' method has been deprecated, use round(vector) instead",
+            DeprecationWarning,
+        )
+        return self.__round__()
+
+    @property
+    def values(self):
+        warnings.warn(
+            "the 'values' attribute has been deprecated, use "
+            "the vector object itself instead",
+            DeprecationWarning,
+        )
+        return list(self)
+
+    @values.setter
+    def values(self, values):
+        raise AttributeError(
+            "can't set attribute, the 'values' attribute has been deprecated",
+        )
+
+    def isclose(self, other: "Vector", **kwargs) -> bool:
+        """Return True if the vector is close to another Vector."""
+        assert len(self) == len(other)
+        return all(math.isclose(a, b, **kwargs) for a, b in zip(self, other))
+
+
+def _operator_rsub(a, b):
+    return operator.sub(b, a)
+
+
+def _operator_rtruediv(a, b):
+    return operator.truediv(b, a)