alhena 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce5de3849b4aa2df47ea56cdeb9973a32292f141bc112dee2ea982cb57a34458
-  data.tar.gz: 5a8511d09bdd3ba79634eebe8ea808fd90e8381a146e213b600315a81551d4d7
+  metadata.gz: 387d1d13d4023f565425ad659f94aaf572e7110e07eb029fcb7e17a8e20a7aee
+  data.tar.gz: 7828025fb60b1a932e7d2517705ba8d5c5b98563aba4d6fc8ca958d976d7bd31
 SHA512:
-  metadata.gz: 8bdac70ca3bb5b3f5e9b36478bc0abab8323efe5b5127788ceffb0ef4bc8d294a3ed14b63e807834618888d9e87e8ffbf4b5dc9d2f8a65ee8ecc833938bb7f54
-  data.tar.gz: a8c8e4713dedce77ea623faaf562e1014a523738798bb96a823463aa94f5e81334286bf7bcd4f9f1609941585032a357a56df269d4c182ca4facc2fb9bcd55f7
+  metadata.gz: 3a50ec152fed8ae539ee365514ff7759f74675f45fb446412f7d2c9b268f50a4ee0bbf06fed77700b135b23447152438a489c126b94521da70e28af1ed51aed8
+  data.tar.gz: 345d93a28236e523e1860db99d779a557676b15ccca644a8794d0713ab447cc591b604d60ad9d2dab06fb489c470e9ab19fa5037ff685692290729cfbf44fac0

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.0 — 2026-09-23
+
+- Expose font bounds, glyph IDs, advances, and Unicode mappings for font consumers.
+- Build self-contained TrueType subsets with composite glyph dependencies and valid checksums.
+- Preserve complete CFF fonts when building PDF-compatible font data.
+- Convert supported static name-keyed CFF1 fonts to CID-keyed subsets for PDF embedding.
+
 ## 0.2.1 — 2026-09-21
 
 - Add a deterministic rasterized-glyph demo image and regeneration task.

data/README.md

@@ -28,6 +28,7 @@ Alhena reads TrueType, OpenType, and TTC fonts, extracts their outlines, and ras
 ## Features
 
 - TrueType, OpenType CFF1/CFF2, and TTC font parsing
+- TrueType and supported CFF1 subset construction and glyph-to-Unicode lookup for PDF embedding
 - Analytic grayscale and LCD rasterization with subpixel positioning
 - Variable font axes, outlines, and metrics
 - Fast text advance measurement without rasterization
@@ -164,6 +165,10 @@ rgba = color&.rgba
 
 Alhena does not provide TrueType hinting, shaping, GSUB/GPOS, kerning, system font discovery, COLR v1 paint graphs, avar v2, JPEG/TIFF decoding, or MVAR global metric variation. Use `embedded_bitmap` to retrieve unsupported sbix image formats for external decoding.
 
+`Alhena::Subset.build(font, glyph_ids)` creates a compact TrueType font containing the requested glyphs and any composite-glyph dependencies, or a compact static name-keyed CFF1 font for the supported CFF subset described below. CFF2, CID-keyed CFF, predefined CFF charsets, custom CFF encodings, and variable CFF1 fonts are rejected with `Alhena::UnsupportedFont`; they are never silently returned unchanged. CFF subsets retain selected outlines, Unicode mappings, horizontal metrics, and the original subroutine indexes, but omit layout, shaping, color, and vertical-metric tables whose glyph references are not rewritten.
+
+For PDF consumers, `Alhena::Subset.build_cid(font, glyph_ids)` converts a static, name-keyed CFF1 font to a compact CID-keyed CFF1 program. Array order assigns CIDs (the first glyph must be glyph 0), and repeated glyph IDs are allowed. It intentionally rejects CFF2, variable, and already CID-keyed source fonts.
+
 Unknown formats raise `Alhena::UnsupportedFont`; malformed bounds and structures raise `Alhena::InvalidFont`. Bitmap allocations are limited to 16,777,216 samples.
 
 ## Performance

data/lib/alhena/cff.rb

@@ -17,9 +17,11 @@ module Alhena
       else
         names, at = read_index(header_size)
         tops, at = read_index(at)
-        _strings, at = read_index(at)
+        @strings, at = read_index(at)
         @global_subrs, = read_index(at)
         raise InvalidFont, "OpenType CFF must contain one font" unless names.size == 1 && tops.size == 1
+        @name_objects, @top_dictionary = names, tops.first
+        @top_dictionary_entries = dictionary_entries(@top_dictionary)
         @top = parse_dictionary(tops.first)
       end
       raise UnsupportedFont, "only Type 2 charstrings are supported" unless @top.fetch(1206, [2]).first == 2
