fontisan 0.4.45 → 0.4.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5809fbd27b8c1e2d11d559e90e45201748c35aee50106d6eda8e34f363c4ead7
-  data.tar.gz: 897ed09e0131fc562d21b5796d1c4e263967277bbbbc038b1eac3ea4f10ffc9e
+  metadata.gz: 1866983941321f8342976513ef0fb988454641cd88e677c9f8ea5c5811fe4368
+  data.tar.gz: 959ca2b7cec09514b960b1f9c649ca9b6f3d9716dfd87c31dfa8155ae54d6ac2
 SHA512:
-  metadata.gz: 31e50b7dc96edb8ad675f5ad4843264708890a40b77586496a75ca61335dc46a5ab1e96b587d66e03512b5cca8b38a7d6d78804ea3d3520797b5b9cd740571c4
-  data.tar.gz: 19d29274a8fd77b7fe5dc39dec2f2435f38ecfc16df1a00c560051afd5b42f14add68cf92f0873b3cb59c1d35647904917a99826ca5b10c1c4710871cacdae7f
+  metadata.gz: 8515b8d576d88acd19737ccfb14fc5aea468c7ac94b1242beb09757a6a45c11f9846caf8e64df1558ccd472f31a74ceee3fae415471861c8fe0b0520802d86fd
+  data.tar.gz: b025f9cb74a3a4059367d33453113838fbde355ff434f51879a97d19a134e5753d640b6b2460741d3999a69b79ce16e5bc78db3e5e6e929e85974a77e5cebca2

data/Rakefile

@@ -8,7 +8,7 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-# rubocop:disable Metrics/BlockLength
+# rubocop:disable-next Metrics/BlockLength
 namespace :fixtures do
   # Load centralized fixture configuration and the test-only downloader.
   # The downloader lives under spec/support (not lib/) because it is
@@ -144,7 +144,6 @@ namespace :fixtures do
     end
   end
 end
-# rubocop:enable Metrics/BlockLength
 
 # RSpec task depends on fixtures
 RSpec::Core::RakeTask.new(spec: "fixtures:download")

data/lib/fontisan/cli.rb

@@ -599,7 +599,7 @@ module Fontisan
 
     def export(font_file)
       command = Commands::ExportCommand.new(
-        font_file,
+        input: font_file,
         output: options[:output],
         format: options[:format].to_sym,
         tables: options[:tables],

data/lib/fontisan/commands/export_command.rb

@@ -32,8 +32,8 @@ module Fontisan
       # @param pretty [Boolean] Pretty-print output
       def initialize(input:, output: nil, format: :yaml, tables: nil,
                      binary_format: :hex, pretty: true)
-        super()
         @input = input
+        super(input)
         @output = output
         @format = format.to_sym
         @tables = tables
@@ -47,8 +47,8 @@ module Fontisan
       def run
         validate_params!
 
-        # Load font
-        font = load_font
+        # BaseCommand loads the font during initialization
+        font = @font
         return 1 unless font
 
         # Create exporter

data/lib/fontisan/export/exporter.rb

@@ -188,7 +188,7 @@ module Fontisan
           tag: tag,
           checksum: format_checksum(checksum),
           parsed: false,
-          data: @serializer.encode_binary(binary_data),
+          data: @serializer.serialize_binary(binary_data, tag).fetch(:data),
           fields: { error: error.message }.to_json,
         )
       end

data/lib/fontisan/export/table_serializer.rb

@@ -28,14 +28,6 @@ module Fontisan
         cvt fpgm prep gasp DSIG GDEF GPOS GSUB
       ].freeze
 
-      # Tables that ship a summary alongside the raw binary.
-      MIXED_SUMMARIES = {
-        "glyf" => GlyphSummary,
-        "loca" => LocaSummary,
-        "cmap" => CmapSummary,
-        "CFF" => CffSummary,
-      }.freeze
-
       # @param binary_format [Symbol] :hex or :base64
       def initialize(binary_format: :hex)
         @binary_format = binary_format
@@ -62,6 +54,42 @@ module Fontisan
         { tag: tag, parsed: false, data: encode_binary(data), fields: nil }
       end
 
