fontisan 0.2.22 → 0.3.0

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Builds the OpenType `cmap` (character-to-glyph mapping) table.
+      # Emits two subtables:
+      #   - Format 4 (BMP), platform 3 encoding 1 (Windows Unicode BMP)
+      #   - Format 12 (full Unicode), platform 3 encoding 10 (Windows Unicode full)
+      #
+      # Both subtables share the same segment list (capped to BMP for
+      # format 4); format 4 is required by Windows even though format
+      # 12 is more capable.
+      # @see https://learn.microsoft.com/en-us/typography/opentype/spec/cmap
+      module Cmap
+        PLATFORM_WINDOWS = 3
+        ENCODING_WINDOWS_BMP = 1
+        ENCODING_WINDOWS_FULL = 10
+
+        # @param _font [Fontisan::Ufo::Font]
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] in gid order
+        # @return [String] cmap table bytes
+        def self.build(_font, glyphs:)
+          mappings = {}
+          glyphs.each_with_index do |glyph, gid|
+            glyph.unicodes.each do |cp|
+              mappings[cp] = gid unless mappings.key?(cp)
+            end
+          end
+
+          subtable_bmp = format4_subtable(mappings.reject { |cp, _| cp > 0xFFFF })
+          subtable_full = format12_subtable(mappings)
+
+          header_size = 4 + (2 * 8) # version + numTables + 2 records
+          offset_bmp = header_size
+          offset_full = header_size + subtable_bmp.bytesize
+
+          header = [0, 2].pack("nn")
+          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_BMP, offset_bmp)
+          header << subtable_record(PLATFORM_WINDOWS, ENCODING_WINDOWS_FULL, offset_full)
+          header + subtable_bmp + subtable_full
+        end
+
+        def self.subtable_record(platform_id, encoding_id, offset)
+          [platform_id, encoding_id, offset].pack("nnN")
+        end
+
+        # Group adjacent (cp, gid) pairs into contiguous ranges where
+        # both cp and gid advance by 1 each step.
+        # @return [Array<Range>] Array of inclusive cp ranges
+        def self.build_segments(cp_to_gid)
+          sorted = cp_to_gid.sort
+          return [] if sorted.empty?
+
+          segments = []
+          seg_start_cp, prev_gid = sorted.first
+          prev_cp = seg_start_cp
+
+          sorted[1..].each do |cp, gid|
+            contiguous = cp == prev_cp + 1 && gid == prev_gid + 1
+            unless contiguous
+              segments << (seg_start_cp..prev_cp)
+              seg_start_cp = cp
+            end
+            prev_cp = cp
+            prev_gid = gid
+          end
+          segments << (seg_start_cp..prev_cp)
+          segments
+        end
+
+        # Format 4 segment-encoded cmap subtable for the BMP.
+        def self.format4_subtable(mappings)
+          segments = build_segments(mappings) + [0xFFFF..0xFFFF] # sentinel
+          seg_count = segments.size
+          search_range = largest_pow2_le(seg_count) * 2
+          entry_selector = (Math.log([1, search_range / 2].max) / Math.log(2)).to_i
+          range_shift = seg_count * 2 - search_range
+
+          end_codes = segments.map(&:end)
+          start_codes = segments.map(&:begin)
+          # id_delta[i] = (gid_at_start - start_code) mod 65536
+          id_deltas = segments.map do |range|
+            start_cp = range.begin
+            gid = mappings.fetch(start_cp, 0)
+            # For the sentinel segment (0xFFFF..0xFFFF) with no mapping,
+            # delta 1 maps 0xFFFF → gid 0 (.notdef).
+            gid_delta = start_cp == 0xFFFF && gid.zero? ? 1 : (gid - start_cp)
+            gid_delta & 0xFFFF
+          end
+
+          body = +""
+          body << [seg_count * 2, search_range, entry_selector, range_shift].pack("nnnn")
+          body << end_codes.pack("n*")
+          body << [0].pack("n") # reservedPad
+          body << start_codes.pack("n*")
+          body << id_deltas.pack("n*")
+          body << Array.new(seg_count, 0).pack("n*") # idRangeOffset (all 0)
+
+          length = 14 + body.bytesize # 14-byte header
+          [4, length, 0].pack("nnn") + body
+        end
+
+        # Format 12 sparse-coverage subtable for full Unicode.
+        def self.format12_subtable(mappings)
+          segments = build_segments(mappings)
+
+          body = +""
+          segments.each do |range|
+            start_gid = mappings.fetch(range.begin, 0)
+            body << [range.begin, range.end, start_gid].pack("NNN")
+          end
+
+          length = 16 + body.bytesize # 16-byte header
+          [12, 0].pack("nn") + [length, 0, segments.size].pack("NNN") + body
+        end
+
+        def self.largest_pow2_le(n)
+          return 0 if n <= 0
+
+          1 << (n.bit_length - 1)
+        end
+        private_class_method :subtable_record, :build_segments,
+                             :format4_subtable, :format12_subtable,
+                             :largest_pow2_le
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Converts cubic Bezier curves to quadratic. TrueType outlines
+        # only support quadratic Beziers; UFO sources typically use
+        # cubic. This filter walks each contour, finds cubic segments
+        # (two consecutive off-curve points followed by an on-curve),
+        # and replaces them with one or more quadratic approximations.
+        #
+        # Algorithm (fontTools-compatible):
+        #   For cubic (P0, C1, C2, P3):
+        #     Q1 = (3*C1 - P0) / 2
+        #     Q2 = (3*C2 - P3) / 2
+        #     Q  = midpoint(Q1, Q2)
+        #     Error ≈ |Q1 - Q2| / 3
+        #     If error ≤ tolerance: emit one quadratic (P0, Q, P3)
+        #     Else: subdivide at t=0.5, recurse each half.
+        module CubicToQuadratic
+          DEFAULT_TOLERANCE = 1.0
+
+          # @param glyphs [Array<Fontisan::Ufo::Glyph>]
+          # @param tolerance [Float] max deviation in font units
+          # @return [Array<Fontisan::Ufo::Glyph>] the same array, mutated
+          def self.run(glyphs, tolerance: DEFAULT_TOLERANCE, **_opts)
+            glyphs.each do |glyph|
+              glyph.contours.each_with_index do |contour, _ci|
+                contour.points = convert_contour(contour.points, tolerance)
+              end
+            end
+            glyphs
+          end
+
+          # Walk a contour's point list and replace cubic segments
+          # with quadratic approximations. Preserves on-curve points
+          # (lines, moves); only touches (off, off, on) triplets.
+          #
+          # @param points [Array<Fontisan::Ufo::Point>]
+          # @param tolerance [Float]
+          # @return [Array<Fontisan::Ufo::Point>] new point array
+          def self.convert_contour(points, tolerance)
+            return points if points.size < 4
+
+            result = []
+            i = 0
+
+            while i < points.size
+              # Check if we have a cubic segment: off, off, on-curve
+              if i + 2 < points.size &&
+                  off_curve?(points[i]) &&
+                  off_curve?(points[i + 1]) &&
+                  on_curve?(points[i + 2])
+                # The previous on-curve point (P0) is the last on-curve
+                # before this segment. If result is empty, use the last
+                # point in the original contour (contour wraps around).
+                p0 = result.empty? ? last_on_curve(points) : result.last
+
+                if p0
+                  c1 = points[i]
+                  c2 = points[i + 1]
+                  p3 = points[i + 2]
+
+                  quads = subdivide_cubic(p0, c1, c2, p3, tolerance)
+                  quads.each { |q| result << q }
+                  i += 3
+                else
+                  result << points[i]
+                  i += 1
+                end
+              else
+                result << points[i]
+                i += 1
+              end
+            end
+
+            result
+          end
+
+          # Recursive cubic-to-quadratic subdivision.
+          # Returns a list of Points: alternating off-curve control
+          # points and on-curve endpoints.
+          def self.subdivide_cubic(p0, c1, c2, p3, tolerance)
+            q1x = (3.0 * c1.x - p0.x) / 2.0
+            q1y = (3.0 * c1.y - p0.y) / 2.0
+            q2x = (3.0 * c2.x - p3.x) / 2.0
+            q2y = (3.0 * c2.y - p3.y) / 2.0
+
+            # Error metric: half the distance between Q1 and Q2
+            dx = (q1x - q2x).abs
+            dy = (q1y - q2y).abs
+            error = [dx, dy].max / 3.0
+
+            if error <= tolerance
+              # Single quadratic approximation
+              mid_x = (q1x + q2x) / 2.0
+              mid_y = (q1y + q2y) / 2.0
+              [
+                Point.new(x: mid_x, y: mid_y, type: "offcurve"),
+                Point.new(x: p3.x, y: p3.y, type: p3.type, smooth: p3.smooth),
+              ]
+            else
+              # Subdivide at t=0.5
+              midpoint_on_cubic(p0, c1, c2, p3, 0.5)
+
+              # Left half: P0, L1, L2, M
+              Point.new(x: (p0.x + c1.x) / 2.0,
+                        y: (p0.y + c1.y) / 2.0, type: "offcurve")
+              Point.new(x: (c1.x + c2.x) / 4.0 + (p0.x + c1.x) / 4.0,
+                        y: (c1.y + c2.y) / 4.0 + (p0.y + c1.y) / 4.0,
+                        type: "offcurve")
+              # Actually, proper De Casteljau subdivision:
+              l1x = (p0.x + c1.x) / 2.0
+              l1y = (p0.y + c1.y) / 2.0
+              mx = (c1.x + c2.x) / 2.0
+              my = (c1.y + c2.y) / 2.0
+              r2x = (c2.x + p3.x) / 2.0
+              r2y = (c2.y + p3.y) / 2.0
+              l2x = (l1x + mx) / 2.0
+              l2y = (l1y + my) / 2.0
+              r1x = (mx + r2x) / 2.0
+              r1y = (my + r2y) / 2.0
+              mid_x = (l2x + r1x) / 2.0
+              mid_y = (l2y + r1y) / 2.0
+
+              left_p0 = p0
+              left_c1 = Point.new(x: l1x, y: l1y, type: "offcurve")
+              left_c2 = Point.new(x: l2x, y: l2y, type: "offcurve")
+              left_p3 = Point.new(x: mid_x, y: mid_y, type: "qcurve")
+
+              right_p0 = left_p3
+              right_c1 = Point.new(x: r1x, y: r1y, type: "offcurve")
+              right_c2 = Point.new(x: r2x, y: r2y, type: "offcurve")
+              right_p3 = p3
+
+              left = subdivide_cubic(left_p0, left_c1, left_c2, left_p3, tolerance)
+              right = subdivide_cubic(right_p0, right_c1, right_c2, right_p3, tolerance)
+
+              # Drop the duplicated midpoint point between halves
+              left + right
+            end
+          end
+
+          # Evaluate a point on a cubic Bezier at parameter t.
+          def self.midpoint_on_cubic(p0, c1, c2, p3, t)
+            mt = 1.0 - t
+            x = mt * mt * mt * p0.x + 3 * mt * mt * t * c1.x +
+              3 * mt * t * t * c2.x + t * t * t * p3.x
+            y = mt * mt * mt * p0.y + 3 * mt * mt * t * c1.y +
+              3 * mt * t * t * c2.y + t * t * t * p3.y
+            Point.new(x: x, y: y, type: "qcurve")
+          end
+
+          def self.last_on_curve(points)
+            points.reverse_each.find { |p| on_curve?(p) }
+          end
+
+          def self.on_curve?(point)
+            ["line", "move", "curve", "qcurve"].include?(point.type)
+          end
+
+          def self.off_curve?(point)
+            point.type == "offcurve"
+          end
+
+          private_class_method :convert_contour, :subdivide_cubic,
+                               :midpoint_on_cubic, :last_on_curve,
+                               :on_curve?, :off_curve?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Decomposes composite glyphs (those with Components) into
+        # simple glyphs by resolving each component reference to its
+        # base glyph's contours and applying the component's
+        # transformation matrix.
+        #
+        # For MVP: components are silently dropped (the glyph retains
+        # its own contours but loses component-derived outlines).
+        # Full resolution requires the full glyph-name → glyph lookup
+        # that the compiler provides. TODO.full/07b will wire this.
+        module DecomposeComponents
+          def self.run(glyphs, **_opts)
+            glyphs.each do |glyph|
+              # Drop components; keep contours only.
+              # Full implementation would:
+              #   1. Look up each component's base glyph by name
+              #   2. Clone its contours
+              #   3. Apply the component's Transformation matrix
+              #   4. Merge into this glyph's contours
+              glyph.components.clear
+            end
+            glyphs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Flattens nested component references. If glyph A references
+        # glyph B which references glyph C, this filter makes A
+        # directly reference C (one level deep only).
+        #
+        # For MVP: same as DecomposeComponents — components are
+        # cleared. Full implementation lands with TODO.full/07b.
+        module FlattenComponents
+          def self.run(glyphs, **_opts)
+            glyphs.each { |g| g.components.clear }
+            glyphs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      module Filters
+        # Reverses the point order in every contour. TrueType fonts
+        # use clockwise winding for outer contours (opposite of the
+        # PostScript/UFO convention). Applying this filter before
+        # TTF compilation ensures correct glyph rendering.
+        module ReverseContourDirection
+          # @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 do |contour|
+                contour.points.reverse!
+              end
+            end
+            glyphs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Fontisan
+  module Ufo
+    module Compile
+      # Glyph-processing filters applied between the UFO model and the
+      # binary table compilers. Each filter is a stateless module
+      # with `.run(glyphs, **opts)` that mutates the glyph list
+      # (or returns a new one).
+      #
+      # OCP: adding a filter = new module + one REGISTRY entry.
+      # The compiler picks which filters to run based on the output
+      # format — not a switch statement in compiler code.
+      module Filters
+        autoload :ReverseContourDirection,
+                 "fontisan/ufo/compile/filters/reverse_contour_direction"
+        autoload :CubicToQuadratic,
+                 "fontisan/ufo/compile/filters/cubic_to_quadratic"
+        autoload :DecomposeComponents,
+                 "fontisan/ufo/compile/filters/decompose_components"
+        autoload :FlattenComponents,
+                 "fontisan/ufo/compile/filters/flatten_components"
+
+        # Filters that MUST run for TTF output (TrueType only
+        # supports quadratic curves + clockwise outer winding).
+        TTF_REQUIRED = %i[
+          cubic_to_quadratic
+          reverse_contour_direction
+        ].freeze
+
+        # Filters that MUST run for OTF output (CFF handles cubic
+        # natively, so no curve conversion needed; winding is
+        # already correct for PostScript).
+        OTF_REQUIRED = [].freeze
+
+        REGISTRY = {
+          reverse_contour_direction: ReverseContourDirection,
+          cubic_to_quadratic: CubicToQuadratic,
+          decompose_components: DecomposeComponents,
+          flatten_components: FlattenComponents,
+        }.freeze
+
+        # @param names [Array<Symbol>] filter names from REGISTRY
+        # @param glyphs [Array<Fontisan::Ufo::Glyph>] glyphs to filter
+        # @param opts [Hash] per-filter options
+        # @return [Array<Fontisan::Ufo::Glyph>] the (possibly mutated) glyphs
+        def self.apply(names, glyphs, **)
+          Array(names).reduce(glyphs) do |current, name|
+            klass = REGISTRY[name.to_sym] or
+              raise ArgumentError, "unknown filter: #{name.inspect}"
+            klass.run(current, **)
+          end
+        end
+      end
+    end
+  end
+end

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