@@ -28,9 +30,11 @@ module Alhena
       raise InvalidFont, "invalid CFF FontMatrix" unless @matrix.size == 6
       if @top.key?(1230) || @version == 2
         dictionaries, = read_index(@top.fetch(1236).first)
+        @private_records = []
         @privates = dictionaries.map { |entry| read_private_dict(parse_dictionary(entry)) }
         @fd_select = @top[1237]&.first
       else
+        @private_records = []
         @privates = [read_private_dict(@top)]
         @privates.first[3] = nil
       end
@@ -49,6 +53,22 @@ module Alhena
       path.transform(@matrix.map { |n| n * @units_per_em })
     end
 
+    # Rebuild a name-keyed CFF1 table with only the requested charstrings.
+    def subset(glyphs)
+      Subsetter.new(glyphs, data: @data, version: @version, top: @top,
+        top_dictionary_entries: @top_dictionary_entries, name_objects: @name_objects,
+        strings: @strings, global_subrs: @global_subrs, charstrings: @charstrings,
+        private_records: @private_records).build
+    end
+
+    # Rebuild a single-FD CID-keyed CFF1 program in the requested CID order.
+    def subset_cid(glyphs)
+      Subsetter.new(glyphs, data: @data, version: @version, top: @top,
+        top_dictionary_entries: @top_dictionary_entries, name_objects: @name_objects,
+        strings: @strings, global_subrs: @global_subrs, charstrings: @charstrings,
+        private_records: @private_records).build_cid
+    end
+
     private
 
     def read_index(at)
@@ -73,7 +93,7 @@ module Alhena
       data, stack, result = Binary.new(bytes), [], {}
       while data.position < data.size
         byte = data.u8
-        if byte >= 32 || [28, 29, 30].include?(byte)
+        if byte >= 32 || [28, 29, 30, 255].include?(byte)
           stack << read_number(data, byte)
           raise InvalidFont, "CFF DICT operand overflow" if stack.length > (@version == 2 ? 513 : 48)
         else
@@ -105,6 +125,7 @@ module Alhena
             raise InvalidFont, "oversized CFF real" if value.size > 64
           end
         end
+      when 255 then data.fixed
       when 32..246 then byte - 139
       when 247..250 then (byte - 247) * 256 + data.u8 + 108
       when 251..254 then -(byte - 251) * 256 - data.u8 - 108
@@ -116,11 +137,32 @@ module Alhena
 
     def read_private_dict(dict)
       length, offset = dict.fetch(18, [0, 0])
-      private_data = parse_dictionary(@data.bytes(offset, length))
+      raw = @data.bytes(offset, length)
+      private_data = parse_dictionary(raw)
       local = private_data.key?(19) ? read_index(offset + private_data[19].first).first : []
+      @private_records << { entries: dictionary_entries(raw), subrs: local } if @version == 1
       [local, private_data.fetch(20, [0]).first, private_data.fetch(21, [0]).first, dict[1207], private_data.fetch(22, [0]).first]
     end
 
+    def dictionary_entries(bytes)
+      data, operands, entries = Binary.new(bytes), [], []
+      while data.position < data.size
+        start = data.position
+        byte = data.u8
+        if byte >= 32 || [28, 29, 30, 255].include?(byte)
+          value = read_number(data, byte)
+          operands << [bytes.byteslice(start...data.position), value]
+        else
+          operator = byte == 12 ? 1200 + data.u8 : byte
+          entries << [operator, operands]
+          operands = []
+        end
+      end
+      raise InvalidFont, "unterminated CFF DICT operands" unless operands.empty?
+
+      entries
+    end
+
     def font_dict_index(glyph)
       return 0 unless @fd_select
       case @data.u8(@fd_select)