+      # Summary builders for mixed-content tables.
+      module GlyphSummary
+        def self.call(table)
+          { type: "glyf", num_glyphs: table.glyphs.length,
+            note: "Outline data stored as binary" }
+        end
+      end
+
+      module LocaSummary
+        def self.call(table)
+          { type: "loca", num_offsets: table.offsets.length,
+            format: table.format }
+        end
+      end
+
+      module CmapSummary
+        def self.call(table)
+          { type: "cmap", version: table.version,
+            note: "Character mappings stored as binary" }
+        end
+      end
+
+      module CffSummary
+        def self.call(_table)
+          { type: "CFF", note: "CharString data stored as binary" }
+        end
+      end
+
+      # Tables that ship a summary alongside the raw binary.
+      MIXED_SUMMARIES = {
+        "glyf" => GlyphSummary,
+        "loca" => LocaSummary,
+        "cmap" => CmapSummary,
+        "CFF" => CffSummary,
+      }.freeze
+
       private
 
       def fully_parsed?(tag)
@@ -107,36 +135,6 @@ module Fontisan
               "Invalid binary format: #{@binary_format}. " \
               "Must be one of: #{valid.join(', ')}"
       end
-
-      # Summary builders for mixed-content tables. Each is a callable
-      # that receives the typed table and returns a JSON-able Hash.
-
-      module GlyphSummary
-        def self.call(table)
-          { type: "glyf", num_glyphs: table.glyphs.length,
-            note: "Outline data stored as binary" }
-        end
-      end
-
-      module LocaSummary
-        def self.call(table)
-          { type: "loca", num_offsets: table.offsets.length,
-            format: table.format }
-        end
-      end
-
-      module CmapSummary
-        def self.call(table)
-          { type: "cmap", version: table.version,
-            note: "Character mappings stored as binary" }
-        end
-      end
-
-      module CffSummary
-        def self.call(_table)
-          { type: "CFF", note: "CharString data stored as binary" }
-        end
-      end
     end
   end
 end

data/lib/fontisan/stitcher/partition_strategy/by_block.rb

@@ -33,7 +33,7 @@ module Fontisan
         # be data-driven, swap BLOCKS for a CSV/YAML loader behind
         # the same constant — callers don't care about the source
         # (OCP).
-        # rubocop:disable Metrics/CollectionLiteralLength
+        # rubocop:disable-next Metrics/CollectionLiteralLength
         BLOCKS = {
           # BMP (Plane 0)
           "Basic_Latin" => 0x0000..0x007F,
@@ -375,7 +375,6 @@ module Fontisan
           "Tags" => 0xE0000..0xE007F,
           "Variation_Selectors_Supplement" => 0xE0100..0xE01EF,
         }.freeze
-        # rubocop:enable Metrics/CollectionLiteralLength
 
         # @param cp_map [Hash{Integer=>Object}] codepoint → donor label
         # @param cap [Integer] max codepoints per partition

data/lib/fontisan/tables/cff/standard_strings_data.rb

@@ -13,7 +13,7 @@ module Fontisan
       module StandardStrings
         # The 391 CFF standard strings are a fixed spec-defined data
         # table (Adobe TN 5176 Appendix A).
-        # rubocop:disable Metrics/CollectionLiteralLength
+        # rubocop:disable-next Metrics/CollectionLiteralLength
         LIST = %w[
           .notdef space exclam quotedbl numbersign
           dollar percent ampersand quoteright
@@ -75,7 +75,6 @@ module Fontisan
           afii57518 afii57519 afii57520 afii57521 afii64237 afii64238
           exclamdouble uni204A uni2080 uni2081 uni2082 uni2083 uni2084
         ].freeze
-        # rubocop:enable Metrics/CollectionLiteralLength
 
         COUNT = 391
       end

