fontisan 0.2.23 → 0.3.0

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

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the TrueType `glyf` + `loca` tables. Each glyph's
+      # outline is delta-encoded into the glyf table; loca is the
+      # offset index.
+      #
+      # For OTF output this module is NOT used — CFF takes its place.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/glyf
+      module GlyfLoca
+        # Flag bits (simple glyph)
+        FLAG_ON_CURVE       = 0x01
+        FLAG_X_SHORT        = 0x02
+        FLAG_Y_SHORT        = 0x04
+        FLAG_REPEAT         = 0x08
+        FLAG_X_IS_POSITIVE  = 0x10 # only meaningful if FLAG_X_SHORT
+        FLAG_Y_IS_POSITIVE  = 0x20 # only meaningful if FLAG_Y_SHORT
+        FLAG_OVERLAP_SIMPLE = 0x40
+
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [Hash<String, String>] {"glyf" => bytes, "loca" => bytes}
+        def self.build(_font, glyphs:)
+          glyf_bytes = +""
+          offsets = [0]
+
+          glyphs.each do |glyph|
+            glyf_bytes << encode_glyph(glyph)
+            glyf_bytes << "\x00" while glyf_bytes.bytesize.odd? # 2-byte align
+            offsets << glyf_bytes.bytesize
+          end
+
+          # Choose loca format based on the largest offset.
+          use_long = offsets.max > 0x1FFFE # 2 × uint16 max
+          loca_bytes =
+            if use_long
+              offsets.pack("N*")
+            else
+              offsets.map { |o| o / 2 }.pack("n*")
+            end
+
+          { "glyf" => glyf_bytes, "loca" => loca_bytes, :loca_format => use_long ? 1 : 0 }
+        end
+
+        # Encode a single glyph into glyf bytes. Empty glyphs (no
+        # contours, no components) produce zero bytes per spec.
+        def self.encode_glyph(glyph)
+          return "" if glyph.contours.empty? && glyph.components.empty?
+          return encode_composite(glyph) if glyph.composite?
+
+          encode_simple(glyph)
+        end
+
+        # Encode a simple (non-composite) glyph.
+        def self.encode_simple(glyph)
+          bbox = glyph.bbox
+          header = [
+            glyph.contours.size, # numberOfContours (int16)
+            bbox.x_min.to_i, bbox.y_min.to_i,
+            bbox.x_max.to_i, bbox.y_max.to_i
+          ].pack("nnnnn")
+          # NB: pack 'n' for int16 truncates negatives to unsigned 16-bit
+          # two's complement — which is what OpenType wants.
+
+          # endPtsOfContours (uint16[numContours])
+          end_points = +""
+          point_count = 0
+          glyph.contours.each do |contour|
+            point_count += contour.points.size
+            end_points << [point_count - 1].pack("n")
+          end
+
+          # instructions: empty for MVP
+          instructions = [0].pack("n")
+
+          flags, x_bytes, y_bytes = encode_points(glyph.contours)
+
+          header + end_points + instructions + flags + x_bytes + y_bytes
+        end
+
+        # Encode all points across contours into (flags, x_bytes, y_bytes).
+        # Per OpenType spec:
+        #   - SHORT bit set + POSITIVE bit set  → 1-byte positive value
+        #   - SHORT bit set + POSITIVE bit clear → 1-byte negative value
+        #   - SHORT bit clear + POSITIVE bit set → delta is 0 (no bytes)
+        #   - SHORT bit clear + POSITIVE bit clear → 2-byte signed value
+        def self.encode_points(contours)
+          flags = +""
+          x_bytes = +""
+          y_bytes = +""
+
+          prev_x = 0
+          prev_y = 0
+          contours.flat_map(&:points).each do |point|
+            dx = point.x.to_i - prev_x
+            dy = point.y.to_i - prev_y
+
+            flag = point.on_curve? ? FLAG_ON_CURVE : 0
+
+            # X coordinate
+            if dx.zero?
+              flag |= FLAG_X_IS_POSITIVE # "same as previous" — no bytes
+            elsif dx.between?(-255, 255)
+              flag |= FLAG_X_SHORT
+              flag |= FLAG_X_IS_POSITIVE if dx.positive?
+              x_bytes << [dx.abs].pack("C")
+            else
+              # SHORT not set, POSITIVE not set → 2-byte signed
+              x_bytes << [dx & 0xFFFF].pack("n")
+            end
+
+            # Y coordinate
+            if dy.zero?
+              flag |= FLAG_Y_IS_POSITIVE # "same as previous" — no bytes
+            elsif dy.between?(-255, 255)
+              flag |= FLAG_Y_SHORT
+              flag |= FLAG_Y_IS_POSITIVE if dy.positive?
+              y_bytes << [dy.abs].pack("C")
+            else
+              y_bytes << [dy & 0xFFFF].pack("n")
+            end
+
+            flags << [flag].pack("C")
+            prev_x = point.x.to_i
+            prev_y = point.y.to_i
+          end
+
+          [flags, x_bytes, y_bytes]
+        end
+
+        # Composite glyph encoding (component references with optional
+        # transformations). Out of scope for MVP — emits empty bytes.
+        def self.encode_composite(_glyph)
+          # TODO.full/07: implement composite glyph encoding when the
+          # spec needs it. For now, return empty (the glyph renders as
+          # nothing).
+          ""
+        end
+        private_class_method :encode_glyph, :encode_simple, :encode_points, :encode_composite
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `head` table from a UFO Font.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/head
+      module Head
+        MAGIC_NUMBER = 0x5F0F3CF5
+        DEFAULT_FLAGS = 0x000B
+        DEFAULT_LOWEST_REC_PPEM = 8
+        DEFAULT_FONT_DIRECTION_HINT = 2
+        DEFAULT_GLYPH_DATA_FORMAT = 0
+        LOCA_FORMAT_SHORT = 0
+        LOCA_FORMAT_LONG = 1
+        MAC_STYLE_REGULAR = 0
+        # Seconds between 1904-01-01 (Mac epoch) and 1970-01-01 (Unix epoch)
+        MAC_EPOCH_OFFSET = 2_082_844_800
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] (unused here;
+        #   bbox is computed by the caller for performance)
+        # @return [Fontisan::Tables::Head]
+        def self.build(font, glyphs:, units_per_em: nil, loca_format: LOCA_FORMAT_LONG)
+          bbox = font_bbox(font, glyphs)
+          Fontisan::Tables::Head.new(
+            version_raw: 0x00010000,
+            font_revision_raw: font_revision_fixed(font),
+            checksum_adjustment: 0, # patched by FontWriter
+            magic_number: MAGIC_NUMBER,
+            flags: DEFAULT_FLAGS,
+            units_per_em: units_per_em || font.info.units_per_em || 1000,
+            created_raw: time_to_longdatetime(font.info.created),
+            modified_raw: time_to_longdatetime(font.info.modified),
+            x_min: bbox[:x_min].to_i,
+            y_min: bbox[:y_min].to_i,
+            x_max: bbox[:x_max].to_i,
+            y_max: bbox[:y_max].to_i,
+            mac_style: MAC_STYLE_REGULAR,
+            lowest_rec_ppem: DEFAULT_LOWEST_REC_PPEM,
+            font_direction_hint: DEFAULT_FONT_DIRECTION_HINT,
+            index_to_loc_format: loca_format,
+            glyph_data_format: DEFAULT_GLYPH_DATA_FORMAT,
+          )
+        end
+
+        # Union bbox of every glyph's outline.
+        def self.font_bbox(_font, glyphs)
+          return { x_min: 0, y_min: 0, x_max: 0, y_max: 0 } if glyphs.empty?
+
+          bboxes = glyphs.filter_map(&:bbox)
+          return { x_min: 0, y_min: 0, x_max: 0, y_max: 0 } if bboxes.empty?
+
+          {
+            x_min: bboxes.map(&:x_min).min,
+            y_min: bboxes.map(&:y_min).min,
+            x_max: bboxes.map(&:x_max).max,
+            y_max: bboxes.map(&:y_max).max,
+          }
+        end
+        private_class_method :font_bbox
+
+        # Parse the UFO version string ("1.0" or "Version 1.0") into
+        # a 16.16 fixed-point int. Defaults to 1.0 on parse failure.
+        def self.font_revision_fixed(font)
+          version = [font.info.version_major, font.info.version_minor].compact
+          return 0x00010000 if version.empty?
+
+          major = font.info.version_major || 1
+          minor = font.info.version_minor || 0
+          ((major & 0xFFFF) << 16) | (minor & 0xFFFF)
+        end
+        private_class_method :font_revision_fixed
+
+        # UFO 3 stores `openTypeHeadCreated` as "YYYY/MM/DD HH:MM:SS".
+        # OpenType head.created/modified are LONGDATETIME seconds
+        # since 1904-01-01. If the UFO field is absent, use now.
+        def self.time_to_longdatetime(value)
+          return Time.now.to_i + MAC_EPOCH_OFFSET if value.nil?
+
+          require "time"
+          parsed = nil
+          begin
+            parsed = Time.iso8601(value.to_s)
+          rescue ArgumentError
+            begin
+              parsed = Time.parse(value.to_s)
+            rescue ArgumentError
+              parsed = Time.now
+            end
+          end
+          parsed.to_i + MAC_EPOCH_OFFSET
+        end
+        private_class_method :time_to_longdatetime
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `hhea` (horizontal header) table.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/hhea
+      module Hhea
+        VERSION_1_0 = 0x00010000
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+        # @return [Fontisan::Tables::Hhea]
+        def self.build(font, glyphs:)
+          info = font.info
+          widths = glyphs.map { |g| g.width.to_i }
+          Fontisan::Tables::Hhea.new(
+            version_raw: VERSION_1_0,
+            ascent: info.ascender || 800,
+            descent: info.descender || -200,
+            line_gap: info.open_type_hhea_line_gap || 0,
+            advance_width_max: widths.max || 0,
+            min_left_side_bearing: 0,
+            min_right_side_bearing: 0,
+            x_max_extent: widths.max || 0,
+            caret_slope_rise: 1,
+            caret_slope_run: 0,
+            caret_offset: 0,
+            metric_data_format: 0,
+            number_of_h_metrics: glyphs.size,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `hmtx` (horizontal metrics) table.
+      # One LongHorMetric per glyph (4 bytes each):
+      #   uint16 advanceWidth, int16 lsb
+      # No trailing "leftSideBearing" array (use numberOfHMetrics = numGlyphs).
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/hmtx
+      module Hmtx
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String] hmtx table bytes
+        def self.build(_font, glyphs:)
+          data = +""
+          glyphs.each do |glyph|
+            bbox = glyph.bbox
+            lsb = bbox ? bbox.x_min.to_i : 0
+            data << [glyph.width.to_i, lsb].pack("nn")
+          end
+          data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `maxp` (maximum profile) table.
+      # TrueType (0x00010000) carries 13 metrics; CFF (0x00005000)
+      # carries just num_glyphs. We pick the version based on which
+      # outline compiler is in use — caller passes `version:`.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/maxp
+      module Maxp
+        VERSION_TRUE_TYPE = 0x00010000
+        VERSION_OPEN_TYPE = 0x00005000
+
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+        # @param version [Integer] one of VERSION_TRUE_TYPE / VERSION_OPEN_TYPE
+        # @return [Fontisan::Tables::Maxp]
+        def self.build(_font, glyphs:, version: VERSION_OPEN_TYPE)
+          if version == VERSION_TRUE_TYPE
+            build_truetype(glyphs)
+          else
+            Fontisan::Tables::Maxp.new(
+              version_raw: VERSION_OPEN_TYPE,
+              num_glyphs: glyphs.size,
+            )
+          end
+        end
+
+        def self.build_truetype(glyphs)
+          max_points = glyphs.map(&:point_count).max || 0
+          max_contours = glyphs.map { |g| g.contours.size }.max || 0
+          max_components = glyphs.map { |g| g.components.size }.max || 0
+
+          Fontisan::Tables::Maxp.new(
+            version_raw: VERSION_TRUE_TYPE,
+            num_glyphs: glyphs.size,
+            max_points: max_points,
+            max_contours: max_contours,
+            max_composite_points: max_points,
+            max_composite_contours: max_contours,
+            max_zones: 2,
+            max_twilight_points: 0,
+            max_storage: 0,
+            max_function_defs: 0,
+            max_instruction_defs: 0,
+            max_stack_elements: 0,
+            max_size_of_instructions: 0,
+            max_component_elements: max_components,
+            max_component_depth: max_components.positive? ? 1 : 0,
+          )
+        end
+        private_class_method :build_truetype
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `name` table from UFO fontinfo data.
+      # Writes Windows-Unicode (platform 3, encoding 1) name records
+      # for the standard 6 name IDs (copyright, family, subfamily,
+      # unique ID, full name, version, PostScript name).
+      #
+      # BinData's Tables::Name structure doesn't make construction
+      # from a record list easy (it has a custom after_read_hook and
+      # a `rest :string_storage`); this builder produces the bytes
+      # directly so we don't fight the BinData shape.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/name
+      module Name
+        PLATFORM_WINDOWS_UNICODE = 3
+        ENCODING_WINDOWS_UNICODE_BMP = 1
+        LANGUAGE_WINDOWS_ENGLISH_US = 0x0409
+
+        # @param font [Fontisan::Ufo::Font]
+        # @return [String] the name table bytes
+        def self.build(font, **_opts)
+          records = default_records(font)
+          format0_bytes(records)
+        end
+
+        # @param font [Fontisan::Ufo::Font] (used without glyph info)
+        # @return [Array<Hash{name_id: Integer, value: String}>]
+        def self.default_records(font)
+          family = font.info.family_name || "Untitled"
+          subfamily = font.info.style_name || "Regular"
+          ps_name = font.info.postscript_font_name || "#{family}-#{subfamily}"
+          full_name = "#{family} #{subfamily}".strip
+          major = font.info.version_major || 0
+          minor = font.info.version_minor || 0
+          version_str = "Version #{major}.#{minor}"
+          unique_id = "#{family}-#{subfamily};#{version_str}"
+          copyright = font.info.copyright || ""
+
+          [
+            { name_id: 0, value: copyright }, # copyright
+            { name_id: 1, value: family },    # family
+            { name_id: 2, value: subfamily }, # subfamily
+            { name_id: 3, value: unique_id }, # unique ID
+            { name_id: 4, value: full_name }, # full name
+            { name_id: 5, value: version_str }, # version
+            { name_id: 6, value: ps_name }, # PostScript name
+          ]
+        end
+
+        def self.format0_bytes(records)
+          # Strings are stored UTF-16BE on disk (Windows Unicode).
+          encoded = records.map { |r| r[:value].encode("UTF-16BE").force_encoding("BINARY") }
+          storage = encoded.join
+          storage_offset = 6 + (records.size * 12)
+
+          header = [0, records.size, storage_offset].pack("nnn")
+          body = +""
+          offset = 0
+          records.zip(encoded).each do |r, bytes|
+            body << [
+              PLATFORM_WINDOWS_UNICODE,
+              ENCODING_WINDOWS_UNICODE_BMP,
+              LANGUAGE_WINDOWS_ENGLISH_US,
+              r[:name_id],
+              bytes.bytesize,
+              offset,
+            ].pack("nnnnnn")
+            offset += bytes.bytesize
+          end
+
+          header + body + storage
+        end
+        private_class_method :format0_bytes, :default_records
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `OS/2` table from UFO fontinfo data.
+      # Default version is 4 (modern). Most fields are 0 unless the
+      # UFO has explicit values.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/os2
+      module Os2
+        VERSION_DEFAULT = 4
+        WEIGHT_REGULAR = 400
+        WIDTH_NORMAL = 5
+        FS_SELECTION_REGULAR = 0x0040
+
+        # @param font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] used to compute
+        #   usFirstCharIndex/usLastCharIndex + xAvgCharWidth
+        # @return [Fontisan::Tables::Os2]
+        def self.build(font, glyphs:)
+          info = font.info
+          cp_min, cp_max = unicode_range(glyphs)
+          Fontisan::Tables::Os2.new(
+            version: VERSION_DEFAULT,
+            x_avg_char_width: avg_advance(glyphs),
+            us_weight_class: info.open_type_os2_weight_class || WEIGHT_REGULAR,
+            us_width_class: info.open_type_os2_width_class || WIDTH_NORMAL,
+            fs_type: 0,
+            y_subscript_x_size: 650,
+            y_subscript_y_size: 600,
+            y_subscript_x_offset: 0,
+            y_subscript_y_offset: 75,
+            y_superscript_x_size: 650,
+            y_superscript_y_size: 600,
+            y_superscript_x_offset: 0,
+            y_superscript_y_offset: 350,
+            y_strikeout_size: 50,
+            y_strikeout_position: 300,
+            s_family_class: 0,
+            panose: Array.new(10, 0),
+            ul_unicode_range1: 1, # Basic Latin
+            ul_unicode_range2: 0,
+            ul_unicode_range3: 0,
+            ul_unicode_range4: 0,
+            ach_vend_id: "NONE",
+            fs_selection: FS_SELECTION_REGULAR,
+            us_first_char_index: cp_min,
+            us_last_char_index: cp_max,
+            s_typo_ascender: info.ascender || 800,
+            s_typo_descender: info.descender || -200,
+            s_typo_line_gap: info.open_type_hhea_line_gap || 0,
+            us_win_ascent: info.ascender || 1000,
+            us_win_descent: -(info.descender || -200),
+            ul_code_page_range1: 1, # Latin 1
+            ul_code_page_range2: 0,
+            sx_height: info.x_height || 500,
+            s_cap_height: info.cap_height || 700,
+            us_default_char: 0,
+            us_break_char: 0x20,
+            us_max_context: 0,
+          )
+        end
+
+        def self.unicode_range(glyphs)
+          cps = glyphs.flat_map(&:unicodes).sort
+          return [0xFFFF, 0] if cps.empty?
+
+          [cps.first, cps.last]
+        end
+        private_class_method :unicode_range
+
+        def self.avg_advance(glyphs)
+          return 0 if glyphs.empty?
+
+          (glyphs.sum { |g| g.width.to_i } / glyphs.size.to_f).round
+        end
+        private_class_method :avg_advance
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # UFO → OTF. Uses CFF outlines (instead of TrueType glyf/loca).
+      # Maxp version 0.5 (no TrueType metrics); sfnt version OTTO.
+      #
+      # TODO.full/10: this currently emits a placeholder CFF table
+      # that satisfies the OTTO signature but does NOT yet encode
+      # real charstrings. Full CFF construction lands when TODO 10
+      # ships.
+      class OtfCompiler < BaseCompiler
+        SFNT_VERSION = SFNT_VERSION_OPEN_TYPE
+
+        def build_outline_tables
+          {
+            "CFF " => Cff.build(font, glyphs: font.glyphs.values),
+          }
+        end
+
+        def compile(output_path:)
+          glyphs = font.glyphs.values
+
+          tables = {
+            "head" => Head.build(font, glyphs: glyphs, loca_format: Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(font, glyphs: glyphs),
+            "maxp" => Maxp.build(font, glyphs: glyphs, version: Maxp::VERSION_OPEN_TYPE),
+            "OS/2" => Os2.build(font, glyphs: glyphs),
+            "name" => Name.build(font),
+            "post" => Post.build(font),
+            "hmtx" => Hmtx.build(font, glyphs: glyphs),
+            "cmap" => Cmap.build(font, glyphs: glyphs),
+            "CFF " => Cff.build(font, glyphs: glyphs),
+          }
+
+          write(tables, output_path)
+          output_path
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `post` (PostScript name) table.
+      # Default version is 3.0 (no per-glyph names; smallest).
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/post
+      module Post
+        VERSION_3_0_RAW = 0x00030000
+
+        # @param _font [Fontisan::Ufo::Font] italic angle + underline
+        #   read from info, but everything else is zero (no hinting)
+        # @return [String] the post table bytes (32 bytes for v3.0)
+        def self.build(font, **_opts)
+          italic_angle = font.info.italic_angle || 0.0
+          [
+            VERSION_3_0_RAW,                       # version 3.0
+            (italic_angle * 0x10000).to_i,         # italicAngle (Fixed 16.16)
+            -100,                                  # underlinePosition (FUnits)
+            50,                                    # underlineThickness
+            0,                                     # isFixedPitch
+            0,                                     # minMemType42
+            0,                                     # maxMemType42
+            0,                                     # minMemType1
+            0, # maxMemType1
+          ].pack("NNnnNNNNN")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # UFO → TTF. Same tables as the OTF compiler plus glyf + loca
+      # (no CFF). Maxp version 1.0 carries the TrueType metrics.
+      #
+      # Before glyf encoding, the TTF-required filters run:
+      #   - cubic_to_quadratic (TTF only supports quadratic Beziers)
+      #   - reverse_contour_direction (TTF winding convention)
+      class TtfCompiler < BaseCompiler
+        SFNT_VERSION = SFNT_VERSION_TRUE_TYPE
+
+        def compile(output_path:)
+          glyphs = font.glyphs.values
+
+          # Deep-clone glyphs so filters don't mutate the source UFO.
+          filtered = clone_glyphs(glyphs)
+          Filters.apply(Filters::TTF_REQUIRED, filtered)
+
+          glyf_loca = GlyfLoca.build(font, glyphs: filtered)
+          loca_format = glyf_loca.delete(:loca_format)
+
+          tables = {
+            "head" => Head.build(font, glyphs: filtered,
+                                       loca_format: loca_format || Head::LOCA_FORMAT_LONG),
+            "hhea" => Hhea.build(font, glyphs: filtered),
+            "maxp" => Maxp.build(font, glyphs: filtered,
+                                       version: Maxp::VERSION_TRUE_TYPE),
+            "OS/2" => Os2.build(font, glyphs: filtered),
+            "name" => Name.build(font),
+            "post" => Post.build(font),
+            "hmtx" => Hmtx.build(font, glyphs: filtered),
+            "cmap" => Cmap.build(font, glyphs: filtered),
+            "glyf" => glyf_loca["glyf"],
+            "loca" => glyf_loca["loca"],
+          }
+
+          write(tables, output_path)
+          output_path
+        end
+
+        private
+
+        def clone_glyphs(glyphs)
+          glyphs.map { |g| clone_glyph(g) }
+        end
+
+        def clone_glyph(original)
+          copy = Ufo::Glyph.new(name: original.name)
+          copy.width = original.width
+          copy.height = original.height
+          original.unicodes.each { |cp| copy.add_unicode(cp) }
+          original.contours.each { |c| copy.add_contour(clone_contour(c)) }
+          original.components.each { |c| copy.add_component(c) }
+          copy
+        end
+
+        def clone_contour(original)
+          points = original.points.map do |p|
+            Ufo::Point.new(x: p.x, y: p.y, type: p.type, smooth: p.smooth)
+          end
+          Ufo::Contour.new(points)
+        end
+      end
+    end
+  end
+end