data/lib/alhena/cff_subset.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Alhena
+  class CFF
+    class Subsetter
+      def initialize(glyphs, data:, version:, top:, top_dictionary_entries:, name_objects:, strings:,
+                     global_subrs:, charstrings:, private_records:)
+        @glyphs, @data, @version, @top = glyphs, data, version, top
+        @top_dictionary_entries, @name_objects, @strings = top_dictionary_entries, name_objects, strings
+        @global_subrs, @charstrings, @private_records = global_subrs, charstrings, private_records
+      end
+
+      def build
+        raise UnsupportedFont, "CFF subsetting requires CFF1" unless @version == 1
+        raise UnsupportedFont, "CID-keyed CFF subsetting is unsupported" if @top.key?(1230) || @top.key?(1236) || @top.key?(1237)
+        raise UnsupportedFont, "CFF predefined charsets cannot be subset" if @top.fetch(15, [0]).first < 3
+        raise UnsupportedFont, "custom CFF encodings cannot be subset" if @top.fetch(16, [0]).first > 1
+        raise ArgumentError, "glyphs must be a nonempty Array" unless @glyphs.is_a?(Array) && !@glyphs.empty?
+        raise ArgumentError, "CFF glyph out of range" unless @glyphs.all? { |glyph| glyph.is_a?(Integer) && glyph.between?(0, @charstrings.length - 1) }
+
+        glyphs = @glyphs.uniq.sort
+        raise ArgumentError, "CFF subset must include glyph 0" unless glyphs.first.zero?
+        private_record = @private_records.first
+        name_index, string_index = encode_index(@name_objects), encode_index(@strings)
+        global_subrs_index = encode_index(@global_subrs)
+        charstrings_index = encode_index(glyphs.map { |glyph| @charstrings.fetch(glyph) })
+        charset = subset_charset(glyphs)
+        local_subrs = private_record ? private_record[:subrs] : []
+        has_local_subrs = private_record && private_record[:entries].any? { |operator, _| operator == 19 }
+        local_subrs_index = has_local_subrs ? encode_index(local_subrs) : "".b
+        private_dictionary = encode_private_dictionary(private_record, has_local_subrs)
+        header = @data.bytes(0, @data.u8(2))
+        base_offset = header.bytesize + name_index.bytesize + string_index.bytesize + global_subrs_index.bytesize
+        charset_offset = charstrings_offset = private_offset = 0
+
+        12.times do
+          top_index = encode_index([encode_top_dictionary(charset_offset, charstrings_offset, private_offset, private_dictionary.bytesize)])
+          offsets = [base_offset + top_index.bytesize]
+          offsets << offsets[0] + charset.bytesize
+          offsets << offsets[1] + charstrings_index.bytesize
+          break if offsets == [charset_offset, charstrings_offset, private_offset]
+
+          charset_offset, charstrings_offset, private_offset = offsets
+        end
+
+        top_index = encode_index([encode_top_dictionary(charset_offset, charstrings_offset, private_offset, private_dictionary.bytesize)])
+        offsets = [base_offset + top_index.bytesize]
+        offsets << offsets[0] + charset.bytesize
+        offsets << offsets[1] + charstrings_index.bytesize
+        raise InvalidFont, "CFF subset offsets did not converge" unless offsets == [charset_offset, charstrings_offset, private_offset]
+
+        header + name_index + top_index + string_index + global_subrs_index + charset +
+          charstrings_index + private_dictionary + local_subrs_index
+      end
+
+      def build_cid
+        raise UnsupportedFont, "CFF CID conversion requires name-keyed CFF1" unless @version == 1 && !@top.key?(1230) && !@top.key?(1236) && !@top.key?(1237)
+        raise ArgumentError, "glyphs must be a nonempty Array" unless @glyphs.is_a?(Array) && !@glyphs.empty?
+        raise ArgumentError, "CFF glyph out of range" unless @glyphs.all? { |glyph| glyph.is_a?(Integer) && glyph.between?(0, @charstrings.length - 1) }
+        raise ArgumentError, "CID 0 must map to glyph 0" unless @glyphs.first.zero?
+        raise ArgumentError, "CID font cannot exceed 65,536 glyphs" if @glyphs.length > 65_536
+
+        private_record = @private_records.first
+        has_local_subrs = private_record && private_record[:entries].any? { |operator, _| operator == 19 }
+        private_dictionary = private_record ? encode_private_dictionary(private_record, has_local_subrs) : "".b
+        local_subrs_index = has_local_subrs ? encode_index(private_record[:subrs]) : "".b
+        charset = [0].pack("C") + (1...@glyphs.length).to_a.pack("n*")
+        charstrings_index = encode_index(@glyphs.map { |glyph| @charstrings.fetch(glyph) })
+        fd_select = "\0".b * (@glyphs.length + 1)
+        header = @data.bytes(0, @data.u8(2))
+        name_index = encode_index(@name_objects)
+        string_index = encode_index(@strings + ["Adobe", "Identity"])
+        global_subrs_index = encode_index(@global_subrs)
+        base_offset = header.bytesize + name_index.bytesize + string_index.bytesize + global_subrs_index.bytesize
+        offsets = Array.new(5, 0)
+
+        16.times do
+          top_index = encode_index([encode_cid_top_dictionary(offsets)])
+          cursor = base_offset + top_index.bytesize
+          charset_offset = cursor
+          cursor += charset.bytesize
+          charstrings_offset = cursor
+          cursor += charstrings_index.bytesize
+          fd_select_offset = cursor
+          cursor += fd_select.bytesize
+          fd_array_offset = cursor
+          fd_dictionary = encode_dictionary([], private_record ? {18 => [private_dictionary.bytesize, offsets[4]]} : {})
+          fd_array = encode_index([fd_dictionary])
+          private_offset = fd_array_offset + fd_array.bytesize
+          current = [charset_offset, charstrings_offset, fd_select_offset, fd_array_offset, private_offset]
+          break if current == offsets
+
+          offsets = current
+        end
+
+        top_index = encode_index([encode_cid_top_dictionary(offsets)])
+        fd_dictionary = encode_dictionary([], private_record ? {18 => [private_dictionary.bytesize, offsets[4]]} : {})
+        fd_array = encode_index([fd_dictionary])
+        charset_offset, charstrings_offset, fd_select_offset, fd_array_offset, private_offset = offsets
+        cursor = base_offset + top_index.bytesize
+        expected = [cursor, cursor + charset.bytesize,
+          cursor + charset.bytesize + charstrings_index.bytesize,
+          cursor + charset.bytesize + charstrings_index.bytesize + fd_select.bytesize]
+        raise InvalidFont, "CFF CID subset offsets did not converge" unless expected == offsets.take(4) && fd_array_offset + fd_array.bytesize == private_offset
+
+        header + name_index + top_index + string_index + global_subrs_index + charset +
+          charstrings_index + fd_select + fd_array + private_dictionary + local_subrs_index
+      end
+
+      private
+
+      def encode_private_dictionary(record, has_subrs)
+        return "".b unless record
+        return encode_dictionary(record[:entries], {}) unless has_subrs
+
+        relative_offset = 0
+        8.times do
+          bytes = encode_dictionary(record[:entries], {19 => [relative_offset]})
+          return bytes if bytes.bytesize == relative_offset
+
+          relative_offset = bytes.bytesize
+        end
+        raise InvalidFont, "CFF private subroutine offset did not converge"
+      end
+
+      def encode_dictionary(entries, replacements)
+        present = {}
+        output = +"".b
+        entries.each do |operator, operands|
+          if replacements.key?(operator)
+            output << replacements.fetch(operator).map { |value| encode_number(value) }.join.b
+            present[operator] = true
+          else
+            operands.each { |raw, _value| output << raw }
+          end
+          output << encode_operator(operator)
+        end
+        replacements.each do |operator, values|
+          next if present[operator]
+
+          output << values.map { |value| encode_number(value) }.join.b
+          output << encode_operator(operator)
+        end
+        output
+      end
+
+      def encode_operator(operator)
+        operator >= 1200 ? [12, operator - 1200].pack("C2") : [operator].pack("C")
+      end
+
+      def encode_number(value)
+        raise InvalidFont, "invalid CFF offset" unless value.is_a?(Integer) && value >= 0
+        case value
+        when 0..107 then [value + 139].pack("C")
+        when 108..1131 then [247 + (value - 108) / 256, (value - 108) % 256].pack("C2")
+        when 1132..32767 then [28, value].pack("Cn")
+        when 32768..0x7fff_ffff then [29, value].pack("CN")
+        else raise InvalidFont, "CFF offset exceeds DICT integer range"
+        end
+      end
+
+      def encode_index(objects)
+        raise UnsupportedFont, "too many CFF INDEX entries" if objects.length > 0xffff
+        return [0].pack("n") if objects.empty?
+
+        offsets = [1]
+        objects.each { |object| offsets << offsets.last + object.bytesize }
+        raise UnsupportedFont, "CFF INDEX exceeds 32-bit offsets" if offsets.last > 0xffff_ffff
+        width = offsets.last <= 0xff ? 1 : offsets.last <= 0xffff ? 2 : offsets.last <= 0xff_ffff ? 3 : 4
+        encoded_offsets = offsets.map do |offset|
+          width.times.map { |index| (offset >> ((width - index - 1) * 8)) & 0xff }.pack("C*")
+        end.join.b
+        [objects.length].pack("n") + [width].pack("C") + encoded_offsets + objects.join.b
+      end
+
+      def subset_charset(glyphs)
+        offset = @top.fetch(15).first
+        format = @data.u8(offset)
+        source_sids = [0]
+        glyph = 1
+        case format
+        when 0
+          @data.validate_bounds(offset + 1, (@charstrings.length - 1) * 2)
+          source_sids.concat((@charstrings.length - 1).times.map { |index| @data.u16(offset + 1 + index * 2) })
+        when 1, 2
+          cursor = offset + 1
+          while glyph < @charstrings.length
+            first = @data.u16(cursor)
+            cursor += 2
+            left = format == 1 ? @data.u8(cursor) : @data.u16(cursor)
+            cursor += format == 1 ? 1 : 2
+            (left + 1).times { |index| source_sids[glyph] = first + index; glyph += 1 }
+            raise InvalidFont, "CFF charset range exceeds glyph count" if glyph > @charstrings.length
+          end
+        else
+          raise UnsupportedFont, "unsupported CFF charset format"
+        end
+        raise InvalidFont, "CFF charset does not cover glyphs" unless source_sids.length == @charstrings.length
+
+        selected_sids = glyphs.drop(1).map { |glyph_id| source_sids.fetch(glyph_id) }
+        unless selected_sids.all? { |sid| sid.between?(0, 390) || (sid >= 391 && sid - 391 < @strings.length) }
+          raise InvalidFont, "CFF charset references an invalid SID"
+        end
+        [0].pack("C") + selected_sids.pack("n*")
+      end
+
+      def encode_top_dictionary(charset_offset, charstrings_offset, private_offset, private_size)
+        replacements = {15 => [charset_offset], 17 => [charstrings_offset]}
+        replacements[18] = [private_size, private_offset] if @top.key?(18)
+        replacements[16] = [@top.fetch(16, [0]).first] if @top.key?(16)
+        encode_dictionary(@top_dictionary_entries, replacements)
+      end
+
+      def encode_cid_top_dictionary(offsets)
+        charset_offset, charstrings_offset, fd_select_offset, fd_array_offset = offsets
+        entries = @top_dictionary_entries.reject { |operator, _| [15, 16, 17, 18, 1230, 1236, 1237].include?(operator) }
+        ros_registry = 391 + @strings.length
+        replacements = {15 => [charset_offset], 17 => [charstrings_offset],
+          1230 => [ros_registry, ros_registry + 1, 0], 1236 => [fd_array_offset], 1237 => [fd_select_offset]}
+        encode_dictionary(entries, replacements)
+      end
+    end
+  end
+end