data/lib/fontisan/tables/gpos/glyph_filter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "fontisan/tables/gpos/pair_position"
+
+module Fontisan
+  module Tables
+    class Gpos
+      # Evaluates lookup flags against explicit GDEF classes for pair endpoints.
+      class GlyphFilter
+        def initialize(flags, gdef, mark_set:)
+          raise ParseError, "Reserved GPOS lookup flags" unless (flags & 0x00e0).zero?
+
+          @flags = flags
+          if (flags & 0xff1e).positive?
+            unless gdef
+              raise UnsupportedFormatError, "GPOS lookup filtering requires gdef: font.table_data['GDEF']"
+            end
+
+            @gdef = gdef
+            @header = header
+            @classes = definition(@header[1], "glyph classes")
+            raise ParseError, "Invalid GDEF glyph class" if @classes.maximum > 4
+
+            if (flags & 8).zero?
+              if (flags & 16).positive?
+                @mark_set = mark_set(mark_set)
+              elsif (flags >> 8).positive?
+                @mark_classes = definition(@header[2], "mark attachment classes")
+              end
+            end
+          end
+          freeze
+        end
+
+        def allows?(glyph)
+          return true unless @classes
+
+          glyph_class = @classes[glyph]
+          return false if glyph_class.between?(1, 3) && (@flags & (1 << glyph_class)).positive?
+          return true unless glyph_class == 3
+          return @mark_set.include?(glyph) if @mark_set
+          return @mark_classes[glyph] == (@flags >> 8) if @mark_classes
+
+          true
+        end
+
+        private
+
+        def header
+          @gdef.cached(:gdef_header) do
+            minor = @gdef.uint16(2)
+            unless @gdef.uint16(0) == 1 && [0, 2, 3].include?(minor)
+              raise ParseError, "Unsupported GDEF version"
+            end
+
+            length = { 0 => 12, 2 => 14, 3 => 18 }.fetch(minor)
+            @gdef.bytes(0, length)
+            [length, @gdef.uint16(4), @gdef.uint16(10), minor.zero? ? 0 : @gdef.uint16(12)].freeze
+          end
+        end
+
+        def definition(offset, name)
+          raise UnsupportedFormatError, "GPOS filtering requires GDEF #{name}" if offset.zero?
+
+          view = @gdef.child(offset, minimum: @header[0])
+          view.cached(:class_definition) { ClassDefinition.new(view) }
+        end
+
+        def mark_set(index)
+          raise UnsupportedFormatError, "GPOS filtering requires GDEF mark glyph sets" if @header[3].zero?
+
+          sets = @gdef.child(@header[3], minimum: @header[0])
+          raise ParseError, "Unsupported GDEF mark glyph sets format" unless sets.uint16(0) == 1
+
+          count = sets.uint16(2)
+          raise ParseError, "Invalid GDEF mark filtering set #{index}" if index >= count
+
+          sets.uint32(4 + (count - 1) * 4)
+          view = sets.child(sets.uint32(4 + index * 4), minimum: 4 + count * 4)
+          view.cached(:coverage) { Coverage.new(view) }
+        end
+      end
+
+      private_constant :GlyphFilter
+    end
+  end
+end

