stationery 0.1.0 → 0.3.0

data/lib/stationery/fonts/font.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-require "digest/md5"
-
 module Stationery
   module Fonts
-    # One TrueType font as used by one document: measures text, encodes it as
-    # glyph ids and remembers which glyphs were drawn so only those are embedded.
+    # One font as used by one document: measures text, encodes it as
+    # character codes and remembers which glyphs were drawn so only those are
+    # embedded (TrueType) or so the widths and ToUnicode cover them (CFF).
     #
-    # Embedded as a Type0 font over a CIDFontType2 with Identity-H encoding and a
-    # ToUnicode map, so text extracts and searches correctly.
+    # Embedded as a Type0 font with Identity-H encoding and a ToUnicode map, so
+    # text extracts and searches correctly; the descendant CIDFont comes from
+    # Embedding::TrueType or Embedding::CFF.
     class Font
       OBLIQUE_SKEW = Math.tan(12 * Math::PI / 180)
 
@@ -17,132 +17,112 @@ module Stationery
       def initialize(ttf)
         @ttf = ttf
         @used = {}
-        @widths = {}
+        @pairs = {}
+        @glyphs = {}
+        @shapes = { true => {}, false => {} }
+        @advances = { true => {}, false => {} }
+        @kerns = { true => {}, false => {} }
+        @cid_keyed = ttf.cff? && ttf.cff.cid_keyed?
       end
 
       def inspect = "#<#{self.class} #{@ttf.postscript_name} used=#{@used.size}>"
 
-      def width_of(text, size, letter_spacing: 0)
-        units = text.each_char.sum { |char| @widths[char] ||= @ttf.advance(@ttf.glyph_id(char.ord)) }
-        scale(units, size) + (letter_spacing * text.length)
+      # Advances and kerning are remembered per string, so measuring the same
+      # word again (wrapping, then laying out the line) allocates nothing.
+      # Letter spacing is added per glyph, so a ligature counts once; any
+      # letter spacing turns ligatures off, as it does when drawing.
+      def width_of(text, size, letter_spacing: 0, kerning: false, ligatures: true)
+        ligatures &&= letter_spacing.zero?
+        width = scale(advance_units(text, ligatures), size) + (letter_spacing * shape(text, ligatures).first.size)
+        return width unless kerning
+
+        width + (kerning_units(text, ligatures) * size / 1000.0)
       end
 
       def ascender(size) = scale(@ttf.ascender, size)
       def descender(size) = -scale(@ttf.descender, size)
       def line_gap(size) = scale(@ttf.line_gap, size)
       def line_height(size) = ascender(size) + descender(size) + line_gap(size)
+      def x_height(size) = scale(@ttf.x_height, size)
       def underline_position(size) = scale(@ttf.underline_position, size)
       def underline_thickness(size) = scale(@ttf.underline_thickness, size)
       def strikeout_position(size) = scale(@ttf.strikeout_position, size)
       def strikeout_size(size) = scale(@ttf.strikeout_size, size)
-      def glyph?(char) = @ttf.glyph?(char)
+      def glyph?(char) = @glyphs.fetch(char) { @glyphs[char] = @ttf.glyph?(char) }
 
       def bold?
         @ttf.weight >= 600
       end
 
-      def encode(text)
-        text.each_char.map do |char|
-          gid = @ttf.glyph_id(char.ord)
-          @used[gid] ||= char
-          gid
-        end.pack("n*")
+      def encode(text) = glyph_run(text).gids.map { |gid| code(gid) }.pack("n*")
+
+      # `ligatures:` substitutes the font's standard ligatures; `kerning:`
+      # then fills the adjustments with pair kerning between the glyphs.
+      def glyph_run(text, kerning: false, ligatures: true)
+        gids, chars = shape(text, ligatures)
+        gids.each_with_index { |gid, i| @used[gid] ||= chars[i] }
+        adjust = gids.each_with_index.map { |gid, i| kerning && i + 1 < gids.size ? pair(gid, gids[i + 1]) : 0 }
+        GlyphRun.new(font: self, gids:, adjust:, chars:)
       end
 
       def used?
         @used.any?
       end
 
