fonttools 4.60.2__cp311-cp311-win32.whl

fontTools/ttLib/removeOverlaps.py

@@ -0,0 +1,395 @@
+"""Simplify TrueType glyphs by merging overlapping contours/components.
+
+Requires https://github.com/fonttools/skia-pathops
+"""
+
+import itertools
+import logging
+from typing import Callable, Iterable, Optional, Mapping
+
+from fontTools.cffLib import CFFFontSet
+from fontTools.ttLib import ttFont
+from fontTools.ttLib.tables import _g_l_y_f
+from fontTools.ttLib.tables import _h_m_t_x
+from fontTools.misc.psCharStrings import T2CharString
+from fontTools.misc.roundTools import otRound, noRound
+from fontTools.pens.ttGlyphPen import TTGlyphPen
+from fontTools.pens.t2CharStringPen import T2CharStringPen
+
+import pathops
+
+
+__all__ = ["removeOverlaps"]
+
+
+class RemoveOverlapsError(Exception):
+    pass
+
+
+log = logging.getLogger("fontTools.ttLib.removeOverlaps")
+
+_TTGlyphMapping = Mapping[str, ttFont._TTGlyph]
+
+
+def skPathFromGlyph(glyphName: str, glyphSet: _TTGlyphMapping) -> pathops.Path:
+    path = pathops.Path()
+    pathPen = path.getPen(glyphSet=glyphSet)
+    glyphSet[glyphName].draw(pathPen)
+    return path
+
+
+def skPathFromGlyphComponent(
+    component: _g_l_y_f.GlyphComponent, glyphSet: _TTGlyphMapping
+):
+    baseGlyphName, transformation = component.getComponentInfo()
+    path = skPathFromGlyph(baseGlyphName, glyphSet)
+    return path.transform(*transformation)
+
+
+def componentsOverlap(glyph: _g_l_y_f.Glyph, glyphSet: _TTGlyphMapping) -> bool:
+    if not glyph.isComposite():
+        raise ValueError("This method only works with TrueType composite glyphs")
+    if len(glyph.components) < 2:
+        return False  # single component, no overlaps
+
+    component_paths = {}
+
+    def _get_nth_component_path(index: int) -> pathops.Path:
+        if index not in component_paths:
+            component_paths[index] = skPathFromGlyphComponent(
+                glyph.components[index], glyphSet
+            )
+        return component_paths[index]
+
+    return any(
+        pathops.op(
+            _get_nth_component_path(i),
+            _get_nth_component_path(j),
+            pathops.PathOp.INTERSECTION,
+            fix_winding=False,
+            keep_starting_points=False,
+        )
+        for i, j in itertools.combinations(range(len(glyph.components)), 2)
+    )
+
+
+def ttfGlyphFromSkPath(path: pathops.Path) -> _g_l_y_f.Glyph:
+    # Skia paths have no 'components', no need for glyphSet
+    ttPen = TTGlyphPen(glyphSet=None)
+    path.draw(ttPen)
+    glyph = ttPen.glyph()
+    assert not glyph.isComposite()
+    # compute glyph.xMin (glyfTable parameter unused for non composites)
+    glyph.recalcBounds(glyfTable=None)
+    return glyph
+
+
+def _charString_from_SkPath(
+    path: pathops.Path, charString: T2CharString
+) -> T2CharString:
+    if charString.width == charString.private.defaultWidthX:
+        width = None
+    else:
+        width = charString.width - charString.private.nominalWidthX
+    t2Pen = T2CharStringPen(width=width, glyphSet=None)
+    path.draw(t2Pen)
+    return t2Pen.getCharString(charString.private, charString.globalSubrs)
+
+
+def _round_path(
+    path: pathops.Path, round: Callable[[float], float] = otRound
+) -> pathops.Path:
+    rounded_path = pathops.Path()
+    for verb, points in path:
+        rounded_path.add(verb, *((round(p[0]), round(p[1])) for p in points))
+    return rounded_path
+
+
+def _simplify(
+    path: pathops.Path,
+    debugGlyphName: str,
+    *,
+    round: Callable[[float], float] = otRound,
+) -> pathops.Path:
+    # skia-pathops has a bug where it sometimes fails to simplify paths when there
+    # are float coordinates and control points are very close to one another.
+    # Rounding coordinates to integers works around the bug.
+    # Since we are going to round glyf coordinates later on anyway, here it is
+    # ok(-ish) to also round before simplify. Better than failing the whole process
+    # for the entire font.
+    # https://bugs.chromium.org/p/skia/issues/detail?id=11958
+    # https://github.com/google/fonts/issues/3365
+    # TODO(anthrotype): remove once this Skia bug is fixed
+    try:
+        return pathops.simplify(path, clockwise=path.clockwise)
+    except pathops.PathOpsError:
+        pass
+
+    path = _round_path(path, round=round)
+    try:
+        path = pathops.simplify(path, clockwise=path.clockwise)
+        log.debug(
+            "skia-pathops failed to simplify '%s' with float coordinates, "
+            "but succeded using rounded integer coordinates",
+            debugGlyphName,
+        )
+        return path
+    except pathops.PathOpsError as e:
+        if log.isEnabledFor(logging.DEBUG):
+            path.dump()
+        raise RemoveOverlapsError(
+            f"Failed to remove overlaps from glyph {debugGlyphName!r}"
+        ) from e
+
+    raise AssertionError("Unreachable")
+
+
+def _same_path(path1: pathops.Path, path2: pathops.Path) -> bool:
+    return {tuple(c) for c in path1.contours} == {tuple(c) for c in path2.contours}
+
+
+def removeTTGlyphOverlaps(
+    glyphName: str,
+    glyphSet: _TTGlyphMapping,
+    glyfTable: _g_l_y_f.table__g_l_y_f,
+    hmtxTable: _h_m_t_x.table__h_m_t_x,
+    removeHinting: bool = True,
+) -> bool:
+    glyph = glyfTable[glyphName]
+    # decompose composite glyphs only if components overlap each other
+    if (
+        glyph.numberOfContours > 0
+        or glyph.isComposite()
+        and componentsOverlap(glyph, glyphSet)
+    ):
+        path = skPathFromGlyph(glyphName, glyphSet)
+
+        # remove overlaps
+        path2 = _simplify(path, glyphName)
+
+        # replace TTGlyph if simplified path is different (ignoring contour order)
+        if not _same_path(path, path2):
+            glyfTable[glyphName] = glyph = ttfGlyphFromSkPath(path2)
+            # simplified glyph is always unhinted
+            assert not glyph.program
+            # also ensure hmtx LSB == glyph.xMin so glyph origin is at x=0
+            width, lsb = hmtxTable[glyphName]
+            if lsb != glyph.xMin:
+                hmtxTable[glyphName] = (width, glyph.xMin)
+            return True
+
+    if removeHinting:
+        glyph.removeHinting()
+    return False
+
+
+def _remove_glyf_overlaps(
+    *,
+    font: ttFont.TTFont,
+    glyphNames: Iterable[str],
+    glyphSet: _TTGlyphMapping,
+    removeHinting: bool,
+    ignoreErrors: bool,
+) -> None:
+    glyfTable = font["glyf"]
+    hmtxTable = font["hmtx"]
+
+    # process all simple glyphs first, then composites with increasing component depth,
+    # so that by the time we test for component intersections the respective base glyphs
+    # have already been simplified
+    glyphNames = sorted(
+        glyphNames,
+        key=lambda name: (
+            (
+                glyfTable[name].getCompositeMaxpValues(glyfTable).maxComponentDepth
+                if glyfTable[name].isComposite()
+                else 0
+            ),
+            name,
+        ),
+    )
+    modified = set()
+    for glyphName in glyphNames:
+        try:
+            if removeTTGlyphOverlaps(
+                glyphName, glyphSet, glyfTable, hmtxTable, removeHinting
+            ):
+                modified.add(glyphName)
+        except RemoveOverlapsError:
+            if not ignoreErrors:
+                raise
+            log.error("Failed to remove overlaps for '%s'", glyphName)
+
+    log.debug("Removed overlaps for %s glyphs:\n%s", len(modified), " ".join(modified))
+
+
+def _remove_charstring_overlaps(
+    *,
+    glyphName: str,
+    glyphSet: _TTGlyphMapping,
+    cffFontSet: CFFFontSet,
+) -> bool:
+    path = skPathFromGlyph(glyphName, glyphSet)
+
+    # remove overlaps
+    path2 = _simplify(path, glyphName, round=noRound)
+
+    # replace TTGlyph if simplified path is different (ignoring contour order)
+    if not _same_path(path, path2):
+        charStrings = cffFontSet[0].CharStrings
+        charStrings[glyphName] = _charString_from_SkPath(path2, charStrings[glyphName])
+        return True
+
+    return False
+
+
+def _remove_cff_overlaps(
+    *,
+    font: ttFont.TTFont,
+    glyphNames: Iterable[str],
+    glyphSet: _TTGlyphMapping,
+    removeHinting: bool,
+    ignoreErrors: bool,
+    table_tag: str,
+    removeUnusedSubroutines: bool = True,
+) -> None:
+    cffFontSet = font[table_tag].cff
+    modified = set()
+    for glyphName in glyphNames:
+        try:
+            if _remove_charstring_overlaps(
+                glyphName=glyphName,
+                glyphSet=glyphSet,
+                cffFontSet=cffFontSet,
+            ):
+                modified.add(glyphName)
+        except RemoveOverlapsError:
+            if not ignoreErrors:
+                raise
+            log.error("Failed to remove overlaps for '%s'", glyphName)
+
+    if not modified:
+        log.debug("No overlaps found in the specified CFF glyphs")
+        return
+
+    if removeHinting:
+        cffFontSet.remove_hints()
+
+    if removeUnusedSubroutines:
+        cffFontSet.remove_unused_subroutines()
+
+    log.debug("Removed overlaps for %s glyphs:\n%s", len(modified), " ".join(modified))
+
+
+def removeOverlaps(
+    font: ttFont.TTFont,
+    glyphNames: Optional[Iterable[str]] = None,
+    removeHinting: bool = True,
+    ignoreErrors: bool = False,
+    *,
+    removeUnusedSubroutines: bool = True,
+) -> None:
+    """Simplify glyphs in TTFont by merging overlapping contours.
+
+    Overlapping components are first decomposed to simple contours, then merged.
+
+    Currently this only works for fonts with 'glyf' or 'CFF ' tables.
+    Raises NotImplementedError if 'glyf' or 'CFF ' tables are absent.
+
+    Note that removing overlaps invalidates the hinting. By default we drop hinting
+    from all glyphs whether or not overlaps are removed from a given one, as it would
+    look weird if only some glyphs are left (un)hinted.
+
+    Args:
+        font: input TTFont object, modified in place.
+        glyphNames: optional iterable of glyph names (str) to remove overlaps from.
+            By default, all glyphs in the font are processed.
+        removeHinting (bool): set to False to keep hinting for unmodified glyphs.
+        ignoreErrors (bool): set to True to ignore errors while removing overlaps,
+            thus keeping the tricky glyphs unchanged (fonttools/fonttools#2363).
+        removeUnusedSubroutines (bool): set to False to keep unused subroutines
+            in CFF table after removing overlaps. Default is to remove them if
+            any glyphs are modified.
+    """
+
+    if "glyf" not in font and "CFF " not in font and "CFF2" not in font:
+        raise NotImplementedError(
+            "No outline data found in the font: missing 'glyf', 'CFF ', or 'CFF2' table"
+        )
+
+    if glyphNames is None:
+        glyphNames = font.getGlyphOrder()
+
+    # Wraps the underlying glyphs, takes care of interfacing with drawing pens
+    glyphSet = font.getGlyphSet()
+
+    if "glyf" in font:
+        _remove_glyf_overlaps(
+            font=font,
+            glyphNames=glyphNames,
+            glyphSet=glyphSet,
+            removeHinting=removeHinting,
+            ignoreErrors=ignoreErrors,
+        )
+
+    if "CFF " in font or "CFF2" in font:
+        _remove_cff_overlaps(
+            font=font,
+            glyphNames=glyphNames,
+            glyphSet=glyphSet,
+            removeHinting=removeHinting,
+            ignoreErrors=ignoreErrors,
+            table_tag="CFF " if "CFF " in font else "CFF2",
+            removeUnusedSubroutines=removeUnusedSubroutines,
+        )
+
+
+def main(args=None):
+    """Simplify glyphs in TTFont by merging overlapping contours."""
+
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools ttLib.removeOverlaps", description=__doc__
+    )
+
+    parser.add_argument("input", metavar="INPUT.ttf", help="Input font file")
+    parser.add_argument("output", metavar="OUTPUT.ttf", help="Output font file")
+    parser.add_argument(
+        "glyphs",
+        metavar="GLYPHS",
+        nargs="*",
+        help="Optional list of glyph names to remove overlaps from",
+    )
+    parser.add_argument(
+        "--keep-hinting",
+        action="store_true",
+        help="Keep hinting for unmodified glyphs, default is to drop hinting",
+    )
+    parser.add_argument(
+        "--ignore-errors",
+        action="store_true",
+        help="ignore errors while removing overlaps, "
+        "thus keeping the tricky glyphs unchanged",
+    )
+    parser.add_argument(
+        "--keep-unused-subroutines",
+        action="store_true",
+        help="Keep unused subroutines in CFF table after removing overlaps, "
+        "default is to remove them if any glyphs are modified",
+    )
+    args = parser.parse_args(args)
+
+    with ttFont.TTFont(args.input) as font:
+        removeOverlaps(
+            font=font,
+            glyphNames=args.glyphs or None,
+            removeHinting=not args.keep_hinting,
+            ignoreErrors=args.ignore_errors,
+            removeUnusedSubroutines=not args.keep_unused_subroutines,
+        )
+        font.save(args.output)
+
+
+if __name__ == "__main__":
+    main()