data/lib/fontisan/tables/gpos/kerning_pairs.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "fontisan/tables/gpos/glyph_filter"
+
+module Fontisan
+  module Tables
+    class Gpos
+      # Glyph-ID pair queries with explicit bounds for class-based enumeration.
+      class KerningPairs
+        include Enumerable
+
+        def initialize(table, script_tag:, feature_tag:, glyph_count:, gdef:)
+          if !glyph_count.nil? && (!glyph_count.is_a?(Integer) || !glyph_count.between?(0, 65536))
+            raise ArgumentError, "glyph_count must be an integer from 0 to 65536"
+          end
+
+          raise ArgumentError, "gdef must contain raw GDEF table bytes" unless gdef.nil? || gdef.is_a?(String)
+
+          @glyph_count = glyph_count
+          @view = BinaryView.new(table.raw_data.dup.freeze)
+          @gdef = BinaryView.new(gdef.dup.freeze) if gdef
+          @lookups = selected_lookups(table, script_tag, feature_tag).tally.freeze
+          @subtables = @lookups.keys.flat_map(&:subtables).uniq.freeze
+          @view.freeze
+          @gdef&.freeze
+        end
+
+        def [](pair)
+          unless pair.is_a?(Array) && pair.size == 2 && pair.all? { |gid| gid.is_a?(Integer) && gid.between?(0, 65535) }
+            raise ArgumentError, "Expected two glyph IDs from 0 to 65535"
+          end
+
+          @lookups.sum { |lookup, count| lookup.adjustment(*pair) * count }
+        end
+
+        def each
+          return enum_for(:each) unless block_given?
+
+          if @glyph_count.nil? && @subtables.any?(&:class_based?)
+            raise ArgumentError, "glyph_count is required to enumerate class-based kerning"
+          end
+
+          left_glyphs(@subtables).each do |left|
+            candidates(@subtables, left).each do |right|
+              pair = [left, right]
+              value = self[pair]
+              yield pair, value unless value.zero?
+            end
+          end
+          self
+        end
+
+        private
+
+        def candidates(subtables, left)
+          matching = subtables.select { |subtable| subtable.covers?(left) }
+          return (0...@glyph_count) if matching.any?(&:class_based?)
+
+          union(matching.map { |subtable| subtable.right_glyphs(left) })
+        end
+
+        def left_glyphs(subtables)
+          union(subtables.map(&:left_glyphs))
+        end
+
+        def union(sequences)
+          glyphs = {}
+          sequences.each do |sequence|
+            sequence.each do |glyph|
+              break if @glyph_count && glyph >= @glyph_count
+
+              glyphs[glyph] = true
+            end
+          end
+          glyphs.keys.sort
+        end
+
+        def selected_lookups(table, script_tag, feature_tag)
+          return [] if table.script_list_offset.zero? || table.feature_list_offset.zero?
+
+          indices = feature_indices(table.script_list_offset.to_i, script_tag)
+          return [] if indices.empty?
+
+          features = @view.child(table.feature_list_offset.to_i, minimum: 10)
+          list = features.record(LayoutCommon::FeatureList, header: 2, count_offset: 0, item_size: 6)
+          feature_offsets = indices.filter_map do |index|
+            raise ParseError, "Invalid GPOS feature index #{index}" if index >= list.feature_count
+
+            record = list.feature_records[index]
+            record.feature_offset.to_i if record.feature_tag == feature_tag
+          end
+          lookup_indices = feature_lookup_indices(features, feature_offsets.uniq,
+                                                  2 + list.feature_count.to_i * 6,
+                                                  table.lookup_list_offset.to_i)
+          return [] if lookup_indices.empty?
+
+          lookups(table.lookup_list_offset.to_i, lookup_indices)
+        end
+
+        def feature_lookup_indices(features, offsets, minimum, lookup_list_offset)
+          ranges = feature_ranges(features, offsets, minimum)
+          return [] if ranges.empty?
+
+          lookup_count = @view.child(lookup_list_offset, minimum: 10).uint16(0)
+          indices = {}
+          ranges.group_by { |first, _last| first % 2 }.each_value do |spans|
+            previous = -1
+            spans.sort.each do |first, last|
+              [first, previous + 2].max.step(last, 2) do |position|
+                lookup_index = features.uint16(position)
+                raise ParseError, "Invalid GPOS lookup index #{lookup_index}" if lookup_index >= lookup_count
+
+                indices[lookup_index] = true
+              end
+              previous = [previous, last].max
+            end
+          end
+          indices.keys.sort
+        end
+
+        def feature_ranges(features, offsets, minimum)
+          offsets.filter_map do |offset|
+            feature = features.child(offset, minimum: minimum)
+            count = feature.uint16(2)
+            feature.bytes(2 + count * 2, 2)
+            [offset + 4, offset + 2 + count * 2] unless count.zero?
+          end
+        end
+
+        def feature_indices(offset, script_tag)
+          scripts = @view.child(offset, minimum: 10)
+          list = scripts.record(LayoutCommon::ScriptList, header: 2, count_offset: 0, item_size: 6)
+          record = list.script_records.find { |item| item.script_tag == script_tag }
+          return [] unless record
+
+          script = scripts.child(record.script_offset.to_i, minimum: 2 + list.script_count.to_i * 6)
+          header = script.record(LayoutCommon::Script, header: 4, count_offset: 2, item_size: 6)
+          return [] if header.default_lang_sys_offset.zero?
+
+          lang = script.child(header.default_lang_sys_offset.to_i, minimum: 4 + header.lang_sys_count.to_i * 6)
+          record = lang.record(LayoutCommon::LangSys, header: 6, count_offset: 4, item_size: 2)
+          indices = record.feature_indices.map(&:to_i)
+          indices << record.required_feature_index.to_i unless record.required_feature_index == 0xffff
+          indices.uniq
+        end
+
+        def extension_subtables(views)
+          extensions = views.map do |view|
+            view.cached(:extension_position) do
+              raise ParseError, "Unsupported GPOS extension format" unless view.uint16(0) == 1
+
+              type = view.uint16(2)
+              raise ParseError, "Invalid GPOS extension lookup type #{type}" unless type.between?(1, 8)
+
+              [type, view.child(view.uint32(4), minimum: 8)].freeze
+            end
+          end
+          if extensions.map(&:first).uniq.size > 1
+            raise ParseError, "Inconsistent GPOS extension lookup types"
+          end
+
+          extensions.filter_map { |type, view| view if type == 2 }
+        end
+
+        def lookups(offset, indices)
+          list = @view.child(offset, minimum: 10)
+          count = list.uint16(0)
+          offsets = list.array(2, count)
+          indices.filter_map do |index|
+            lookup = list.child(offsets[index], minimum: 2 + count * 2)
+            type = lookup.uint16(0)
+            next unless [2, 9].include?(type)
+
+            lookup.cached(:pair_lookup) do
+              subtable_count = lookup.uint16(4)
+              subtable_offsets = lookup.array(6, subtable_count)
+              header = 6 + subtable_count * 2
+              header += 2 unless (lookup.uint16(2) & 16).zero?
+              lookup.bytes(0, header)
+              views = subtable_offsets.uniq.map { |subtable_offset| lookup.child(subtable_offset, minimum: header) }
+              views = extension_subtables(views) if type == 9
+              subtables = views.map { |view| view.cached(:pair_position) { PairPosition.new(view) } }.freeze
+              flags = subtables.empty? ? 0 : lookup.uint16(2)
+              mark_set = (flags & 16).zero? ? 0 : lookup.uint16(6 + subtable_count * 2)
+              PairLookup.new(subtables, GlyphFilter.new(flags, @gdef, mark_set: mark_set))
+            end
+          end
+        end
+      end
+
+      # One physical lookup can be referenced by multiple logical lookup indices.
+      class PairLookup
+        attr_reader :subtables
+
+        def initialize(subtables, filter)
+          @subtables = subtables
+          @filter = filter
+          freeze
+        end
+
+        def adjustment(left, right)
+          return 0 unless @filter.allows?(left) && @filter.allows?(right)
+
+          subtables.each do |subtable|
+            value = subtable.adjustment(left, right)
+            return value unless value.nil?
+          end
+          0
+        end
+      end
+
+      private_constant :KerningPairs, :PairLookup
+    end
+  end
+end