-      def build(writer)
-        gids = @used.keys.sort
-        subset, mapping = Subset.build(@ttf, gids)
-        name = :"#{subset_tag(gids)}+#{@ttf.postscript_name}"
-
-        writer.add(
-          Type: :Font, Subtype: :Type0, BaseFont: name, Encoding: :"Identity-H",
-          DescendantFonts: [cid_font(writer, name, gids, subset, mapping)],
-          ToUnicode: writer.add(PDF::Stream.new(to_unicode_cmap))
-        )
+      # The two-byte character code a glyph is written as: its CID in a
+      # CID-keyed CFF font, otherwise the glyph id itself.
+      def code(gid)
+        @cid_keyed ? @ttf.cff.cid_for(gid) : gid
       end
 
-      private
-
-      def cid_font(writer, name, gids, subset, mapping)
-        writer.add(
-          Type: :Font, Subtype: :CIDFontType2, BaseFont: name,
-          CIDSystemInfo: { Registry: "Adobe", Ordering: "Identity", Supplement: 0 },
-          FontDescriptor: descriptor(writer, name, subset),
-          DW: glyph_space(@ttf.advance(0)), W: glyph_widths(gids),
-          CIDToGIDMap: writer.add(PDF::Stream.new(cid_to_gid_map(gids, mapping)))
-        )
+      # { code => text } for every glyph drawn so far; a ligature's text is
+      # every character it stands for.
+      def used_codes
+        @used.to_h { |gid, char| [code(gid), char] }
       end
 
-      def descriptor(writer, name, subset)
+      def build(writer)
+        embedding = (@ttf.cff? ? Embedding::CFF : Embedding::TrueType).new(self)
+        name, cid_font = embedding.build(writer, @used.keys.sort)
+
         writer.add(
-          Type: :FontDescriptor, FontName: name, Flags: flags,
-          FontBBox: @ttf.bbox.map { |v| glyph_space(v) }, ItalicAngle: @ttf.italic_angle,
-          Ascent: glyph_space(@ttf.ascender), Descent: glyph_space(@ttf.descender),
-          CapHeight: glyph_space(@ttf.cap_height), XHeight: glyph_space(@ttf.x_height),
-          StemV: bold? ? 120 : 80,
-          FontFile2: writer.add(PDF::Stream.new(subset, { Length1: subset.bytesize }))
+          Type: :Font, Subtype: :Type0, BaseFont: name, Encoding: :"Identity-H",
+          DescendantFonts: [cid_font], ToUnicode: writer.add(PDF::Stream.new(ToUnicode.cmap(used_codes)))
         )
       end
 
-      def scale(units, size)
-        units * size / @ttf.units_per_em.to_f
-      end
+      private
 
-      def glyph_space(units)
-        (units * 1000.0 / @ttf.units_per_em).round
+      # [gids, source text of each glyph], remembered per string.
+      def shape(text, ligatures)
+        @shapes[ligatures][text] ||= begin
+          gids = text.each_char.map { |char| @ttf.glyph_id(char.ord) }
+          ligatures ? ligate(gids, text) : [gids, text.chars].each(&:freeze).freeze
+        end
       end
 
-      def flags
-        flags = 32 # Nonsymbolic
-        flags |= 1 if @ttf.fixed_pitch?
-        flags |= 64 unless @ttf.italic_angle.zero?
-        flags
+      def ligate(gids, text)
+        start = 0
+        glyphs = @ttf.ligatures.substitute(gids)
+        chars = glyphs.map { |_gid, count| text[start, count].tap { start += count } }
+        [glyphs.map(&:first), chars].each(&:freeze).freeze
       end
 
-      # Subset fonts are named with six uppercase letters: ABCDEF+OpenSans-Regular.
-      def subset_tag(gids)
-        Digest::MD5.digest(gids.pack("n*") + @ttf.postscript_name).bytes.first(6).map { |b| (65 + (b % 26)).chr }.join
+      def advance_units(text, ligatures)
+        @advances[ligatures][text] ||= shape(text, ligatures).first.sum { |gid| @ttf.advance(gid) }
       end
 
-      # Text uses the original glyph ids as CIDs; this maps them to the subset's ids.
-      def cid_to_gid_map(gids, mapping)
-        map = Array.new((gids.max || 0) + 1, 0)
-        gids.each { |gid| map[gid] = mapping.fetch(gid) }
-        map.pack("n*")
+      def kerning_units(text, ligatures)
+        @kerns[ligatures][text] ||= shape(text, ligatures).first.each_cons(2).sum { |left, right| pair(left, right) }
       end
 
