fontisan 0.4.11 → 0.4.12

data/lib/fontisan/ufo/compile/feature_writers/mark_family_base.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # Shared base for feature writers that pair "mark" glyphs with
+        # "base" glyphs via a paired-anchor convention (Mark uses
+        # +_<name>+ ↔ +<name>+; Mkmk uses +_<name>mkmk+ ↔
+        # +<name>mkmk+). Concrete subclasses plug in the lookup
+        # convention + the lookup type + the feature tag.
+        #
+        # Reduces duplication between Mark and Mkmk: both walk every
+        # glyph, collect its anchor classes (with the convention's
+        # prefix + suffix), then pair each class with matching bases.
+        class MarkFamilyBase < Base
+          # @return [FeatureOutput, nil]
+          def write
+            marks = collect_marks
+            return nil if marks.empty?
+
+            attachments = {}
+
+            marks.each do |(mark_name, classes)|
+              classes.each do |class_name, mark_anchor|
+                bases = collect_bases_for(class_name)
+                next if bases.empty?
+
+                attachments[class_name] ||= new_class_entry
+                attachments[class_name][:marks][mark_name] = mark_anchor
+                bases.each { |n, a| attachments[class_name][base_bucket_key][n] = a }
+              end
+            end
+
+            return nil if attachments.empty?
+
+            FeatureOutput.new(
+              table_tag: table_tag,
+              feature_tag: feature_tag,
+              lookup_type: lookup_type,
+              data: { attachments: attachments },
+            )
+          end
+
+          private
+
+          # The convention's mark-anchor predicate. Returns the
+          # class_name extracted from a mark glyph's anchor name, or
+          # +nil+ if the anchor doesn't match the convention.
+          #
+          # Subclasses implement this — Mark's convention is
+          # "_<name>"; Mkmk's is "_<name>mkmk".
+          def mark_class_from_anchor(_anchor_name)
+            raise NotImplementedError,
+                  "#{self.class} must implement #mark_class_from_anchor"
+          end
+
+          # Inverse of +mark_class_from_anchor+: given a class name
+          # extracted from a mark anchor, what's the matching
+          # base-anchor name? Mark's convention is class_name; Mkmk's
+          # is "<class_name>mkmk".
+          def base_anchor_name_for(_class_name)
+            raise NotImplementedError,
+                  "#{self.class} must implement #base_anchor_name_for"
+          end
+
+          # Subclass overrides — Mark uses :bases, Mkmk uses :base_marks.
+          def base_bucket_key
+            :bases
+          end
+
+          # Build a fresh per-class attachment entry with the right
+          # base bucket key. Avoids inline hash-literal ambiguity
+          # with dynamic keys.
+          def new_class_entry
+            { marks: {}, base_bucket_key => {} }
+          end
+
+          def table_tag
+            "GPOS"
+          end
+
+          def feature_tag
+            nil
+          end
+
+          def lookup_type
+            nil
+          end
+
+          def collect_marks
+            font.glyphs.each_with_object({}) do |(name, glyph), h|
+              classes = mark_classes_for(glyph)
+              h[name] = classes unless classes.empty?
+            end
+          end
+
+          def mark_classes_for(glyph)
+            glyph.anchors.each_with_object({}) do |anchor, h|
+              class_name = mark_class_from_anchor(anchor.name.to_s)
+              next unless class_name
+
+              h[class_name] = [anchor.x, anchor.y]
+            end
+          end
+
+          def collect_bases_for(class_name)
+            target = base_anchor_name_for(class_name)
+            return {} unless target
+
+            font.glyphs.each_with_object({}) do |(name, glyph), h|
+              anchor = glyph.anchors.find { |a| a.name == target }
+              next unless anchor
+
+              h[name] = [anchor.x, anchor.y]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers/mkmk.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module FeatureWriters
+        # GPOS MarkToMark (lookup type 6) — mark-to-mark attachment.
+        #
+        # Same shape as MarkToBase, but pairs marks with OTHER marks
+        # rather than marks with bases. UFO convention: a mark glyph
+        # that can attach to another mark has a +_<name>mkmk+ anchor
+        # (the attach-FROM point), and the "base mark" it attaches to
+        # has the matching +<name>mkmk+ anchor (the attach-TO point).
+        #
+        # Pairs every glyph with a +_<name>mkmk+ anchor with every
+        # glyph that has the matching +<name>mkmk+ anchor.
+        class Mkmk < MarkFamilyBase
+          LOOKUP_TYPE = 6
+          FEATURE_TAG = "mkmk"
+          MKMK_SUFFIX = "mkmk"
+
+          private
+
+          def feature_tag
+            FEATURE_TAG
+          end
+
+          def lookup_type
+            LOOKUP_TYPE
+          end
+
+          def base_bucket_key
+            :base_marks
+          end
+
+          # Mkmk convention: _<name>mkmk → class_name = name (drop
+          # underscore prefix + "mkmk" suffix).
+          def mark_class_from_anchor(anchor_name)
+            return nil unless anchor_name.start_with?("_")
+            return nil unless anchor_name.end_with?(MKMK_SUFFIX)
+
+            anchor_name[1..-MKMK_SUFFIX.length - 1]
+          end
+
+          # Base-mark convention: class_name + "mkmk" suffix.
+          def base_anchor_name_for(class_name)
+            "#{class_name}#{MKMK_SUFFIX}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/feature_writers.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Feature writers extract GSUB/GPOS feature data from a UFO
+      # source. Each writer is a class extending {FeatureWriters::Base}
+      # with a +#write+ method that returns a {FeatureOutput} value
+      # object (or +nil+ if the UFO has no data for that feature).
+      #
+      # The compiler runs registered writers, collects their outputs,
+      # and feeds each into the corresponding table builder
+      # (`Tables::Gpos`, `Tables::Gsub`, etc.) for binary encoding.
+      #
+      # OCP: adding a new feature writer = new class + one REGISTRY
+      # entry. No edits to the compiler.
+      module FeatureWriters
+        autoload :Base, "fontisan/ufo/compile/feature_writers/base"
+        autoload :MarkFamilyBase, "fontisan/ufo/compile/feature_writers/mark_family_base"
+        autoload :Kern, "fontisan/ufo/compile/feature_writers/kern"
+        autoload :Kern2, "fontisan/ufo/compile/feature_writers/kern2"
+        autoload :Gdef, "fontisan/ufo/compile/feature_writers/gdef"
+        autoload :Mark, "fontisan/ufo/compile/feature_writers/mark"
+        autoload :Mkmk, "fontisan/ufo/compile/feature_writers/mkmk"
+        autoload :Curs, "fontisan/ufo/compile/feature_writers/curs"
+
+        # Default writer set — what the compiler runs when the user
+        # doesn't override. Per feature, +#write+ returns +nil+ when
+        # the UFO has no data for that feature, so it's safe to
+        # always run them all. Order matters: Gdef first (so later
+        # writers can rely on glyph classification), then position
+        # features (kern, mark, mkmk, curs).
+        DEFAULT_WRITERS = [Gdef, Kern, Mark, Mkmk, Curs].freeze
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/propagate_anchors.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Propagates anchors from base glyphs to composite glyphs.
+        #
+        # In UFO sources, a composite glyph references base glyphs via
+        # Component entries. Anchors (mark-attachment points used by
+        # GPOS mark feature writers) typically live on the base glyphs
+        # only — the composite inherits them by applying each
+        # component's transformation matrix to the base's anchors.
+        #
+        # This filter does that propagation in place. After it runs,
+        # every composite glyph carries its component-derived anchors,
+        # ready for the mark feature writer to read.
+        #
+        # Single-pass (no recursive propagation through multi-level
+        # component chains). Multi-level propagation would require
+        # topological sort; if you need it, run the filter repeatedly
+        # until no anchors change.
+        module PropagateAnchors
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>] the glyphs to
+          #   mutate. Must include any base glyphs referenced by
+          #   components, or those references will be silently
+          #   skipped.
+          # @param font [Fontisan::Ufo::Font, nil] optional explicit
+          #   font lookup. When provided, base glyphs are resolved
+          #   via +font.glyph(name)+ instead of the +glyphs+ array,
+          #   so composites can reference base glyphs that aren't in
+          #   the +glyphs+ list.
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, font: nil, **_opts)
+            lookup = build_lookup(font, glyphs)
+
+            glyphs.each do |glyph|
+              next if glyph.components.empty?
+
+              glyph.components.each do |component|
+                base = lookup[component.base_glyph]
+                next unless base
+
+                transform = coerce_transformation(component.transformation)
+                propagate_anchors(glyph, base, transform)
+              end
+            end
+
+            glyphs
+          end
+
+          class << self
+            private
+
+            def build_lookup(font, glyphs)
+              return ->(name) { font.glyph(name) } if font
+
+              hash = glyphs.to_h { |g| [g.name, g] }
+              ->(name) { hash[name] }
+            end
+
+            def coerce_transformation(matrix)
+              return Fontisan::Ufo::Transformation.new if matrix.nil?
+              return matrix if matrix.is_a?(Fontisan::Ufo::Transformation)
+
+              Fontisan::Ufo::Transformation.new(
+                a: matrix[0], b: matrix[1],
+                c: matrix[2], d: matrix[3],
+                e: matrix[4], f: matrix[5]
+              )
+            end
+
+            # Copy each anchor from +base+ into +glyph+, transformed
+            # by +transform+. Skip anchors whose (name, transformed
+            # x, transformed y) already exist on +glyph+ (the user
+            # may have placed them manually). Coordinates are coerced
+            # to Float so an Integer manual placement and the Float
+            # transform output compare equal as dedup keys (Ruby's
+            # eql? is type-strict, but == treats 100 == 100.0).
+            def propagate_anchors(glyph, base, transform)
+              existing = glyph.anchors.to_h do |a|
+                [[a.name, a.x.to_f, a.y.to_f], true]
+              end
+
+              base.anchors.each do |anchor|
+                tx, ty = transform.apply(anchor.x, anchor.y)
+                key = [anchor.name, tx, ty]
+                next if existing[key]
+
+                glyph.add_anchor(Fontisan::Ufo::Anchor.new(
+                                   x: tx, y: ty, name: anchor.name,
+                                 ))
+                existing[key] = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/remove_overlaps.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Boolean union of overlapping contours within each glyph.
+        # Two contours that overlap visually are merged into one,
+        # removing the seam. Required for some hinting programs and
+        # for SVG/COLR rendering correctness.
+        #
+        # == Why bounding-box approximation, not polygon clipping
+        #
+        # Full polygon clipping (Greiner-Hormann or Vatti) operates
+        # on straight-line polygons. UFO contours are Bezier curves.
+        # Applying polygon clipping would require:
+        #   1. Flatten Bezier to polygon edges (tessellation).
+        #   2. Run polygon clipping (union).
+        #   3. Re-fit Bezier curves on the result (curve fitting).
+        #
+        # Step 3 is the killer: curve fitting is lossy. The output
+        # curves won't match the input curves' control points,
+        # changing the glyph's rendering at small sizes. For a font
+        # pipeline, preserving curve fidelity matters more than
+        # mathematical union correctness.
+        #
+        # The bounding-box approximation handles the common cases
+        # (overlapping duplicates, fully-contained sub-contours)
+        # without losing any curve data. It does NOT handle partial
+        # overlaps — those remain as separate contours. For fonts
+        # that need partial-overlap removal, preprocess in an editor
+        # (FontLab, Glyphs) or use the `clipper` gem as a pre-compile
+        # step with explicit curve-flattening tolerances.
+        module RemoveOverlaps
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, **_opts)
+            glyphs.each { |g| remove_overlaps_in_glyph(g) }
+            glyphs
+          end
+
+          class << self
+            private
+
+            def remove_overlaps_in_glyph(glyph)
+              return if glyph.contours.size < 2
+
+              bboxes = glyph.contours.map { |c| bounding_box(c) }
+              drop = Set.new
+
+              glyph.contours.each_with_index do |outer, i|
+                next if drop.include?(i)
+
+                glyph.contours.each_with_index do |inner, j|
+                  next if i == j || drop.include?(j)
+
+                  # Drop inner when its bbox is fully inside outer's.
+                  if contained_in?(bboxes[j], bboxes[i]) && (inner.points.size <= outer.points.size)
+                    # Sanity: only drop if the point count is smaller —
+                    # a fully-contained contour with MORE points is
+                    # almost certainly the outer one in a malformed
+                    # source, and dropping it would lose data.
+                    drop << j
+                  end
+                end
+              end
+
+              return if drop.empty?
+
+              glyph.contours.reject!.with_index { |_c, i| drop.include?(i) }
+            end
+
+            def bounding_box(contour)
+              points = contour.points
+              return { x_min: 0, y_min: 0, x_max: 0, y_max: 0 } if points.empty?
+
+              xs = points.map(&:x)
+              ys = points.map(&:y)
+              { x_min: xs.min, y_min: ys.min, x_max: xs.max, y_max: ys.max }
+            end
+
+            def contained_in?(inner, outer)
+              inner[:x_min] >= outer[:x_min] &&
+                inner[:x_max] <= outer[:x_max] &&
+                inner[:y_min] >= outer[:y_min] &&
+                inner[:y_max] <= outer[:y_max]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/sort_contours.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Sorts the contours within each glyph + the points within
+        # each contour. Two distinct operations, both required for
+        # TrueType hinting compatibility:
+        #
+        # 1. **Start-point alignment**: rotate each contour's point
+        #    list so an on-curve point is first (TrueType hinting
+        #    programs expect this).
+        #
+        # 2. **Contour ordering**: order contours within each glyph
+        #    by their starting point's (Y descending, X ascending)
+        #    so the hint program processes outer contours before
+        #    inner ones (true-type convention for nested shapes).
+        #
+        # This is the fontTools/ufo2ft sort_contours filter, scoped
+        # to the contour-level concerns. Per-glyph sort across
+        # multiple glyphs is the caller's responsibility (callers
+        # typically sort glyphs by gid / post name).
+        module SortContours
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array,
+          #   mutated in place
+          def self.run(glyphs, **_opts)
+            glyphs.each do |glyph|
+              glyph.contours.each { |c| rotate_to_first_on_curve(c) }
+              glyph.contours.sort_by! { |c| sort_key(c) }
+            end
+            glyphs
+          end
+
+          class << self
+            private
+
+            # Rotate the point list so an on-curve point sits at
+            # index 0. If the contour is all off-curve (impossible
+            # for valid UFO but defensively handled), leave it
+            # unchanged.
+            def rotate_to_first_on_curve(contour)
+              points = contour.points
+              return if points.empty?
+              return if points.first.on_curve?
+
+              first_on = points.find_index(&:on_curve?)
+              return unless first_on
+
+              contour.points = points.rotate(first_on)
+            end
+
+            # Sort key: descending Y (outer contours typically start
+            # at the top), then ascending X (leftmost first when Y
+            # ties). Uses the first on-curve point's coordinates.
+            # Empty contours sort last (Float::INFINITY).
+            def sort_key(contour)
+              first = contour.points.find(&:on_curve?) || contour.points.first
+              return [Float::INFINITY, Float::INFINITY] unless first
+
+              [-first.y.to_f, first.x.to_f]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters/transformations.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Applies a 2×3 affine transformation to every glyph's
+        # contours + components. The general-purpose filter — other
+        # filters (decompose_components, propagate_anchors) are
+        # special cases of geometric transforms applied to specific
+        # glyph subsets.
+        #
+        # Used for:
+        #   - Symmetric mirroring (e.g. italic→upright flip).
+        #   - Slant adjustment.
+        #   - Custom per-font offsets that callers want baked in at
+        #     compile time rather than carried as variation axis deltas.
+        #
+        # Identity matrix is a no-op fast path.
+        module Transformations
+          DEFAULT_OFFSET_X = 0.0
+          DEFAULT_OFFSET_Y = 0.0
+
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @param matrix [Fontisan::Ufo::Transformation, Array<Numeric>, nil]
+          #   The affine matrix to apply. Accepts either a
+          #   +Transformation+ value object or the raw +[a, b, c, d, e, f]+
+          #   array. +nil+ (the default) is a no-op — leaves glyphs
+          #   unchanged.
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array (mutated)
+          def self.run(glyphs, matrix: nil, **_opts)
+            return glyphs if matrix.nil?
+
+            transform = coerce_transformation(matrix)
+            return glyphs if transform.identity?
+
+            glyphs.each { |g| apply_to_glyph(g, transform) }
+            glyphs
+          end
+
+          class << self
+            private
+
+            # Coerce the matrix argument into a Transformation.
+            # Centralizes the "array, object, or nil?" decision so
+            # callers can pass any form.
+            def coerce_transformation(matrix)
+              return Fontisan::Ufo::Transformation.new if matrix.nil?
+              return matrix if matrix.is_a?(Fontisan::Ufo::Transformation)
+
+              Fontisan::Ufo::Transformation.new(
+                a: matrix[0], b: matrix[1],
+                c: matrix[2], d: matrix[3],
+                e: matrix[4], f: matrix[5]
+              )
+            end
+
+            # Apply the transform in place: each contour's points are
+            # rewritten with transformed coordinates; each component's
+            # +transformation+ is composed with the new one (so nested
+            # component refs chain correctly).
+            def apply_to_glyph(glyph, transform)
+              glyph.contours.each do |contour|
+                contour.points = contour.points.map do |pt|
+                  tx, ty = transform.apply(pt.x, pt.y)
+                  Fontisan::Ufo::Point.new(
+                    x: tx, y: ty,
+                    type: pt.type, smooth: pt.smooth
+                  )
+                end
+              end
+
+              glyph.components.map! do |component|
+                Fontisan::Ufo::Component.new(
+                  base_glyph: component.base_glyph,
+                  # Composition order: outer transform ∘ existing.
+                  # For a base-glyph point P, the component places it
+                  # at T_existing(P) in this glyph; the outer transform
+                  # then maps that to T_outer(T_existing(P)). So the
+                  # new component transformation is T_outer ∘ T_existing.
+                  transformation: compose(transform, component.transformation),
+                  identifier: component.identifier,
+                )
+              end
+            end
+
+            # Compose two affine transformations: result = outer ∘ inner
+            #   | outer.a outer.c outer.e |   | inner.a inner.c inner.e |
+            #   | outer.b outer.d outer.f | × | inner.b inner.d inner.f |
+            #   |   0        0        1   |   |   0        0        1   |
+            #
+            # Each input can be a Transformation, a 6-array, or nil
+            # (treated as identity — the default Component state).
+            # The result is always a Transformation.
+            def compose(outer, inner)
+              outer_t = coerce_transformation(outer)
+              inner_t = coerce_transformation(inner)
+
+              Fontisan::Ufo::Transformation.new(
+                a: outer_t.a * inner_t.a + outer_t.c * inner_t.b,
+                b: outer_t.b * inner_t.a + outer_t.d * inner_t.b,
+                c: outer_t.a * inner_t.c + outer_t.c * inner_t.d,
+                d: outer_t.b * inner_t.c + outer_t.d * inner_t.d,
+                e: outer_t.a * inner_t.e + outer_t.c * inner_t.f + outer_t.e,
+                f: outer_t.b * inner_t.e + outer_t.d * inner_t.f + outer_t.f,
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fontisan/ufo/compile/filters.rb

@@ -20,6 +20,14 @@ module Fontisan
                  "fontisan/ufo/compile/filters/decompose_components"
         autoload :FlattenComponents,
                  "fontisan/ufo/compile/filters/flatten_components"
+        autoload :Transformations,
+                 "fontisan/ufo/compile/filters/transformations"
+        autoload :SortContours,
+                 "fontisan/ufo/compile/filters/sort_contours"
+        autoload :PropagateAnchors,
+                 "fontisan/ufo/compile/filters/propagate_anchors"
+        autoload :RemoveOverlaps,
+                 "fontisan/ufo/compile/filters/remove_overlaps"
 
         # Filters that MUST run for TTF output (TrueType only
         # supports quadratic curves + clockwise outer winding).
@@ -38,6 +46,10 @@ module Fontisan
           cubic_to_quadratic: CubicToQuadratic,
           decompose_components: DecomposeComponents,
           flatten_components: FlattenComponents,
+          transformations: Transformations,
+          sort_contours: SortContours,
+          propagate_anchors: PropagateAnchors,
+          remove_overlaps: RemoveOverlaps,
         }.freeze
 
         # @param names [Array<Symbol>] filter names from REGISTRY