data/lib/alhena/font.rb

@@ -5,7 +5,7 @@ module Alhena
   class Font
     LOOKUP_CACHE_SIZE = 4096
     private_constant :LOOKUP_CACHE_SIZE
-    attr_reader :index, :tables, :axis_values
+    attr_reader :index, :tables, :axis_values, :sfnt_signature
 
     # @param path [String] sfnt, OpenType or TTC filename
     # @param index [Integer] zero-based collection face
@@ -29,6 +29,7 @@ module Alhena
       end
       signature = @binary.bytes(offset, 4)
       raise UnsupportedFont, "expected sfnt, OpenType or TTC" unless ["\x00\x01\x00\x00".b, "OTTO", "true"].include?(signature)
+      @sfnt_signature = signature.freeze
       count = @binary.u16(offset + 4)
       @binary.validate_bounds(offset + 12, count * 16)
       @tables = {}
@@ -64,6 +65,36 @@ module Alhena
     def ascent = table("hhea").i16(4)
     def descent = table("hhea").i16(6)
     def line_gap = table("hhea").i16(8)
+    def bbox = 4.times.map { |index| table("head").i16(36 + index * 2) }.freeze
+    def cff? = @tables.key?("CFF ") || @tables.key?("CFF2")
+
+    def glyph_ids(text)
+      raise ArgumentError, "text must be a String" unless text.is_a?(String)
+
+      codepoints = text.codepoints
+      codepoints.each_with_index.filter_map do |codepoint, index|
+        next if variation_selector?(codepoint)
+
+        selector = codepoints[index + 1]
+        glyph_id(codepoint, variation_selector: variation_selector?(selector) ? selector : nil)
+      end
+    end
+
+    # Unicode codepoint => glyph ID. `glyph_id` remains the bounded lookup API;
+    # this map is useful when a consumer needs a stable reverse mapping.
+    def cmap
+      @cmap ||= begin
+        result = {}
+        cmaps.each { |data| add_cmap_entries(result, data) }
+        result.freeze
+      end
+    end
+
+    def unicode_for_glyph(glyph)
+      validate_glyph(glyph)
+      @unicode_cmap ||= cmap.each_with_object({}) { |(codepoint, id), reverse| reverse[id] ||= codepoint }.freeze
+      @unicode_cmap[glyph]
+    end
 
     def names
       @names ||= begin