data/lib/fontisan/tables/gpos/pair_position.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "fontisan"
+
+module Fontisan
+  module Tables
+    class Gpos
+      # Checked views share physical identity without copying table suffixes.
+      class BinaryView
+        def initialize(data, offset: 0, cache: {})
+          @data = data
+          @offset = offset
+          @cache = cache
+        end
+
+        def bytes(offset, length)
+          if offset.negative? || length.negative? || @offset + offset + length > @data.bytesize
+            raise ParseError, "Truncated GPOS data at byte #{offset}"
+          end
+
+          @data.byteslice(@offset + offset, length)
+        end
+
+        def uint16(offset)
+          bytes(offset, 2).unpack1("n")
+        end
+
+        def uint32(offset)
+          bytes(offset, 4).unpack1("N")
+        end
+
+        def array(offset, count)
+          bytes(offset, count * 2).unpack("n*")
+        end
+
+        def child(offset, minimum:)
+          raise ParseError, "Invalid GPOS offset #{offset}" if offset < minimum
+
+          bytes(offset, 1)
+          self.class.new(@data, offset: @offset + offset, cache: @cache)
+        end
+
+        def record(type, header:, count_offset:, item_size:)
+          bytes(0, header + uint16(count_offset) * item_size)
+          type.read(@data.byteslice(@offset..))
+        end
+
+        def cached(context)
+          key = [@offset, context]
+          @cache.fetch(key) { @cache[key] = yield }
+        end
+
+        def freeze
+          @cache.freeze
+          super
+        end
+      end
+
+      # Coverage ranges remain compact, including the full glyph-ID domain.
+      class Coverage
+        include Enumerable
+
+        attr_reader :size
+
+        def initialize(view)
+          format = view.uint16(0)
+          count = view.uint16(2)
+          case format
+          when 1
+            @glyphs = view.array(4, count).freeze
+            unless @glyphs.each_cons(2).all? { |first, second| first < second }
+              raise ParseError, "Unsorted or duplicate GPOS glyph IDs"
+            end
+
+            @size = count
+          when 2
+            @ranges = view.array(4, count * 3).each_slice(3).map(&:freeze).freeze
+            @size = 0
+            previous = -1
+            @ranges.each do |first, last, index|
+              if first > last || index != @size || first <= previous
+                raise ParseError, "Invalid GPOS coverage range"
+              end
+
+              @size += last - first + 1
+              previous = last
+            end
+          else
+            raise ParseError, "Unsupported Coverage format #{format}"
+          end
+          freeze
+        end
+
+        def include?(glyph)
+          return @glyphs.bsearch { |candidate| candidate >= glyph } == glyph if @glyphs
+
+          record = @ranges.bsearch { |_first, last, _index| last >= glyph }
+          record && record[0] <= glyph
+        end
+
+        def each(&block)
+          return enum_for(:each) unless block
+
+          if @glyphs
+            @glyphs.each(&block)
+          else
+            @ranges.each do |first, last, _index|
+              (first..last).each(&block)
+            end
+          end
+          self
+        end
+      end
+
+      # Class arrays support direct glyph indexing without singleton ranges.
+      class ClassDefinition
+        attr_reader :maximum
+
+        def initialize(view)
+          @view = view
+          case view.uint16(0)
+          when 1
+            @first = view.uint16(2)
+            @count = view.uint16(4)
+            raise ParseError, "Invalid GPOS class definition" if @first + @count > 65536
+
+            @maximum = view.array(6, @count).max || 0
+          when 2
+            @ranges = view.array(4, view.uint16(2) * 3).each_slice(3).map(&:freeze).freeze
+            previous = -1
+            @maximum = 0
+            @ranges.each do |first, last, value|
+              if first <= previous || first > last
+                raise ParseError, "Invalid GPOS class definition"
+              end
+
+              @maximum = [@maximum, value].max
+              previous = last
+            end
+          else
+            raise ParseError, "Unsupported ClassDef format #{view.uint16(0)}"
+          end
+          freeze
+        end
+
+        def [](glyph)
+          if @ranges
+            record = @ranges.bsearch { |_first, last, _value| last >= glyph }
+            record && record[0] <= glyph ? record[2] : 0
+          else
+            index = glyph - @first
+            index.between?(0, @count - 1) ? @view.uint16(6 + index * 2) : 0
+          end
+        end
+      end
+
+      # Compact PairPos data; class matrices stay in their binary representation.
+      class PairPosition
+        attr_reader :left_glyphs
+
+        def initialize(view)
+          @view = view
+          @format = view.uint16(0)
+          raise ParseError, "Unsupported PairPos format #{@format}" unless [1, 2].include?(@format)
+
+          @first_format = view.uint16(4)
+          @second_format = view.uint16(6)
+          @first_size = value_size(@first_format)
+          @record_size = @first_size + value_size(@second_format)
+          @advance_offset = value_size(@first_format & 3)
+          @coverage = coverage
+          @left_glyphs = @coverage
+          @format == 1 ? parse_pairs : parse_classes
+          freeze
+        end
+
+        def class_based?
+          @format == 2
+        end
+
+        def covers?(glyph)
+          @coverage.include?(glyph)
+        end
+
+        def adjustment(left, right)
+          return unless covers?(left)
+          return @pairs.fetch(left)[right] unless class_based?
+
+          row = @first_classes[left]
+          column = @second_classes[right]
+          advance(@matrix, (row * @second_count + column) * @record_size)
+        end
+
+        def right_glyphs(left)
+          @pairs.fetch(left).each_key
+        end
+
+        private
+
+        def value_size(format)
+          raise ParseError, "Reserved GPOS ValueFormat bits" unless (format & 0xff00).zero?
+
+          format.digits(2).sum * 2
+        end
+
+        def advance(view, offset)
+          return 0 if (@first_format & 4).zero?
+
+          value = view.uint16(offset + @advance_offset)
+          value >= 0x8000 ? value - 0x10000 : value
+        end
+
+        def coverage
+          minimum = @format == 1 ? 10 + @view.uint16(8) * 2 : 16 + matrix_size
+          view = @view.child(@view.uint16(2), minimum: minimum)
+          view.cached(:coverage) { Coverage.new(view) }
+        end
+
+        def parse_pairs
+          count = @view.uint16(8)
+          raise ParseError, "GPOS PairSet count differs from coverage" unless count == left_glyphs.size
+
+          offsets = @view.array(10, count)
+          @pairs = {}
+          left_glyphs.each_with_index do |left, index|
+            view = @view.child(offsets[index], minimum: 10 + count * 2)
+            @pairs[left] = view.cached([:pair_set, @first_format, @second_format]) { pair_set(view) }
+          end
+          @pairs.freeze
+        end
+
+        def pair_set(view)
+          count = view.uint16(0)
+          view.bytes(2, count * (2 + @record_size))
+          previous = -1
+          pairs = {}
+          count.times do |index|
+            start = 2 + index * (2 + @record_size)
+            glyph = view.uint16(start)
+            raise ParseError, "Unsorted or duplicate GPOS glyph IDs" if glyph <= previous
+
+            pairs[glyph] = advance(view, start + 2)
+            previous = glyph
+          end
+          pairs.freeze
+        end
+
+        def matrix_size
+          @view.uint16(12) * @view.uint16(14) * @record_size
+        end
+
+        def parse_classes
+          first_count = @view.uint16(12)
+          @second_count = @view.uint16(14)
+          raise ParseError, "Empty GPOS class matrix" if first_count.zero? || @second_count.zero?
+
+          @matrix = BinaryView.new(@view.bytes(16, matrix_size).freeze).freeze
+          @first_classes = class_definition(@view.uint16(8), first_count)
+          @second_classes = class_definition(@view.uint16(10), @second_count)
+        end
+
+        def class_definition(offset, class_count)
+          view = @view.child(offset, minimum: 16 + matrix_size)
+          definition = view.cached(:class_definition) { ClassDefinition.new(view) }
+          raise ParseError, "Invalid GPOS class definition" if definition.maximum >= class_count
+
+          definition
+        end
+      end
+
+      private_constant :BinaryView, :Coverage, :ClassDefinition, :PairPosition
+    end
+  end
+end

