fonttools 4.55.4__cp313-cp313-musllinux_1_2_aarch64.whl → 4.61.1__cp313-cp313-musllinux_1_2_aarch64.whl

fontTools/feaLib/parser.py

@@ -887,6 +887,11 @@ class Parser(object):
 
         is_deletion = False
         if len(new) == 1 and isinstance(new[0], ast.NullGlyph):
+            if reverse:
+                raise FeatureLibError(
+                    "Reverse chaining substitutions do not support glyph deletion",
+                    location,
+                )
             new = []  # Deletion
             is_deletion = True
 
@@ -1286,6 +1291,19 @@ class Parser(object):
         n = match.group(0)[1:]
         return bytechr(int(n, 16)).decode(encoding)
 
+    def find_previous(self, statements, class_):
+        for previous in reversed(statements):
+            if isinstance(previous, self.ast.Comment):
+                continue
+            elif isinstance(previous, class_):
+                return previous
+            else:
+                # If we find something that doesn't match what we're looking
+                # for, and isn't a comment, fail
+                return None
+        # Out of statements to look at
+        return None
+
     def parse_table_BASE_(self, table):
         statements = table.statements
         while self.next_token_ != "}" or self.cur_comments_:
@@ -1306,6 +1324,19 @@ class Parser(object):
                         location=self.cur_token_location_,
                     )
                 )
+            elif self.is_cur_keyword_("HorizAxis.MinMax"):
+                base_script_list = self.find_previous(statements, ast.BaseAxis)
+                if base_script_list is None:
+                    raise FeatureLibError(
+                        "MinMax must be preceded by BaseScriptList",
+                        self.cur_token_location_,
+                    )
+                if base_script_list.vertical:
+                    raise FeatureLibError(
+                        "HorizAxis.MinMax must be preceded by HorizAxis statements",
+                        self.cur_token_location_,
+                    )
+                base_script_list.minmax.append(self.parse_base_minmax_())
             elif self.is_cur_keyword_("VertAxis.BaseTagList"):
                 vert_bases = self.parse_base_tag_list_()
             elif self.is_cur_keyword_("VertAxis.BaseScriptList"):
@@ -1318,6 +1349,19 @@ class Parser(object):
                         location=self.cur_token_location_,
                     )
                 )
+            elif self.is_cur_keyword_("VertAxis.MinMax"):
+                base_script_list = self.find_previous(statements, ast.BaseAxis)
+                if base_script_list is None:
+                    raise FeatureLibError(
+                        "MinMax must be preceded by BaseScriptList",
+                        self.cur_token_location_,
+                    )
+                if not base_script_list.vertical:
+                    raise FeatureLibError(
+                        "VertAxis.MinMax must be preceded by VertAxis statements",
+                        self.cur_token_location_,
+                    )
+                base_script_list.minmax.append(self.parse_base_minmax_())
             elif self.cur_token_ == ";":
                 continue
 
@@ -1574,7 +1618,7 @@ class Parser(object):
             "HorizAxis.BaseScriptList",
             "VertAxis.BaseScriptList",
         ), self.cur_token_
-        scripts = [(self.parse_base_script_record_(count))]
+        scripts = [self.parse_base_script_record_(count)]
         while self.next_token_ == ",":
             self.expect_symbol_(",")
             scripts.append(self.parse_base_script_record_(count))
@@ -1587,6 +1631,25 @@ class Parser(object):
         coords = [self.expect_number_() for i in range(count)]
         return script_tag, base_tag, coords
 
+    def parse_base_minmax_(self):
+        script_tag = self.expect_script_tag_()
+        language = self.expect_language_tag_()
+        min_coord = self.expect_number_()
+        self.advance_lexer_()
+        if not (self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == ","):
+            raise FeatureLibError(
+                "Expected a comma between min and max coordinates",
+                self.cur_token_location_,
+            )
+        max_coord = self.expect_number_()
+        if self.next_token_ == ",":  # feature tag...
+            raise FeatureLibError(
+                "Feature tags are not yet supported in BASE table",
+                self.cur_token_location_,
+            )
+
+        return script_tag, language, min_coord, max_coord
+
     def parse_device_(self):
         result = None
         self.expect_symbol_("<")