@@ -126,7 +157,11 @@ module Alhena
       cached_metric(glyph, vertical: vertical)[0] * scale_factor(size)
     end
 
-    def advance_width(codepoints, size:, features: [])
+    def advance_width(codepoints, size: nil, features: [])
+      if codepoints.is_a?(Integer)
+        return cached_metric(codepoints, vertical: false)[0] * scale_factor(size || units_per_em)
+      end
+      raise ArgumentError, "size is required" unless size
       validate_features(features)
       raise ArgumentError, "codepoints must be an Array" unless codepoints.is_a?(Array)
 
@@ -190,6 +225,45 @@ module Alhena
 
     private
 
+    def add_cmap_entries(result, data)
+      format = data.u16(0)
+      case format
+      when 0
+        256.times { |codepoint| add_cmap_entry(result, codepoint, glyph_id_from_cmap(data, codepoint)) }
+      when 4
+        count = data.u16(6) / 2
+        count.times do |index|
+          first = data.u16(16 + count * 2 + index * 2)
+          last = data.u16(14 + index * 2)
+          next if first == 0xffff || last == 0xffff
+
+          first.upto(last) { |codepoint| add_cmap_entry(result, codepoint, glyph_id_from_cmap(data, codepoint)) }
+        end
+      when 6
+        first, count = data.u16(6), data.u16(8)
+        count.times { |index| add_cmap_entry(result, first + index, glyph_id_from_cmap(data, first + index)) }
+      when 12, 13
+        count = data.u32(12)
+        data.validate_bounds(16, count * 12)
+        count.times do |index|
+          at = 16 + index * 12
+          first, last, start_glyph = data.u32(at), data.u32(at + 4), data.u32(at + 8)
+          if format == 13
+            add_cmap_entry(result, first, start_glyph)
+            next
+          end
+          [last, first + glyph_count - start_glyph - 1, 0x10ffff].min.downto(first) do |codepoint|
+            glyph = start_glyph + codepoint - first
+            add_cmap_entry(result, codepoint, glyph)
+          end
+        end
+      end
+    end
+
+    def add_cmap_entry(result, codepoint, glyph)
+      result[codepoint] ||= glyph if glyph.positive? && glyph < glyph_count && !(0xd800..0xdfff).cover?(codepoint)
+    end
+
     def scale_factor(size)
       valid = size.is_a?(Numeric) && size.real? && size.finite? && size > 0
       raise ArgumentError, "size must be positive and finite" unless valid