data/lib/fontisan/ufo/compile.rb

@@ -33,6 +33,7 @@ module Fontisan
       autoload :TtfCompiler,  "fontisan/ufo/compile/ttf_compiler"
       autoload :OtfCompiler,  "fontisan/ufo/compile/otf_compiler"
       autoload :Filters,      "fontisan/ufo/compile/filters"
+      autoload :FeatureWriters, "fontisan/ufo/compile/feature_writers"
       autoload :Fvar,         "fontisan/ufo/compile/fvar"
       autoload :Gpos,         "fontisan/ufo/compile/gpos"
       autoload :Gvar,         "fontisan/ufo/compile/gvar"

data/lib/fontisan/ufo/convert/to_dfont.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+
+module Fontisan
+  module Ufo
+    module Convert
+      # UFO → dfont (Mac OS resource-fork font container). Two-step:
+      #
+      #   1. Compile UFO → TTF/OTF in tmpdir.
+      #   2. Load + feed to Collection::DfontBuilder, which wraps the
+      #      SFNT binary in a Mac resource fork.
+      module ToDfont
+        # @param ufo [Fontisan::Ufo::Font]
+        # @param output_path [String]
+        # @param compiler [Symbol] :ttf (default) or :otf
+        # @return [String] the output_path
+        def self.convert(ufo, output_path:, compiler: :ttf, **_opts)
+          compiler_class = Convert::COMPILER_FOR_FORMAT[compiler.to_sym]
+          raise ArgumentError, "unknown intermediate compiler: #{compiler.inspect}" unless compiler_class
+
+          Dir.mktmpdir do |dir|
+            intermediate_path = File.join(dir, "intermediate#{ext_for(compiler)}")
+            compiler_class.new(ufo).compile(output_path: intermediate_path)
+
+            loaded = Fontisan::FontLoader.load(intermediate_path)
+            result = Fontisan::Collection::DfontBuilder.new([loaded]).build
+            File.binwrite(output_path, result[:binary])
+          end
+
+          output_path
+        end
+
+        def self.ext_for(compiler)
+          %i[otf otf2].include?(compiler) ? ".otf" : ".ttf"
+        end
+        private_class_method :ext_for
+      end
+    end
+  end
+end