@@ -2004,44 +2067,6 @@ class Parser(object):
             )
         self.expect_symbol_(";")
 
-        # A multiple substitution may have a single destination, in which case
-        # it will look just like a single substitution. So if there are both
-        # multiple and single substitutions, upgrade all the single ones to
-        # multiple substitutions.
-
-        # Check if we have a mix of non-contextual singles and multiples.
-        has_single = False
-        has_multiple = False
-        for s in statements:
-            if isinstance(s, self.ast.SingleSubstStatement):
-                has_single = not any([s.prefix, s.suffix, s.forceChain])
-            elif isinstance(s, self.ast.MultipleSubstStatement):
-                has_multiple = not any([s.prefix, s.suffix, s.forceChain])
-
-        # Upgrade all single substitutions to multiple substitutions.
-        if has_single and has_multiple:
-            statements = []
-            for s in block.statements:
-                if isinstance(s, self.ast.SingleSubstStatement):
-                    glyphs = s.glyphs[0].glyphSet()
-                    replacements = s.replacements[0].glyphSet()
-                    if len(replacements) == 1:
-                        replacements *= len(glyphs)
-                    for i, glyph in enumerate(glyphs):
-                        statements.append(
-                            self.ast.MultipleSubstStatement(
-                                s.prefix,
-                                glyph,
-                                s.suffix,
-                                [replacements[i]],
-                                s.forceChain,
-                                location=s.location,
-                            )
-                        )
-                else:
-                    statements.append(s)
-            block.statements = statements
-
     def is_cur_keyword_(self, k):
         if self.cur_token_type_ is Lexer.NAME:
             if isinstance(k, type("")):  # basestring is gone in Python3
@@ -2178,7 +2203,7 @@ class Parser(object):
                 raise FeatureLibError(
                     "Expected an equals sign", self.cur_token_location_
                 )
-            value = self.expect_number_()
+            value = self.expect_integer_or_float_()
             location[axis] = value
             if self.next_token_type_ is Lexer.NAME and self.next_token_[0] == ":":
                 # Lexer has just read the value as a glyph name. We'll correct it later
@@ -2210,6 +2235,16 @@ class Parser(object):
             "Expected a floating-point number", self.cur_token_location_
         )
 
+    def expect_integer_or_float_(self):
+        if self.next_token_type_ == Lexer.FLOAT:
+            return self.expect_float_()
+        elif self.next_token_type_ is Lexer.NUMBER:
+            return self.expect_number_()
+        else:
+            raise FeatureLibError(
+                "Expected an integer or floating-point number", self.cur_token_location_
+            )
+
     def expect_decipoint_(self):
         if self.next_token_type_ == Lexer.FLOAT:
             return self.expect_float_()

fontTools/feaLib/variableScalar.py

@@ -17,7 +17,12 @@ class VariableScalar:
     def __repr__(self):
         items = []
         for location, value in self.values.items():
-            loc = ",".join(["%s=%i" % (ax, loc) for ax, loc in location])
+            loc = ",".join(
+                [
+                    f"{ax}={int(coord) if float(coord).is_integer() else coord}"
+                    for ax, coord in location
+                ]
+            )
             items.append("%s:%i" % (loc, value))
         return "(" + (" ".join(items)) + ")"
 

fontTools/fontBuilder.py