-      def glyph_widths(gids)
-        gids.slice_when { |a, b| b != a + 1 }.flat_map do |run|
-          [run.first, run.map { |gid| glyph_space(@ttf.advance(gid)) }]
-        end
+      # Kerning between two glyphs in thousandths of an em.
+      def pair(left, right)
+        @pairs[(left << 16) | right] ||= @ttf.kerning.adjust(left, right) * 1000.0 / @ttf.units_per_em
       end
 
-      def to_unicode_cmap
-        mappings = @used.sort.map do |gid, char|
-          format("<%<gid>04X> <%<utf16>s>", gid:, utf16: char.encode(Encoding::UTF_16BE).unpack1("H*").upcase)
-        end
-        blocks = mappings.each_slice(100).map { |slice| "#{slice.size} beginbfchar\n#{slice.join("\n")}\nendbfchar" }
-
-        <<~CMAP
-          /CIDInit /ProcSet findresource begin
-          12 dict begin
-          begincmap
-          /CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def
-          /CMapName /Adobe-Identity-UCS def
-          /CMapType 2 def
-          1 begincodespacerange
-          <0000> <FFFF>
-          endcodespacerange
-          #{blocks.join("\n")}
-          endcmap
-          CMapName currentdict /CMap defineresource pop
-          end
-          end
-        CMAP
+      def scale(units, size)
+        units * size / @ttf.units_per_em.to_f
       end
     end
   end

data/lib/stationery/fonts/font_book.rb

@@ -6,30 +6,71 @@ module Stationery
     # document gets its own book so glyph usage (and so subsetting) is per
     # document, while the parsed TrueType data is shared through the Registry.
     class FontBook
-      attr_reader :families
+      attr_reader :families, :fallbacks, :warnings
 
-      def initialize(families = {})
+      # `fallbacks:` names the families tried, in order, for a character the
+      # run's own family has no glyph for.
+      def initialize(families = {}, fallbacks: [], warnings: Warnings.new)
         @families = families.dup
+        @fallbacks = fallbacks.map(&:to_s).freeze
+        @warnings = warnings
         @fonts = {}
+        @resolved = {}
+        @split = {}.compare_by_identity
       end
 
       def inspect = "#<#{self.class} families=#{@families.keys.inspect}>"
 
       def register(name, **paths)
-        @families[name.to_s] = Family.new(name, **paths)
+        @resolved.clear
+        @families[name.to_s] = Family.build(name, **paths)
       end
 
-      # Returns [Font, Family::Face] for a Text::Style.
+      # Returns [Font, Family::Face] for a Text::Style, memoised per style.
       def resolve(style)
-        face = family(style.family).face(weight: style.weight, style: style.style)
-        [@fonts[face.path] ||= Font.new(Registry.load(face.path)), face]
+        @resolved[style] ||= begin
+          face = family(style.family).face(weight: style.weight, style: style.style)
+          [@fonts[face.path] ||= Font.new(Registry.load(face.path)), face].freeze
+        end
+      end
+
+      # Whether `name` is registered, bundled or an installed pack.
+      def known?(name) = !(@families[name.to_s] || bundled(name) || pack(name)).nil?
+
+      # The runs split so every character is drawn by a font that has it. Runs
+      # this book already split come back as they are.
+      def fallback(runs)
+        return runs if @split.key?(runs)
+
+        (@fallback ||= Fallback.new(self)).apply(runs).tap { |split| @split[split] = true }
       end
 
       private
 
+      # Registered by name, bundled by name, an installed pack by name, then
+      # the first registered family, then the bundled default.
       def family(name)
-        @families[name.to_s] || @families.values.first ||
-          raise(Error, "no font registered; declare one with `font_family \"Name\", regular: \"path/to/font.ttf\"`")
+        @families[name.to_s] || bundled(name) || pack(name) || substitute(name)
+      end
+
+      # An unknown name draws with the first registered family, else bundled
+      # Inter, and says so once.
+      def substitute(name)
+        used = @families.values.first || bundled(Bundled::DEFAULT)
+        @warnings << Warnings::UnknownFamily.new(requested: name.to_s, used: used.name)
+        used
+      end
+
+      def bundled(name)
+        @bundled ||= {}
+        @bundled[name.to_s] ||= Bundled.family(name)
+      end
+
+      def pack(name)
+        @packs ||= {}
+        return @packs[name.to_s] if @packs.key?(name.to_s)
+
+        @packs[name.to_s] = Packs.family(name)
       end
     end
   end