fontTools/ttLib/reorderGlyphs.py

@@ -0,0 +1,285 @@
+"""Reorder glyphs in a font."""
+
+__author__ = "Rod Sheeter"
+
+# See https://docs.google.com/document/d/1h9O-C_ndods87uY0QeIIcgAMiX2gDTpvO_IhMJsKAqs/
+# for details.
+
+
+from fontTools import ttLib
+from fontTools.ttLib.tables import otBase
+from fontTools.ttLib.tables import otTables as ot
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from collections import deque
+from typing import (
+    Optional,
+    Any,
+    Callable,
+    Deque,
+    Iterable,
+    List,
+    Tuple,
+)
+
+
+_COVERAGE_ATTR = "Coverage"  # tables that have one coverage use this name
+
+
+def _sort_by_gid(
+    get_glyph_id: Callable[[str], int],
+    glyphs: List[str],
+    parallel_list: Optional[List[Any]],
+):
+    if parallel_list:
+        reordered = sorted(
+            ((g, e) for g, e in zip(glyphs, parallel_list)),
+            key=lambda t: get_glyph_id(t[0]),
+        )
+        sorted_glyphs, sorted_parallel_list = map(list, zip(*reordered))
+        parallel_list[:] = sorted_parallel_list
+    else:
+        sorted_glyphs = sorted(glyphs, key=get_glyph_id)
+
+    glyphs[:] = sorted_glyphs
+
+
+def _get_dotted_attr(value: Any, dotted_attr: str) -> Any:
+    attr_names = dotted_attr.split(".")
+    assert attr_names
+
+    while attr_names:
+        attr_name = attr_names.pop(0)
+        value = getattr(value, attr_name)
+    return value
+
+
+class ReorderRule(ABC):
+    """A rule to reorder something in a font to match the fonts glyph order."""
+
+    @abstractmethod
+    def apply(self, font: ttLib.TTFont, value: otBase.BaseTable) -> None: ...
+
+
+@dataclass(frozen=True)
+class ReorderCoverage(ReorderRule):
+    """Reorder a Coverage table, and optionally a list that is sorted parallel to it."""
+
+    # A list that is parallel to Coverage
+    parallel_list_attr: Optional[str] = None
+    coverage_attr: str = _COVERAGE_ATTR
+
+    def apply(self, font: ttLib.TTFont, value: otBase.BaseTable) -> None:
+        coverage = _get_dotted_attr(value, self.coverage_attr)
+
+        if type(coverage) is not list:
+            # Normal path, process one coverage that might have a parallel list
+            parallel_list = None
+            if self.parallel_list_attr:
+                parallel_list = _get_dotted_attr(value, self.parallel_list_attr)
+                assert (
+                    type(parallel_list) is list
+                ), f"{self.parallel_list_attr} should be a list"
+                assert len(parallel_list) == len(coverage.glyphs), "Nothing makes sense"
+
+            _sort_by_gid(font.getGlyphID, coverage.glyphs, parallel_list)
+
+        else:
+            # A few tables have a list of coverage. No parallel list can exist.
+            assert (
+                not self.parallel_list_attr
+            ), f"Can't have multiple coverage AND a parallel list; {self}"
+            for coverage_entry in coverage:
+                _sort_by_gid(font.getGlyphID, coverage_entry.glyphs, None)
+
+
+@dataclass(frozen=True)
+class ReorderList(ReorderRule):
+    """Reorder the items within a list to match the updated glyph order.
+
+    Useful when a list ordered by coverage itself contains something ordered by a gid.
+    For example, the PairSet table of https://docs.microsoft.com/en-us/typography/opentype/spec/gpos#lookup-type-2-pair-adjustment-positioning-subtable.
+    """
+
+    list_attr: str
+    key: str
+
+    def apply(self, font: ttLib.TTFont, value: otBase.BaseTable) -> None:
+        lst = _get_dotted_attr(value, self.list_attr)
+        assert isinstance(lst, list), f"{self.list_attr} should be a list"
+        lst.sort(key=lambda v: font.getGlyphID(getattr(v, self.key)))
+
+
+# (Type, Optional Format) => List[ReorderRule]
+# Encodes the relationships Cosimo identified
+_REORDER_RULES = {
+    # GPOS
+    (ot.SinglePos, 1): [ReorderCoverage()],
+    (ot.SinglePos, 2): [ReorderCoverage(parallel_list_attr="Value")],
+    (ot.PairPos, 1): [ReorderCoverage(parallel_list_attr="PairSet")],
+    (ot.PairSet, None): [ReorderList("PairValueRecord", key="SecondGlyph")],
+    (ot.PairPos, 2): [ReorderCoverage()],
+    (ot.CursivePos, 1): [ReorderCoverage(parallel_list_attr="EntryExitRecord")],
+    (ot.MarkBasePos, 1): [
+        ReorderCoverage(
+            coverage_attr="MarkCoverage", parallel_list_attr="MarkArray.MarkRecord"
+        ),
+        ReorderCoverage(
+            coverage_attr="BaseCoverage", parallel_list_attr="BaseArray.BaseRecord"
+        ),
+    ],
+    (ot.MarkLigPos, 1): [
+        ReorderCoverage(
+            coverage_attr="MarkCoverage", parallel_list_attr="MarkArray.MarkRecord"
+        ),
+        ReorderCoverage(
+            coverage_attr="LigatureCoverage",
+            parallel_list_attr="LigatureArray.LigatureAttach",
+        ),
+    ],
+    (ot.MarkMarkPos, 1): [
+        ReorderCoverage(
+            coverage_attr="Mark1Coverage", parallel_list_attr="Mark1Array.MarkRecord"
+        ),
+        ReorderCoverage(
+            coverage_attr="Mark2Coverage", parallel_list_attr="Mark2Array.Mark2Record"
+        ),
+    ],
+    (ot.ContextPos, 1): [ReorderCoverage(parallel_list_attr="PosRuleSet")],
+    (ot.ContextPos, 2): [ReorderCoverage()],
+    (ot.ContextPos, 3): [ReorderCoverage()],
+    (ot.ChainContextPos, 1): [ReorderCoverage(parallel_list_attr="ChainPosRuleSet")],
+    (ot.ChainContextPos, 2): [ReorderCoverage()],
+    (ot.ChainContextPos, 3): [
+        ReorderCoverage(coverage_attr="BacktrackCoverage"),
+        ReorderCoverage(coverage_attr="InputCoverage"),
+        ReorderCoverage(coverage_attr="LookAheadCoverage"),
+    ],
+    # GSUB
+    (ot.ContextSubst, 1): [ReorderCoverage(parallel_list_attr="SubRuleSet")],
+    (ot.ContextSubst, 2): [ReorderCoverage()],
+    (ot.ContextSubst, 3): [ReorderCoverage()],
+    (ot.ChainContextSubst, 1): [ReorderCoverage(parallel_list_attr="ChainSubRuleSet")],
+    (ot.ChainContextSubst, 2): [ReorderCoverage()],
+    (ot.ChainContextSubst, 3): [
+        ReorderCoverage(coverage_attr="BacktrackCoverage"),
+        ReorderCoverage(coverage_attr="InputCoverage"),
+        ReorderCoverage(coverage_attr="LookAheadCoverage"),
+    ],
+    (ot.ReverseChainSingleSubst, 1): [
+        ReorderCoverage(parallel_list_attr="Substitute"),
+        ReorderCoverage(coverage_attr="BacktrackCoverage"),
+        ReorderCoverage(coverage_attr="LookAheadCoverage"),
+    ],
+    # GDEF
+    (ot.AttachList, None): [ReorderCoverage(parallel_list_attr="AttachPoint")],
+    (ot.LigCaretList, None): [ReorderCoverage(parallel_list_attr="LigGlyph")],
+    (ot.MarkGlyphSetsDef, None): [ReorderCoverage()],
+    # MATH
+    (ot.MathGlyphInfo, None): [ReorderCoverage(coverage_attr="ExtendedShapeCoverage")],
+    (ot.MathItalicsCorrectionInfo, None): [
+        ReorderCoverage(parallel_list_attr="ItalicsCorrection")
+    ],
+    (ot.MathTopAccentAttachment, None): [
+        ReorderCoverage(
+            coverage_attr="TopAccentCoverage", parallel_list_attr="TopAccentAttachment"
+        )
+    ],
+    (ot.MathKernInfo, None): [
+        ReorderCoverage(
+            coverage_attr="MathKernCoverage", parallel_list_attr="MathKernInfoRecords"
+        )
+    ],
+    (ot.MathVariants, None): [
+        ReorderCoverage(
+            coverage_attr="VertGlyphCoverage",
+            parallel_list_attr="VertGlyphConstruction",
+        ),
+        ReorderCoverage(
+            coverage_attr="HorizGlyphCoverage",
+            parallel_list_attr="HorizGlyphConstruction",
+        ),
+    ],
+}
+
+
+# TODO Port to otTraverse
+
+SubTablePath = Tuple[otBase.BaseTable.SubTableEntry, ...]
+
+
+def _bfs_base_table(
+    root: otBase.BaseTable, root_accessor: str
+) -> Iterable[SubTablePath]:
+    yield from _traverse_ot_data(
+        root, root_accessor, lambda frontier, new: frontier.extend(new)
+    )
+
+
+# Given f(current frontier, new entries) add new entries to frontier
+AddToFrontierFn = Callable[[Deque[SubTablePath], List[SubTablePath]], None]
+
+
+def _traverse_ot_data(
+    root: otBase.BaseTable, root_accessor: str, add_to_frontier_fn: AddToFrontierFn
+) -> Iterable[SubTablePath]:
+    # no visited because general otData is forward-offset only and thus cannot cycle
+
+    frontier: Deque[SubTablePath] = deque()
+    frontier.append((otBase.BaseTable.SubTableEntry(root_accessor, root),))
+    while frontier:
+        # path is (value, attr_name) tuples. attr_name is attr of parent to get value
+        path = frontier.popleft()
+        current = path[-1].value
+
+        yield path
+
+        new_entries = []
+        for subtable_entry in current.iterSubTables():
+            new_entries.append(path + (subtable_entry,))
+
+        add_to_frontier_fn(frontier, new_entries)
+
+
+def reorderGlyphs(font: ttLib.TTFont, new_glyph_order: List[str]):
+    old_glyph_order = font.getGlyphOrder()
+    if len(new_glyph_order) != len(old_glyph_order):
+        raise ValueError(
+            f"New glyph order contains {len(new_glyph_order)} glyphs, "
+            f"but font has {len(old_glyph_order)} glyphs"
+        )
+
+    if set(old_glyph_order) != set(new_glyph_order):
+        raise ValueError(
+            "New glyph order does not contain the same set of glyphs as the font:\n"
+            f"* only in new: {set(new_glyph_order) - set(old_glyph_order)}\n"
+            f"* only in old: {set(old_glyph_order) - set(new_glyph_order)}"
+        )
+
+    # Changing the order of glyphs in a TTFont requires that all tables that use
+    # glyph indexes have been fully.
+    # Cf. https://github.com/fonttools/fonttools/issues/2060
+    font.ensureDecompiled()
+    not_loaded = sorted(t for t in font.keys() if not font.isLoaded(t))
+    if not_loaded:
+        raise ValueError(f"Everything should be loaded, following aren't: {not_loaded}")
+
+    font.setGlyphOrder(new_glyph_order)
+
+    coverage_containers = {"GDEF", "GPOS", "GSUB", "MATH"}
+    for tag in coverage_containers:
+        if tag in font.keys():
+            for path in _bfs_base_table(font[tag].table, f'font["{tag}"]'):
+                value = path[-1].value
+                reorder_key = (type(value), getattr(value, "Format", None))
+                for reorder in _REORDER_RULES.get(reorder_key, []):
+                    reorder.apply(font, value)
+
+    for tag in ["CFF ", "CFF2"]:
+        if tag in font:
+            cff_table = font[tag]
+            charstrings = cff_table.cff.topDictIndex[0].CharStrings.charStrings
+            cff_table.cff.topDictIndex[0].charset = new_glyph_order
+            cff_table.cff.topDictIndex[0].CharStrings.charStrings = {
+                k: charstrings.get(k) for k in new_glyph_order
+            }