@@ -264,49 +264,49 @@ _nameIDs = dict(
 # to insert in setupNameTable doc string:
 # print("\n".join(("%s (nameID %s)" % (k, v)) for k, v in sorted(_nameIDs.items(), key=lambda x: x[1])))
 
-_panoseDefaults = Panose()
-
-_OS2Defaults = dict(
-    version=3,
-    xAvgCharWidth=0,
-    usWeightClass=400,
-    usWidthClass=5,
-    fsType=0x0004,  # default: Preview & Print embedding
-    ySubscriptXSize=0,
-    ySubscriptYSize=0,
-    ySubscriptXOffset=0,
-    ySubscriptYOffset=0,
-    ySuperscriptXSize=0,
-    ySuperscriptYSize=0,
-    ySuperscriptXOffset=0,
-    ySuperscriptYOffset=0,
-    yStrikeoutSize=0,
-    yStrikeoutPosition=0,
-    sFamilyClass=0,
-    panose=_panoseDefaults,
-    ulUnicodeRange1=0,
-    ulUnicodeRange2=0,
-    ulUnicodeRange3=0,
-    ulUnicodeRange4=0,
-    achVendID="????",
-    fsSelection=0,
-    usFirstCharIndex=0,
-    usLastCharIndex=0,
-    sTypoAscender=0,
-    sTypoDescender=0,
-    sTypoLineGap=0,
-    usWinAscent=0,
-    usWinDescent=0,
-    ulCodePageRange1=0,
-    ulCodePageRange2=0,
-    sxHeight=0,
-    sCapHeight=0,
-    usDefaultChar=0,  # .notdef
-    usBreakChar=32,  # space
-    usMaxContext=0,
-    usLowerOpticalPointSize=0,
-    usUpperOpticalPointSize=0,
-)
+
+def _getOS2Defaults():
+    return dict(
+        version=3,
+        xAvgCharWidth=0,
+        usWeightClass=400,
+        usWidthClass=5,
+        fsType=0x0004,  # default: Preview & Print embedding
+        ySubscriptXSize=0,
+        ySubscriptYSize=0,
+        ySubscriptXOffset=0,
+        ySubscriptYOffset=0,
+        ySuperscriptXSize=0,
+        ySuperscriptYSize=0,
+        ySuperscriptXOffset=0,
+        ySuperscriptYOffset=0,
+        yStrikeoutSize=0,
+        yStrikeoutPosition=0,
+        sFamilyClass=0,
+        panose=Panose(),
+        ulUnicodeRange1=0,
+        ulUnicodeRange2=0,
+        ulUnicodeRange3=0,
+        ulUnicodeRange4=0,
+        achVendID="????",
+        fsSelection=0,
+        usFirstCharIndex=0,
+        usLastCharIndex=0,
+        sTypoAscender=0,
+        sTypoDescender=0,
+        sTypoLineGap=0,
+        usWinAscent=0,
+        usWinDescent=0,
+        ulCodePageRange1=0,
+        ulCodePageRange2=0,
+        sxHeight=0,
+        sCapHeight=0,
+        usDefaultChar=0,  # .notdef
+        usBreakChar=32,  # space
+        usMaxContext=0,
+        usLowerOpticalPointSize=0,
+        usUpperOpticalPointSize=0,
+    )
 
 
 class FontBuilder(object):
@@ -493,7 +493,7 @@ class FontBuilder(object):
         """Create a new `OS/2` table and initialize it with default values,
         which can be overridden by keyword arguments.
         """
-        self._initTableWithValues("OS/2", _OS2Defaults, values)
+        self._initTableWithValues("OS/2", _getOS2Defaults(), values)
         if "xAvgCharWidth" not in values:
             assert (
                 "hmtx" in self.font
@@ -714,6 +714,12 @@ class FontBuilder(object):
         gvar.reserved = 0
         gvar.variations = variations
 
+    def setupGVAR(self, variations):
+        gvar = self.font["GVAR"] = newTable("GVAR")
+        gvar.version = 1
+        gvar.reserved = 0
+        gvar.variations = variations
+
     def calcGlyphBounds(self):
         """Calculate the bounding boxes of all glyphs in the `glyf` table.
         This is usually not called explicitly by client code.

fontTools/merge/__init__.py

@@ -196,7 +196,7 @@ def main(args=None):
 
     if len(fontfiles) < 1:
         print(
-            "usage: pyftmerge [font1 ... fontN] [--input-file=filelist.txt] [--output-file=merged.ttf] [--import-file=tables.ttx]",
+            "usage: fonttools merge [font1 ... fontN] [--input-file=filelist.txt] [--output-file=merged.ttf] [--import-file=tables.ttx]",
             file=sys.stderr,
         )
         print(

fontTools/merge/cmap.py

@@ -54,6 +54,28 @@ def _glyphsAreSame(
     return True
 
 
+def computeMegaUvs(merger, uvsTables):
+    """Returns merged UVS subtable (cmap format=14)."""
+    uvsDict = {}
+    cmap = merger.cmap
+    for table in uvsTables:
+        for variationSelector, uvsMapping in table.uvsDict.items():
+            if variationSelector not in uvsDict:
+                uvsDict[variationSelector] = {}
+            for unicodeValue, glyphName in uvsMapping:
+                if cmap.get(unicodeValue) == glyphName:
+                    # this is a default variation
+                    glyphName = None
+                    # prefer previous glyph id if both fonts defined UVS
+                if unicodeValue not in uvsDict[variationSelector]:
+                    uvsDict[variationSelector][unicodeValue] = glyphName
+
+    for variationSelector in uvsDict:
+        uvsDict[variationSelector] = [*uvsDict[variationSelector].items()]
+
+    return uvsDict
+
+
 # Valid (format, platformID, platEncID) triplets for cmap subtables containing
 # Unicode BMP-only and Unicode Full Repertoire semantics.
 # Cf. OpenType spec for "Platform specific encodings":
@@ -61,24 +83,29 @@ def _glyphsAreSame(
 class _CmapUnicodePlatEncodings:
     BMP = {(4, 3, 1), (4, 0, 3), (4, 0, 4), (4, 0, 6)}
     FullRepertoire = {(12, 3, 10), (12, 0, 4), (12, 0, 6)}
+    UVS = {(14, 0, 5)}
 
 
 def computeMegaCmap(merger, cmapTables):
-    """Sets merger.cmap and merger.glyphOrder."""
+    """Sets merger.cmap and merger.uvsDict."""
 
     # TODO Handle format=14.
     # Only merge format 4 and 12 Unicode subtables, ignores all other subtables
     # If there is a format 12 table for a font, ignore the format 4 table of it
     chosenCmapTables = []
+    chosenUvsTables = []
     for fontIdx, table in enumerate(cmapTables):
         format4 = None
         format12 = None
+        format14 = None
         for subtable in table.tables:
             properties = (subtable.format, subtable.platformID, subtable.platEncID)
             if properties in _CmapUnicodePlatEncodings.BMP:
                 format4 = subtable
             elif properties in _CmapUnicodePlatEncodings.FullRepertoire:
                 format12 = subtable
+            elif properties in _CmapUnicodePlatEncodings.UVS:
+                format14 = subtable
             else:
                 log.warning(
                     "Dropped cmap subtable from font '%s':\t"
@@ -93,6 +120,9 @@ def computeMegaCmap(merger, cmapTables):
         elif format4 is not None:
             chosenCmapTables.append((format4, fontIdx))
 
+        if format14 is not None:
+            chosenUvsTables.append(format14)
+
     # Build the unicode mapping
     merger.cmap = cmap = {}
     fontIndexForGlyph = {}
@@ -127,6 +157,8 @@ def computeMegaCmap(merger, cmapTables):
                         "Dropped mapping from codepoint %#06X to glyphId '%s'", uni, gid
                     )
 
+    merger.uvsDict = computeMegaUvs(merger, chosenUvsTables)
+
 
 def renameCFFCharStrings(merger, glyphOrder, cffTable):
     """Rename topDictIndex charStrings based on glyphOrder."""

fontTools/merge/tables.py

@@ -312,7 +312,6 @@ def merge(self, m, tables):
 
 @add_method(ttLib.getTableClass("cmap"))
 def merge(self, m, tables):
-    # TODO Handle format=14.
     if not hasattr(m, "cmap"):
         computeMegaCmap(m, tables)
     cmap = m.cmap
@@ -336,6 +335,18 @@ def merge(self, m, tables):
     cmapTable.cmap = cmapBmpOnly
     # ordered by platform then encoding
     self.tables.insert(0, cmapTable)
+
+    uvsDict = m.uvsDict
+    if uvsDict:
+        # format-14
+        uvsTable = module.cmap_classes[14](14)
+        uvsTable.platformID = 0
+        uvsTable.platEncID = 5
+        uvsTable.language = 0
+        uvsTable.cmap = {}
+        uvsTable.uvsDict = uvsDict
+        # ordered by platform then encoding
+        self.tables.insert(0, uvsTable)
     self.tableVersion = 0
     self.numSubTables = len(self.tables)
     return self