data/lib/stationery/fonts/glyph_run.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Glyph ids for one run of text in one font, with an extra advance after
+    # each glyph in thousandths of the font size (positive widens) and the
+    # source text of each glyph (several characters for a ligature). All-zero
+    # adjustments draw as a plain Tj string; otherwise as a TJ array. Glyphs
+    # are written as the font's character codes (see Font#code).
+    GlyphRun = Data.define(:font, :gids, :adjust, :chars) do
+      def width(size, letter_spacing: 0)
+        units = gids.sum { |gid| font.ttf.advance(gid) }
+        (units * size / font.ttf.units_per_em.to_f) + (adjust.sum * size / 1000.0) + (letter_spacing * gids.size)
+      end
+
+      def with_word_spacing(extra_points, size)
+        extra = extra_points * 1000.0 / size
+        with(adjust: adjust.each_with_index.map { |a, i| chars[i] == " " ? a + extra : a })
+      end
+
+      def to_operator
+        return "<#{hex(gids)}> Tj" unless adjusted?
+
+        parts = gids.each_index.slice_after { |i| !adjust[i].zero? }.flat_map do |indices|
+          last = indices.last
+          chunk = ["<#{hex(indices.map { |i| gids[i] })}>"]
+          last == gids.size - 1 || adjust[last].zero? ? chunk : chunk << PDF::Serializer.number(-adjust[last])
+        end
+        "[#{parts.join(" ")}] TJ"
+      end
+
+      private
+
+      def adjusted? = adjust[0...-1].any? { |a| !a.zero? }
+
+      def hex(ids) = ids.map { |gid| font.code(gid) }.pack("n*").unpack1("H*").upcase
+    end
+  end
+end