data/lib/fontisan/tables/gpos.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fontisan"
+
 module Fontisan
   module Tables
     # GPOS (Glyph Positioning) table parser
@@ -55,6 +57,25 @@ module Fontisan
         []
       end
 
+      # Read PairPos value1.xAdvance in font units, directly or via extensions.
+      # The returned Enumerable supports pairs[[left_glyph_id, right_glyph_id]];
+      # unmatched pairs return zero. Use glyph_count: font.table("maxp").num_glyphs.to_i
+      # to enumerate class-based pairs, including implicit class zero, with to_h.
+      # Selects the script's default language system, with no script fallback.
+      # First matching subtables take precedence; distinct lookups are summed.
+      # Supports PairPos formats 1 and 2 in lookup types 2 and 9. Pass raw GDEF
+      # bytes with gdef: font.table_data["GDEF"] for glyph-filtering lookups.
+      # Lazy SFNT fonts can use font.sfnt_table("GDEF").load_data!.data instead.
+      # Filters apply to supplied pair endpoints; this does not shape a stream.
+      # Other lookup types, device corrections and variations are not applied.
+      # @return [Enumerable] nonzero glyph-ID pairs and signed advances
+      # @raise [ParseError] malformed selected positioning data
+      # @raise [UnsupportedFormatError] selected filtering requires missing GDEF data
+      def kern_pairs(script_tag: "latn", feature_tag: "kern", glyph_count: nil, gdef: nil)
+        KerningPairs.new(self, script_tag: script_tag, feature_tag: feature_tag,
+                               glyph_count: glyph_count, gdef: gdef)
+      end
+
       private
 
       # Get feature indices for a given script