data/lib/alhena/subset.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Alhena
+  module Subset
+    CHECKSUM = 0xb1b0afba
+    private_constant :CHECKSUM
+
+    module_function
+
+    def build(font, glyph_ids)
+      raise ArgumentError, "font must be an Alhena::Font" unless font.is_a?(Font)
+      raise ArgumentError, "glyph_ids must be an Array" unless glyph_ids.is_a?(Array)
+      glyph_ids.each do |glyph|
+        raise ArgumentError, "glyph ID out of range" unless glyph.is_a?(Integer) && glyph.between?(0, font.glyph_count - 1)
+      end
+
+      return cff(font, glyph_ids) if font.cff?
+
+      true_type(font, glyph_ids)
+    end
+
+    # Returns a CID-keyed CFF1 program with glyph order matching the requested CIDs.
+    # Unlike #build, glyph_ids may repeat; entry zero must be glyph 0 (.notdef).
+    def build_cid(font, glyph_ids)
+      raise ArgumentError, "font must be an Alhena::Font" unless font.is_a?(Font)
+      raise ArgumentError, "glyph_ids must be an Array" unless glyph_ids.is_a?(Array)
+      glyph_ids.each do |glyph|
+        raise ArgumentError, "glyph ID out of range" unless glyph.is_a?(Integer) && glyph.between?(0, font.glyph_count - 1)
+      end
+      raise UnsupportedFont, "CID conversion requires a non-variable CFF1 font" unless font.tables.key?("CFF ") && !font.tables.key?("CFF2") && !font.tables.key?("fvar") && !font.tables.key?("HVAR")
+
+      CFF.new(font.table("CFF "), units_per_em: font.units_per_em).subset_cid(glyph_ids)
+    end
+
+    def cff(font, glyph_ids)
+      raise UnsupportedFont, "CFF2 subsetting is unsupported" unless font.tables.key?("CFF ") && !font.tables.key?("CFF2")
+      raise UnsupportedFont, "variable CFF1 subsetting is unsupported" if font.tables.key?("fvar") || font.tables.key?("HVAR")
+
+      glyphs = [0, *glyph_ids].uniq.sort
+      remap = glyphs.each_with_index.to_h
+      header = font.table("hhea").data.dup
+      header[34, 2] = [glyphs.length].pack("n")
+      maximum = font.table("maxp").data.dup
+      maximum[4, 2] = [glyphs.length].pack("n")
+      tables = {
+        "CFF " => CFF.new(font.table("CFF "), units_per_em: font.units_per_em).subset(glyphs),
+        "head" => font.table("head").data,
+        "hhea" => header,
+        "hmtx" => metrics(font, glyphs),
+        "maxp" => maximum,
+        "cmap" => unicode_cmap(font, remap)
+      }
+      %w[OS/2 name].each { |tag| tables[tag] = font.table(tag).data if font.tables.key?(tag) }
+      if font.tables.key?("post")
+        post = font.table("post").bytes(0, 32).dup
+        post[0, 4] = [0x0003_0000].pack("N")
+        tables["post"] = post
+      end
+      sfnt(font, tables)
+    end
+
+    def true_type(font, glyph_ids)
+      glyphs = closure(font, [0, *glyph_ids].uniq)
+      remap = glyphs.each_with_index.to_h
+      glyf, locations = +"".b, [0]
+      glyphs.each do |glyph|
+        data = remap_components(glyph_bytes(font, glyph), remap)
+        glyf << data
+        glyf << "\0" if glyf.bytesize.odd?
+        locations << glyf.bytesize
+      end
+
+      head = font.table("head").data.dup
+      head[8, 4] = "\0" * 4
+      head[50, 2] = [1].pack("s>")
+      hhea = font.table("hhea").data.dup
+      hhea[34, 2] = [glyphs.length].pack("n")
+      maxp = font.table("maxp").data.dup
+      maxp[4, 2] = [glyphs.length].pack("n")
+      tables = {"head" => head, "hhea" => hhea, "maxp" => maxp, "glyf" => glyf,
+                "loca" => locations.pack("N*"), "hmtx" => metrics(font, glyphs),
+                "cmap" => unicode_cmap(font, remap)}
+      %w[OS/2 name post].each { |tag| tables[tag] = font.table(tag).data if font.tables.key?(tag) }
+      sfnt(font, tables)
+    end
+
+    def closure(font, roots)
+      found, pending = {}, roots.dup
+      until pending.empty?
+        glyph = pending.pop
+        next if found[glyph]
+        found[glyph] = true
+        composite_children(glyph_bytes(font, glyph)).each { |child| pending << child unless found[child] }
+      end
+      found.keys.sort
+    end
+
+    def glyph_bytes(font, glyph)
+      loca = font.table("loca")
+      format = font.table("head").i16(50)
+      first = format.zero? ? loca.u16(glyph * 2) * 2 : loca.u32(glyph * 4)
+      last = format.zero? ? loca.u16((glyph + 1) * 2) * 2 : loca.u32((glyph + 1) * 4)
+      raise InvalidFont, "invalid glyph location" if last < first
+
+      font.table("glyf").bytes(first, last - first)
+    end
+
+    def composite_children(data)
+      composite_offsets(data).map { |offset| data.unpack1("n", offset: offset) }
+    end
+
+    def remap_components(data, remap)
+      composite_offsets(data).each do |offset|
+        old = data.unpack1("n", offset: offset)
+        data[offset, 2] = [remap.fetch(old) { raise InvalidFont, "missing composite glyph #{old}" }].pack("n")
+      end
+      data
+    end
+
+    def composite_offsets(data)
+      return [] if data.empty? || data.unpack1("s>") >= 0
+
+      offsets = []
+      at = 10
+      loop do
+        raise InvalidFont, "truncated composite glyph" if at + 4 > data.bytesize
+        flags = data.unpack1("n", offset: at)
+        offsets << at + 2
+        at += 4 + ((flags & 1).zero? ? 2 : 4)
+        at += if (flags & 8) != 0 then 2 elsif (flags & 64) != 0 then 4 elsif (flags & 128) != 0 then 8 else 0 end
+        break if (flags & 32).zero?
+      end
+      offsets
+    end
+
+    def metrics(font, glyphs)
+      glyphs.map { |glyph| [font.advance(glyph).round, font.bearing(glyph).round].pack("ns>") }.join.b
+    end
+
+    def unicode_cmap(font, remap)
+      entries = font.cmap.filter_map { |codepoint, glyph| [codepoint, remap[glyph]] if remap.key?(glyph) }
+      groups = []
+      entries.sort.each do |codepoint, glyph|
+        previous = groups.last
+        if previous && codepoint == previous[1] + 1 && glyph == previous[2] + codepoint - previous[0]
+          previous[1] = codepoint
+        else
+          groups << [codepoint, codepoint, glyph]
+        end
+      end
+      subtable = [12, 0, 16 + groups.length * 12, 0, groups.length].pack("nnNNN") + groups.flatten.pack("N*")
+      [0, 1, 0, 4, 12].pack("n4N") + subtable
+    end
+
+    def sfnt(font, tables)
+      tables = tables.transform_values(&:b)
+      head = tables.fetch("head").dup
+      head[8, 4] = "\0" * 4
+      tables["head"] = head
+      count = tables.length
+      power = 1 << (Math.log2(count).floor)
+      search_range = power * 16
+      directory = [font.sfnt_signature, count, search_range, Math.log2(power).to_i, count * 16 - search_range].pack("a4n4")
+      payload, records, head_offset = +"".b, +"".b, nil
+      tables.sort.each do |tag, bytes|
+        offset = 12 + count * 16 + payload.bytesize
+        checksum = table_checksum(bytes)
+        records << tag << [checksum, offset, bytes.bytesize].pack("N3")
+        head_offset = offset if tag == "head"
+        payload << bytes
+        payload << "\0" until payload.bytesize % 4 == 0
+      end
+      output = directory + records + payload
+      adjustment = (CHECKSUM - table_checksum(output)) & 0xffffffff
+      output[head_offset + 8, 4] = [adjustment].pack("N")
+      output
+    end
+
+    def table_checksum(bytes)
+      padded = bytes.dup
+      padded << "\0" until padded.bytesize % 4 == 0
+      padded.unpack("N*").sum & 0xffffffff
+    end
+  end
+end