data/lib/stationery/fonts/gpos/class_def.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gpos
+      # OpenType ClassDef table as a Hash of glyph id => class. Glyphs it
+      # does not list are class 0. Format 1 is a run of classes from a start
+      # glyph, format 2 ranges of glyphs sharing a class.
+      module ClassDef
+        def self.read(ttf, offset)
+          if ttf.u16(offset) == 1
+            start = ttf.u16(offset + 2)
+            classes = ttf.data.byteslice(offset + 6, ttf.u16(offset + 4) * 2).unpack("n*")
+            return classes.each_with_index.to_h { |klass, i| [start + i, klass] }.freeze
+          end
+
+          ranges = ttf.data.byteslice(offset + 4, ttf.u16(offset + 2) * 6).unpack("n*").each_slice(3)
+          ranges.each_with_object({}) do |(first, last, klass), map|
+            (first..last).each { |gid| map[gid] = klass }
+          end.freeze
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gpos/coverage.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gpos
+      # OpenType Coverage table: the glyphs a subtable applies to, in
+      # coverage-index order. Format 1 lists glyphs, format 2 ranges.
+      module Coverage
+        def self.read(ttf, offset)
+          count = ttf.u16(offset + 2)
+          return ttf.data.byteslice(offset + 4, count * 2).unpack("n*") if ttf.u16(offset) == 1
+
+          ttf.data.byteslice(offset + 4, count * 6).unpack("n*").each_slice(3).flat_map do |first, last, _index|
+            (first..last).to_a
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gpos/pair_pos.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gpos
+      # PairPos subtables (GPOS lookup type 2), keeping only the first glyph's
+      # X advance. `adjust` answers nil when the subtable does not apply, so
+      # the lookup tries its next subtable.
+      module PairPos
+        X_ADVANCE = 0x0004
+
+        def self.read(ttf, offset)
+          ttf.u16(offset) == 1 ? Pairs.read(ttf, offset) : Classes.read(ttf, offset)
+        end
+
+        # The first glyph's X advance of `count` records at `offset`, each
+        # `lead` 16-bit fields (a second glyph id) followed by two value
+        # records. A value record has one field per bit set in its format.
+        def self.x_advances(ttf, offset, count, format1, format2, lead: 0)
+          width = [lead + fields(format1) + fields(format2), 1].max
+          records = ttf.data.byteslice(offset, count * width * 2).unpack("s>*").each_slice(width)
+          return records.map { |record| [record.first & 0xFFFF, 0] } unless format1.anybits?(X_ADVANCE)
+
+          index = lead + fields(format1 & (X_ADVANCE - 1))
+          records.map { |record| [record.first & 0xFFFF, record[index]] }
+        end
+
+        def self.fields(format) = format.to_s(2).count("1")
+
+        # Format 1: explicit pairs, grouped by first glyph.
+        class Pairs
+          def self.read(ttf, offset)
+            format1 = ttf.u16(offset + 4)
+            format2 = ttf.u16(offset + 6)
+            pairs = {}
+            Coverage.read(ttf, offset + ttf.u16(offset + 2)).each_with_index do |left, i|
+              set = offset + ttf.u16(offset + 10 + (i * 2))
+              PairPos.x_advances(ttf, set + 2, ttf.u16(set), format1, format2, lead: 1).each do |right, value|
+                pairs[(left << 16) | right] = value
+              end
+            end
+            new(pairs)
+          end
+
+          def initialize(pairs)
+            @pairs = pairs.freeze
+            freeze
+          end
+
+          def adjust(left, right) = @pairs[(left << 16) | right]
+        end
+
+        # Format 2: a class-by-class matrix over two ClassDefs, kept as classes
+        # rather than expanded into every glyph pair.
+        class Classes
+          def self.read(ttf, offset)
+            format1 = ttf.u16(offset + 4)
+            format2 = ttf.u16(offset + 6)
+            columns = ttf.u16(offset + 14)
+            values = PairPos.x_advances(ttf, offset + 16, ttf.u16(offset + 12) * columns, format1, format2)
+            new(Coverage.read(ttf, offset + ttf.u16(offset + 2)),
+                ClassDef.read(ttf, offset + ttf.u16(offset + 8)), ClassDef.read(ttf, offset + ttf.u16(offset + 10)),
+                values.map(&:last).each_slice(columns).to_a)
+          end
+
+          def initialize(coverage, first_classes, second_classes, matrix)
+            @coverage = coverage.to_h { |gid| [gid, true] }.freeze
+            @first_classes = first_classes
+            @second_classes = second_classes
+            @matrix = matrix.each(&:freeze).freeze
+            freeze
+          end
+
+          def adjust(left, right)
+            return unless @coverage[left]
+
+            @matrix.dig(@first_classes.fetch(left, 0), @second_classes.fetch(right, 0)) || 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gpos.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Pair kerning from the GPOS `kern` feature: PairPos lookups (formats 1
+    # and 2), directly or behind Extension lookups. Scripts and languages are
+    # not distinguished; every lookup any `kern` feature record names applies.
+    # Adjustments are the first glyph's X advance, in font units.
+    class Gpos
+      PAIR = 2
+      EXTENSION = 9
+
+      # nil when the font has no GPOS table or no `kern` feature.
+      def self.parse(ttf)
+        base = ttf.table_offset("GPOS")
+        return unless base && ttf.u16(base) == 1
+
+        offsets = feature_lookups(ttf, base, "kern")
+        new(offsets.map { |offset| lookup(ttf, offset) }) if offsets.any?
+      end
+
+      # Offsets of the lookups every `tag` feature record of the GSUB or GPOS
+      # table at `base` names, in LookupList order.
+      def self.feature_lookups(ttf, base, tag)
+        list = base + ttf.u16(base + 6)
+        records = Array.new(ttf.u16(list)) { |i| list + 2 + (i * 6) }
+        indices = records.select { |record| ttf.data.byteslice(record, 4) == tag }.flat_map do |record|
+          feature = list + ttf.u16(record + 4)
+          Array.new(ttf.u16(feature + 2)) { |j| ttf.u16(feature + 4 + (j * 2)) }
+        end
+        lookups = base + ttf.u16(base + 8)
+        indices.uniq.sort.map { |i| lookups + ttf.u16(lookups + 2 + (i * 2)) }
+      end
+
+      # A lookup's PairPos subtables; other lookup types have none.
+      def self.lookup(ttf, offset)
+        type = ttf.u16(offset)
+        subtables = Array.new(ttf.u16(offset + 4)) { |i| offset + ttf.u16(offset + 6 + (i * 2)) }
+        subtables.filter_map do |subtable|
+          if type == PAIR
+            PairPos.read(ttf, subtable)
+          elsif type == EXTENSION && ttf.u16(subtable + 2) == PAIR
+            PairPos.read(ttf, subtable + ttf.u32(subtable + 4))
+          end
+        end.freeze
+      end
+      private_class_method :lookup
+
+      def initialize(lookups)
+        @lookups = lookups.freeze
+        freeze
+      end
+
+      # Within a lookup the first subtable that applies wins; lookups add up.
+      def adjust(left, right)
+        @lookups.sum do |subtables|
+          value = nil
+          subtables.find { |subtable| value = subtable.adjust(left, right) }
+          value || 0
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gsub/ligature_subst.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    class Gsub
+      # LigatureSubst format 1 (GSUB lookup type 4): for each first glyph, the
+      # ligatures starting with it, longest first.
+      class LigatureSubst
+        def self.read(ttf, offset)
+          return unless ttf.u16(offset) == 1
+
+          sets = Gpos::Coverage.read(ttf, offset + ttf.u16(offset + 2)).each_with_index.to_h do |first, i|
+            set = offset + ttf.u16(offset + 6 + (i * 2))
+            [first, ligatures(ttf, set).sort_by.with_index { |(rest, _), j| [-rest.size, j] }.freeze]
+          end
+          new(sets)
+        end
+
+        # [[component gids after the first, ligature gid], ...]
+        def self.ligatures(ttf, set)
+          Array.new(ttf.u16(set)) do |i|
+            ligature = set + ttf.u16(set + 2 + (i * 2))
+            count = ttf.u16(ligature + 2)
+            [ttf.data.byteslice(ligature + 4, (count - 1) * 2).unpack("n*").freeze, ttf.u16(ligature)]
+          end
+        end
+        private_class_method :ligatures
+
+        def initialize(sets)
+          @sets = sets.freeze
+          freeze
+        end
+
+        # [ligature gid, glyphs consumed] for the longest ligature at `index`, or nil.
+        def match(gids, index)
+          @sets[gids[index]]&.each do |components, ligature|
+            return [ligature, components.size + 1] if gids[index + 1, components.size] == components
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/stationery/fonts/gsub.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Standard ligatures from the GSUB `liga` feature: LigatureSubst lookups
+    # (format 1), directly or behind Extension lookups. Only `liga` applies;
+    # contextual (`clig`) and discretionary (`dlig`) ligatures are left out.
+    # Scripts, languages and lookup flags are not distinguished.
+    class Gsub
+      LIGATURE = 4
+      EXTENSION = 7
+
+      # nil when the font has no GSUB table or no `liga` ligatures.
+      def self.parse(ttf)
+        base = ttf.table_offset("GSUB")
+        return unless base && ttf.u16(base) == 1
+
+        lookups = Gpos.feature_lookups(ttf, base, "liga").map { |offset| lookup(ttf, offset) }.reject(&:empty?)
+        new(lookups) if lookups.any?
+      end
+
+      # A lookup's LigatureSubst subtables; other lookup types have none.
+      def self.lookup(ttf, offset)
+        type = ttf.u16(offset)
+        subtables = Array.new(ttf.u16(offset + 4)) { |i| offset + ttf.u16(offset + 6 + (i * 2)) }
+        subtables.filter_map do |subtable|
+          if type == LIGATURE
+            LigatureSubst.read(ttf, subtable)
+          elsif type == EXTENSION && ttf.u16(subtable + 2) == LIGATURE
+            LigatureSubst.read(ttf, subtable + ttf.u32(subtable + 4))
+          end
+        end.freeze
+      end
+      private_class_method :lookup
+
+      def initialize(lookups)
+        @lookups = lookups.freeze
+        freeze
+      end
+
+      # [[gid, number of source glyphs it stands for], ...]. Lookups apply in
+      # order; within one, the first subtable matching at a position wins and
+      # its glyph is not matched again by that lookup.
+      def substitute(gids)
+        @lookups.reduce(gids.map { |gid| [gid, 1] }) { |glyphs, subtables| apply(subtables, glyphs) }
+      end
+
+      private
+
+      def apply(subtables, glyphs)
+        ids = glyphs.map(&:first)
+        result = []
+        i = 0
+        while i < glyphs.size
+          match = nil
+          subtables.find { |subtable| match = subtable.match(ids, i) }
+          length = match ? match.last : 1
+          result << [match ? match.first : ids[i], glyphs[i, length].sum(&:last)]
+          i += length
+        end
+        result
+      end
+    end
+  end
+end