@@ -107,3 +128,5 @@ module Fontisan
     end
   end
 end
+
+require "fontisan/tables/gpos/kerning_pairs"

data/lib/fontisan/tables/post.rb

@@ -14,7 +14,7 @@ module Fontisan
 
       register_tag "post"
       # Standard Mac glyph names for version 1.0 (258 glyphs)
-      # rubocop:disable Metrics/CollectionLiteralLength
+      # rubocop:disable-next Metrics/CollectionLiteralLength
       STANDARD_NAMES = %w[
         .notdef .null nonmarkingreturn space exclam quotedbl numbersign
         dollar percent ampersand quotesingle parenleft parenright asterisk
@@ -48,7 +48,6 @@ module Fontisan
         Gbreve gbreve Idotaccent Scedilla scedilla Cacute cacute Ccaron
         ccaron dcroat
       ].freeze
-      # rubocop:enable Metrics/CollectionLiteralLength
 
       # Version 2.0 as Fixed 16.16 constant
       VERSION_2_0_RAW = 131_072 # 2.0 * 65536
@@ -99,7 +98,7 @@ module Fontisan
       #
       # Version 2.0 uses a combination of standard Mac names (indices 0-257)
       # and custom names (indices >= 258) stored as Pascal strings.
-      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/PerceivedComplexity
       def parse_version_2_names
         return [] unless version_raw == VERSION_2_0_RAW
         return [] if remaining_data.empty?