data/lib/alhena/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Alhena
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/alhena.rb

@@ -15,7 +15,9 @@ require_relative "alhena/outline"
 require_relative "alhena/binary"
 require_relative "alhena/rasterizer"
 require_relative "alhena/cff"
+require_relative "alhena/cff_subset"
 require_relative "alhena/font"
+require_relative "alhena/subset"
 require_relative "alhena/variation"
 require_relative "alhena/png"
 require_relative "alhena/color"

data/sig/alhena.rbs

@@ -62,12 +62,18 @@ module Alhena
     attr_reader index: Integer
     attr_reader tables: Hash[String, [Integer, Integer]]
     attr_reader axis_values: Hash[String, Numeric]
+    attr_reader sfnt_signature: String
     def data: () -> String
     def self.open: (String path, ?index: Integer, ?axes: Hash[String | Symbol, Numeric]) -> Font
     def initialize: (String data, ?index: Integer, ?axes: Hash[String | Symbol, Numeric]) -> void
     def table: (String tag) -> Binary
     def units_per_em: () -> Integer
     def glyph_count: () -> Integer
+    def bbox: () -> [Integer, Integer, Integer, Integer]
+    def cff?: () -> bool
+    def glyph_ids: (String) -> Array[Integer]
+    def cmap: () -> Hash[Integer, Integer]
+    def unicode_for_glyph: (Integer) -> Integer?
     def ascent: () -> Integer
     def descent: () -> Integer
     def line_gap: () -> Integer