@@ -145,7 +144,6 @@ module Fontisan
           end
         end
       end
-      # rubocop:enable Metrics/PerceivedComplexity
 
       public
 

data/lib/fontisan/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fontisan
-  VERSION = "0.4.45"
+  VERSION = "0.4.46"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fontisan
 version: !ruby/object:Gem::Version
-  version: 0.4.45
+  version: 0.4.46
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -322,7 +322,6 @@ files:
 - docs/public/web-app-manifest-512x512.png
 - docs/scripts/post-build.mjs
 - exe/fontisan
-- fontisan.gemspec
 - lib/fontisan.rb
 - lib/fontisan/audit.rb
 - lib/fontisan/audit/check.rb
@@ -644,6 +643,9 @@ files:
 - lib/fontisan/tables/glyf/simple_glyph.rb
 - lib/fontisan/tables/glyf_table.rb
 - lib/fontisan/tables/gpos.rb
+- lib/fontisan/tables/gpos/glyph_filter.rb
+- lib/fontisan/tables/gpos/kerning_pairs.rb
+- lib/fontisan/tables/gpos/pair_position.rb
 - lib/fontisan/tables/gsub.rb
 - lib/fontisan/tables/gvar.rb
 - lib/fontisan/tables/head.rb

data/fontisan.gemspec

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/fontisan/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "fontisan"
-  spec.version = Fontisan::VERSION
-  spec.authors = ["Ribose Inc."]
-  spec.email = ["open.source@ribose.com"]
-
-  spec.summary = "Font analysis tools and utilities for OpenType fonts"
-  spec.description = <<~HEREDOC
-    Fontisan provides font analysis tools and utilities. It is
-    designed as a pure Ruby implementation with full object-oriented architecture,
-    supporting extraction of information from OpenType and TrueType fonts (OTF, TTF, OTC, TTC).
-
-    The gem provides both a Ruby library API and a command-line interface,
-    with structured output formats (YAML, JSON, text).
-  HEREDOC
-
-  spec.homepage = "https://github.com/fontist/fontisan"
-  spec.license = "BSD-2-Clause"
-  spec.required_ruby_version = ">= 3.0.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/fontist/fontisan"
-  spec.metadata["changelog_uri"] = "https://github.com/fontist/fontisan/blob/main/CHANGELOG.md"
-  spec.metadata["rubygems_mfa_required"] = "true"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "base64"
-  spec.add_dependency "bindata", "~> 2.5"
-  spec.add_dependency "brotli", "~> 0.5"
-  spec.add_dependency "logger"
-  spec.add_dependency "lutaml-model", "~> 0.8"
-  spec.add_dependency "nokogiri", "~> 1.16"
-  spec.add_dependency "thor", "~> 1.3"
-end