@@ -77,7 +83,8 @@ module Alhena
     def post: () -> Hash[Symbol, Numeric | bool]
     def glyph_id: (String | Integer character, ?variation_selector: String | Integer | nil) -> Integer
     def advance: (Integer glyph, ?size: Numeric, ?vertical: bool) -> Float
-    def advance_width: (Array[Integer] codepoints, size: Numeric, ?features: Array[String | Symbol]) -> Float
+    def advance_width: (Integer glyph_id, ?size: Numeric) -> Float
+                      | (Array[Integer] codepoints, size: Numeric, ?features: Array[String | Symbol]) -> Float
     def measure: (String text, size: Numeric, ?features: Array[String | Symbol]) -> Metrics
     def bearing: (Integer glyph, ?size: Numeric, ?vertical: bool) -> Float
     def outline: (Integer glyph) -> Outline
@@ -124,4 +131,8 @@ module Alhena
     def prewarm: (Font font, String text, ?Numeric? size, **untyped options) -> self
     def clear: () -> self
   end
+  module Subset
+    def self.build: (Font, Array[Integer]) -> String
+    def self.build_cid: (Font, Array[Integer]) -> String
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alhena
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -27,12 +27,14 @@ files:
 - lib/alhena/bitmap.rb
 - lib/alhena/cache.rb
 - lib/alhena/cff.rb
+- lib/alhena/cff_subset.rb
 - lib/alhena/color.rb
 - lib/alhena/data_compat.rb
 - lib/alhena/font.rb
 - lib/alhena/outline.rb
 - lib/alhena/png.rb
 - lib/alhena/rasterizer.rb
+- lib/alhena/subset.rb
 - lib/alhena/variation.rb
 - lib/alhena/version.rb
 - sig/alhena.rbs