gamba 2.0.0

data/lib/gamba/true_type/file.rb

@@ -0,0 +1,372 @@
+# frozen_string_literal: true
+
+module Gamba
+  module TrueType
+    class Error < StandardError
+    end
+
+    # The tables of a TrueType font that layout and embedding need, read once from its bytes: from a .ttf, one
+    # font of a .ttc collection, or one sfnt resource of a Mac .dfont.
+    class File
+      TRUE_TYPE_VERSIONS = ["\x00\x01\x00\x00".b, "true".b].freeze
+      COLLECTION_TAG = "ttcf".b
+      UNICODE_CMAP_FORMATS = [4, 6, 10, 12].freeze
+      REQUIRED_TABLES = %w[head hhea maxp hmtx cmap].freeze
+      # The fewest bytes a table may hold (head and hhea: their fixed sizes, OS/2: Apple's 68-byte version 0): shorter,
+      # the fields read at fixed offsets would read as nil or past its end.
+      MINIMUM_TABLE_SIZES = {"head" => 54, "hhea" => 36, "maxp" => 6, "OS/2" => 68, "post" => 16}.freeze
+      # Reading past the data a malformed font declares raises these: they become a TrueType::Error.
+      MALFORMED_FONT_ERRORS = [ArgumentError, TypeError, RangeError, NoMethodError, FloatDomainError].freeze
+      MAXIMUM_CODE_POINT = 0x10FFFF
+
+      Header = Data.define(:units_per_em, :x_min, :y_min, :x_max, :y_max, :index_to_location_format)
+
+      FILES_BY_KEY = {}
+      FILES_LOCK = Mutex.new
+
+      # Parsed fonts are shared by every document of the process, until their file changes.
+      def self.open(path, index: 0, resource: false)
+        key = [::File.expand_path(path), index, resource, ::File.mtime(path)]
+        FILES_LOCK.synchronize { FILES_BY_KEY[key] ||= new(::File.binread(path), index:, resource:) }
+      end
+
+      attr_reader :bytes, :offset
+
+      def initialize(bytes, index: 0, resource: false)
+        @bytes = bytes.b.freeze
+        @offset = resource ? resource_offset(index) : 0
+        @offset = collection_offset(index) if @bytes.byteslice(@offset, 4) == COLLECTION_TAG
+        @location_by_tag = read_table_directory
+        validate!
+      rescue *MALFORMED_FONT_ERRORS => exception
+        raise Error, "Malformed font: #{exception.message}"
+      end
+
+      def table?(tag)
+        @location_by_tag.key?(tag)
+      end
+
+      def table(tag)
+        offset, length = @location_by_tag[tag]
+        @bytes.byteslice(offset, length) if offset
+      end
+
+      def outline_format
+        if table?("glyf") then :true_type
+        elsif table?("CFF ") then :open_type
+        else :unknown
+        end
+      end
+
+      def header
+        @header ||= begin
+          units_per_em, x_min, y_min, x_max, y_max = table("head").unpack("@18 n x16 s>4")
+          Header.new(units_per_em:, x_min:, y_min:, x_max:, y_max:, index_to_location_format: table("head").unpack1("@50 s>"))
+        end
+      end
+
+      def glyph_count
+        @glyph_count ||= table("maxp").unpack1("@4 n")
+      end
+
+      # The OS/2 typographic metric when present and not zero, the hhea one otherwise.
+      def ascent
+        @ascent ||= nonzero_os2(:ascent) || horizontal_header[0]
+      end
+
+      def descent
+        @descent ||= nonzero_os2(:descent) || horizontal_header[1]
+      end
+
+      def line_gap
+        @line_gap ||= nonzero_os2(:line_gap) || horizontal_header[2]
+      end
+
+      def os2
+        @os2 ||= begin
+          os2 = table("OS/2")
+          if os2
+            version = os2.unpack1("n")
+            family_class = os2.unpack1("@30 s>")
+            ascent, descent, line_gap = os2.unpack("@68 s>3")
+            x_height, cap_height = os2.unpack("@86 s>2") if version >= 2 && os2.bytesize >= 90
+            {family_class:, ascent:, descent:, line_gap:, x_height:, cap_height:}
+          else
+            {}
+          end
+        end
+      end
+
+      def italic_angle_fixed
+        table("post")&.unpack1("@4 N")
+      end
+
+      def fixed_pitch?
+        table("post")&.unpack1("@12 N").to_i != 0
+      end
+
+      def postscript_name
+        @postscript_name ||= name_string(6) || name_string(1) || "unnamed"
+      end
+
+      def font_name
+        name_string(4)
+      end
+
+      def family_name
+        name_string(1)
+      end
+
+      # Underline position and thickness from the post table, in font units.
+      def underline_metrics
+        table("post").unpack("@8 s>2")
+      end
+
+      def strikeout_position
+        table("OS/2").unpack1("@28 s>")
+      end
+
+      # The lowest and highest points of a glyph's outline, in font units, from its glyf header.
+      def glyph_vertical_bounds(glyph)
+        data = glyph_data(glyph)
+        return [0, 0] if data.bytesize < 10
+
+        data.unpack("@4 s> x2 s>")
+      end
+
+      # Advance widths in font units, one per glyph: glyphs past the last metric share its advance.
+      def advance_widths
+        @advance_widths ||= begin
+          metric_count = horizontal_header[3]
+          raise Error, "Malformed font: no horizontal metrics" unless metric_count.between?(1, table("hmtx").bytesize / 4)
+          widths = table("hmtx").unpack("n*").each_slice(2).first(metric_count).map!(&:first)
+          widths + ([widths.last] * (glyph_count - metric_count))
+        end
+      end
+
+      def glyph_by_code
+        @glyph_by_code ||= read_unicode_cmap || raise(Error, "No unicode cmap found in font")
+      end
+
+      def unicode_cmap?
+        !read_unicode_cmap.nil?
+      end
+
+      def kerning?
+        !kerning_by_glyph_key.empty?
+      end
+
+      # Kerning between two glyphs, in font units, or nil.
+      def kerning_offset(left, right)
+        kerning_by_glyph_key[(left << 16) | right]
+      end
+
+      def glyph_data(glyph)
+        offsets = glyph_offsets
+        start = offsets[glyph]
+        table_bytes = glyf_table
+        table_bytes.byteslice(start, offsets[glyph + 1] - start) || "".b
+      end
+
+      private
+
+      # Fonts may come from users: everything layout reads later is read and checked once, here.
+      def validate!
+        missing = REQUIRED_TABLES.reject { table?(_1) }
+        raise Error, "Malformed font: no #{missing.join(", ")} table" unless missing.empty?
+        raise Error, "Malformed font: no outlines" if outline_format == :unknown
+
+        @location_by_tag.each do |tag, (offset, length)|
+          raise Error, "Malformed font: the #{tag} table lies outside the file" if offset + length > @bytes.bytesize
+          raise Error, "Malformed font: its #{tag} table is too short" if length < MINIMUM_TABLE_SIZES.fetch(tag, 0)
+        end
+        raise Error, "Malformed font: no glyphs" unless glyph_count.positive?
+        # Glyph units scale to text space by 1000 / unitsPerEm: zero would make every metric infinite.
+        raise Error, "Malformed font: its unitsPerEm is zero" if header.units_per_em.zero?
+
+        advance_widths
+        read_unicode_cmap
+        kerning_by_glyph_key
+        validate_glyph_offsets! if outline_format == :true_type
+      end
+
+      def validate_glyph_offsets!
+        offsets = glyph_offsets
+        glyf_size = glyf_table.bytesize
+        valid = offsets.size == glyph_count + 1 && offsets.each_cons(2).all? { |start, finish| start <= finish } && offsets.last <= glyf_size
+        raise Error, "Malformed font: its glyph locations do not fit its glyph table" unless valid
+      end
+
+      def horizontal_header
+        @horizontal_header ||= begin
+          ascent, descent, line_gap = table("hhea").unpack("@4 s>3")
+          [ascent, descent, line_gap, table("hhea").unpack1("@34 n")]
+        end
+      end
+
+      def nonzero_os2(metric)
+        value = os2[metric]
+        value if value&.nonzero?
+      end
+
+      def glyf_table
+        @glyf_table ||= table("glyf")
+      end
+
+      def glyph_offsets
+        @glyph_offsets ||=
+          if header.index_to_location_format.zero?
+            table("loca").unpack("n#{glyph_count + 1}").map { _1 * 2 }
+          else
+            table("loca").unpack("N#{glyph_count + 1}")
+          end
+      end
+
+      # The first kerning subtable's values, keyed by `left << 16 | right` like its records.
+      def kerning_by_glyph_key
+        @kerning_by_glyph_key ||= begin
+          kern = table("kern")
+          subtable = nil
+          if kern
+            version = kern.unpack1("n")
+            if version == 1
+              length, coverage = kern.unpack("@8 N n")
+              subtable = kern.byteslice(16, length - 8) if (coverage & 0xFF).zero?
+            elsif kern.unpack1("@2 n").positive?
+              coverage = kern.unpack1("@8 n")
+              subtable = kern.byteslice(10..) if (coverage >> 8).zero?
+            end
+          end
+          subtable ? format0_kerning_by_glyph_key(subtable) : {}
+        end
+      end
+
+      # A format 0 record is a uint32 glyph pair key then an int16 value: `N s>` reads both as they are stored.
+      def format0_kerning_by_glyph_key(subtable)
+        pair_count = [subtable.unpack1("n"), (subtable.bytesize - 8) / 6].min
+        Hash[*subtable.unpack("@8 #{"N s>" * pair_count}")]
+      end
+
+      def read_table_directory
+        version, table_count = @bytes.unpack("@#{@offset} a4 n")
+        raise Error, "Not a TrueType font" unless TRUE_TYPE_VERSIONS.include?(version) || version == "OTTO"
+
+        Array.new(table_count) do |index|
+          tag, _checksum, offset, length = @bytes.unpack("@#{@offset + 12 + (index * 16)} a4 N3")
+          [tag, [offset + (@offset_base || 0), length]]
+        end.to_h
+      end
+
+      def collection_offset(index)
+        font_count = @bytes.unpack1("@8 N")
+        raise Error, "Font index #{index} out of a collection of #{font_count}" if index >= font_count
+
+        @bytes.unpack1("@#{12 + (index * 4)} N")
+      end
+
+      # A Mac resource fork: table offsets in its sfnt resources count from the resource's own start.
+      def resource_offset(index)
+        data_offset, map_offset = @bytes.unpack("N2")
+        type_list_offset, name_list_offset = @bytes.unpack("@#{map_offset + 24} n2")
+        type_list = map_offset + type_list_offset
+        type_count = @bytes.unpack1("@#{type_list} n") + 1
+        type_count.times do |type_index|
+          type, count, reference_list_offset = @bytes.unpack("@#{type_list + 2 + (type_index * 8)} a4 n2")
+          next unless type == "sfnt"
+
+          references = Array.new(count + 1) do |reference_index|
+            reference = type_list + reference_list_offset + (reference_index * 12)
+            _id, name_offset, attributes_and_offset = @bytes.unpack("@#{reference} n2 N")
+            name = (@bytes.byteslice(map_offset + name_list_offset + name_offset + 1, @bytes.getbyte(map_offset + name_list_offset + name_offset)) unless name_offset == 0xFFFF)
+            [name, data_offset + (attributes_and_offset & 0xFFFFFF) + 4]
+          end
+          chosen = index.is_a?(String) ? references.assoc(index) : references[index]
+          raise Error, "No font #{index.inspect} in this resource file" unless chosen
+
+          @offset_base = chosen[1]
+          return chosen[1]
+        end
+        raise Error, "No sfnt resource in this resource file"
+      end
+
+      def read_unicode_cmap
+        return @unicode_cmap if defined?(@unicode_cmap)
+
+        cmap = table("cmap")
+        subtable_count = cmap.unpack1("@2 n")
+        candidates = Array.new(subtable_count) do |index|
+          platform, encoding, offset = cmap.unpack("@#{4 + (index * 8)} n2 N")
+          format = cmap.unpack1("@#{offset} n")
+          next unless UNICODE_CMAP_FORMATS.include?(format)
+          windows_unicode = platform == 3 && [1, 10].include?(encoding)
+          next unless windows_unicode || platform.zero?
+
+          [format, offset]
+        end.compact
+        format, offset = candidates.max_by(&:first)
+        @unicode_cmap = format && parse_cmap(cmap, format, offset)
+      end
+
+      def parse_cmap(cmap, format, offset)
+        glyph_by_code = {}
+        case format
+        when 4
+          segment_count = cmap.unpack1("@#{offset + 6} n") / 2
+          ends = cmap.unpack("@#{offset + 14} n#{segment_count}")
+          starts_offset = offset + 16 + (segment_count * 2)
+          starts = cmap.unpack("@#{starts_offset} n#{segment_count}")
+          deltas = cmap.unpack("@#{starts_offset + (segment_count * 2)} n#{segment_count}")
+          range_offsets_offset = starts_offset + (segment_count * 4)
+          range_offsets = cmap.unpack("@#{range_offsets_offset} n#{segment_count}")
+          segment_count.times do |segment|
+            (starts[segment]..ends[segment]).each do |code|
+              glyph =
+                if range_offsets[segment].zero?
+                  (code + deltas[segment]) & 0xFFFF
+                else
+                  glyph_offset = range_offsets_offset + (segment * 2) + range_offsets[segment] + ((code - starts[segment]) * 2)
+                  raw = cmap.unpack1("@#{glyph_offset} n").to_i
+                  raw.zero? ? 0 : (raw + deltas[segment]) & 0xFFFF
+                end
+              glyph_by_code[code] = glyph
+            end
+          end
+        when 6
+          first_code, count = cmap.unpack("@#{offset + 6} n2")
+          count = [count, (cmap.bytesize - offset - 10) / 2].min
+          cmap.unpack("@#{offset + 10} n#{count}").each_with_index { |glyph, index| glyph_by_code[first_code + index] = glyph }
+        when 10
+          first_code, count = cmap.unpack("@#{offset + 12} N2")
+          count = [count, (cmap.bytesize - offset - 20) / 2].min
+          cmap.unpack("@#{offset + 20} n#{count}").each_with_index { |glyph, index| glyph_by_code[first_code + index] = glyph }
+        when 12
+          group_count = [cmap.unpack1("@#{offset + 12} N"), (cmap.bytesize - offset - 16) / 12].min
+          cmap.unpack("@#{offset + 16} N#{group_count * 3}").each_slice(3) do |start_code, end_code, start_glyph|
+            (start_code..[end_code, MAXIMUM_CODE_POINT].min).each { |code| glyph_by_code[code] = start_glyph + (code - start_code) }
+          end
+        end
+        glyph_by_code.each { |code, glyph| glyph_by_code[code] = 0 if glyph >= glyph_count }
+        glyph_by_code.default = 0
+        glyph_by_code.freeze
+      end
+
+      def name_string(name_id)
+        name = table("name")
+        return unless name
+
+        count, strings_offset = name.unpack("@2 n2")
+        records = Array.new(count) { |record_index| name.unpack("@#{6 + (record_index * 12)} n6") }
+        record = records.find { |platform, _, _, id| id == name_id && platform == 3 } ||
+          records.find { |platform, _, _, id| id == name_id && platform == 1 } ||
+          records.find { |_, _, _, id| id == name_id }
+        return unless record
+
+        platform, _encoding, _language, _id, length, offset = record
+        raw = name.byteslice(strings_offset + offset, length)
+        (platform == 1) ? raw.force_encoding(::Encoding::MacRoman).encode(::Encoding::UTF_8) : raw.force_encoding(::Encoding::UTF_16BE).encode(::Encoding::UTF_8)
+      rescue ::Encoding::UndefinedConversionError, ::Encoding::InvalidByteSequenceError
+        nil
+      end
+    end
+  end
+end

data/lib/gamba/true_type/open_type_layout.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Gamba
+  module TrueType
+    # The parts of OpenType's GSUB and GPOS tables (OpenType specification, "OpenType Layout") Gamba applies on
+    # request: ligatures (GSUB lookup type 4) and pair kerning (GPOS lookup type 2), for the font's Latin script.
+    class OpenTypeLayout
+      LIGATURE_SUBSTITUTION = 4
+      GSUB_EXTENSION = 7
+      PAIR_ADJUSTMENT = 2
+      GPOS_EXTENSION = 9
+      X_ADVANCE = 0x0004
+      PREFERRED_SCRIPTS = ["latn", "DFLT"].freeze
+
+      def initialize(file, features)
+        @file = file
+        @features = features.map(&:to_s)
+        @ligatures_by_first_glyph = read_ligatures
+        @pair_lookups = read_pair_lookups
+      end
+
+      # Glyphs and the characters each stands for, ligatures applied: [[glyph, [code, …]], …].
+      def shape(codes)
+        clusters = codes.map { |code| [@file.glyph_by_code[code], [code]] }
+        return clusters if @ligatures_by_first_glyph.empty?
+
+        shaped = []
+        index = 0
+        while index < clusters.size
+          ligature = (@ligatures_by_first_glyph[clusters[index][0]] || []).find do |components, _|
+            components.each_with_index.all? { |component, offset| clusters[index + 1 + offset]&.first == component }
+          end
+          if ligature
+            components, glyph = ligature
+            shaped << [glyph, clusters[index, components.size + 1].flat_map(&:last)]
+            index += components.size + 1
+          else
+            shaped << clusters[index]
+            index += 1
+          end
+        end
+        shaped
+      end
+
+      # The horizontal advance adjustment between two glyphs, in font units, or nil.
+      def kerning(left, right)
+        @pair_lookups.each do |lookup|
+          adjustment = lookup.call(left, right)
+          return adjustment if adjustment
+        end
+        nil
+      end
+
+      private
+
+      def read_ligatures
+        table = @file.table("GSUB")
+        return {} unless table && @features.include?("liga")
+
+        ligatures = Hash.new { |hash, glyph| hash[glyph] = [] }
+        lookups(table, "liga", LIGATURE_SUBSTITUTION, GSUB_EXTENSION).each do |subtable|
+          next unless table.unpack1("@#{subtable} n") == 1
+
+          coverage = coverage_glyphs(table, subtable + table.unpack1("@#{subtable + 2} n"))
+          set_count = table.unpack1("@#{subtable + 4} n")
+          table.unpack("@#{subtable + 6} n#{set_count}").each_with_index do |set_offset, index|
+            set = subtable + set_offset
+            table.unpack("@#{set + 2} n#{table.unpack1("@#{set} n")}").each do |ligature_offset|
+              ligature = set + ligature_offset
+              glyph, component_count = table.unpack("@#{ligature} n2")
+              ligatures[coverage[index]] << [table.unpack("@#{ligature + 4} n#{component_count - 1}"), glyph]
+            end
+          end
+        end
+        ligatures.transform_values { |list| list.sort_by { |components, _glyph| -components.size } }
+      end
+
+      def read_pair_lookups
+        table = @file.table("GPOS")
+        return [] unless table && @features.include?("kern")
+
+        lookups(table, "kern", PAIR_ADJUSTMENT, GPOS_EXTENSION).filter_map { pair_lookup(table, _1) }
+      end
+
+      def pair_lookup(table, subtable)
+        format, coverage_offset, first_format, second_format = table.unpack("@#{subtable} n4")
+        return unless (first_format & X_ADVANCE).nonzero?
+
+        coverage = coverage_index(table, subtable + coverage_offset)
+        advance_position = 2 * (first_format & (X_ADVANCE - 1)).digits(2).count(1)
+        record_size = 2 * (first_format.digits(2).count(1) + second_format.digits(2).count(1))
+        case format
+        when 1
+          set_offsets = table.unpack("@#{subtable + 10} n#{table.unpack1("@#{subtable + 8} n")}")
+          lambda do |left, right|
+            index = coverage[left]
+            next unless index
+
+            set = subtable + set_offsets[index]
+            count = table.unpack1("@#{set} n")
+            record = (0...count).find { |candidate| table.unpack1("@#{set + 2 + (candidate * (record_size + 2))} n") == right }
+            record && table.unpack1("@#{set + 4 + (record * (record_size + 2)) + advance_position} s>")
+          end
+        when 2
+          first_classes = class_definition(table, subtable + table.unpack1("@#{subtable + 8} n"))
+          second_classes = class_definition(table, subtable + table.unpack1("@#{subtable + 10} n"))
+          _first_count, second_count = table.unpack("@#{subtable + 12} n2")
+          lambda do |left, right|
+            next unless coverage[left]
+
+            record = (first_classes[left] * second_count) + second_classes[right]
+            table.unpack1("@#{subtable + 16 + (record * record_size) + advance_position} s>").then { |adjustment| adjustment.zero? ? nil : adjustment }
+          end
+        end
+      end
+
+      # Subtables of the lookups a feature uses for the preferred script's default language, of the given type.
+      def lookups(table, feature_tag, type, extension_type)
+        script_list, feature_list, lookup_list = table.unpack("@4 n3")
+        feature_indices = default_language_features(table, script_list)
+        feature_count = table.unpack1("@#{feature_list} n")
+        lookup_indices = feature_indices.flat_map do |feature_index|
+          next [] if feature_index >= feature_count
+
+          tag, offset = table.unpack("@#{feature_list + 2 + (feature_index * 6)} a4 n")
+          next [] unless tag == feature_tag
+
+          feature = feature_list + offset
+          table.unpack("@#{feature + 4} n#{table.unpack1("@#{feature + 2} n")}")
+        end
+        lookup_indices.uniq.flat_map do |lookup_index|
+          lookup = lookup_list + table.unpack1("@#{lookup_list + 2 + (lookup_index * 2)} n")
+          lookup_type, _flags, subtable_count = table.unpack("@#{lookup} n3")
+          table.unpack("@#{lookup + 6} n#{subtable_count}").filter_map do |offset|
+            subtable = lookup + offset
+            if lookup_type == extension_type
+              actual_type, extension_offset = table.unpack("@#{subtable + 2} n N")
+              subtable + extension_offset if actual_type == type
+            elsif lookup_type == type
+              subtable
+            end
+          end
+        end
+      end
+
+      def default_language_features(table, script_list)
+        script_count = table.unpack1("@#{script_list} n")
+        offset_by_tag = Array.new(script_count) { |script_index| table.unpack("@#{script_list + 2 + (script_index * 6)} a4 n") }.to_h
+        script_offset = offset_by_tag.values_at(*PREFERRED_SCRIPTS).find { !_1.nil? } || offset_by_tag.values.first
+        return [] unless script_offset
+
+        script = script_list + script_offset
+        language_offset = table.unpack1("@#{script} n")
+        return [] if language_offset.zero?
+
+        language = script + language_offset
+        table.unpack("@#{language + 6} n#{table.unpack1("@#{language + 4} n")}")
+      end
+
+      def coverage_glyphs(table, offset)
+        coverage_index(table, offset).sort_by(&:last).map(&:first)
+      end
+
+      def coverage_index(table, offset)
+        format, count = table.unpack("@#{offset} n2")
+        if format == 1
+          table.unpack("@#{offset + 4} n#{count}").each_with_index.to_h
+        else
+          table.unpack("@#{offset + 4} n#{count * 3}").each_slice(3).each_with_object({}) do |(first, last, start_index), index|
+            (first..last).each { |glyph| index[glyph] = start_index + (glyph - first) }
+          end
+        end
+      end
+
+      def class_definition(table, offset)
+        classes = Hash.new(0)
+        format = table.unpack1("@#{offset} n")
+        if format == 1
+          start, count = table.unpack("@#{offset + 2} n2")
+          table.unpack("@#{offset + 6} n#{count}").each_with_index { |glyph_class, index| classes[start + index] = glyph_class }
+        else
+          count = table.unpack1("@#{offset + 2} n")
+          table.unpack("@#{offset + 4} n#{count * 3}").each_slice(3) { |first, last, value| (first..last).each { classes[_1] = value } }
+        end
+        classes
+      end
+    end
+  end
+end

data/lib/gamba/true_type/simple_subsets.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Gamba
+  module TrueType
+    # Characters of a TrueType font split into simple fonts of single-byte codes, laid out as Prawn lays them
+    # (through TTFunk) so every reader renders them the same way: the first subset codes characters in Mac Roman,
+    # the next ones take 223 characters each, from code 33. Every subset holds the space at 32, for word spacing: like
+    # TTFunk, a space stays in the subset of the character before it.
+    class SimpleSubsets
+      Subset = Struct.new(:code_by_cluster, :glyph_by_code, :next_code) do
+        def full?
+          next_code > 255
+        end
+      end
+
+      SPACE = 32
+      FIRST_FREE_CODE = 33
+
+      def initialize(glyph_for_cluster)
+        @glyph_for_cluster = glyph_for_cluster
+        @location_by_cluster = {}
+        @subsets = [Subset.new({SPACE => SPACE}, {SPACE => glyph_for_cluster.call([SPACE])}, nil)]
+      end
+
+      def size
+        @subsets.size
+      end
+
+      def [](index)
+        @subsets[index]
+      end
+
+      # [[subset index, bytes], …] for clusters of characters, each cluster [glyph, codes].
+      def encode(clusters)
+        parts = []
+        clusters.each do |glyph, codes|
+          if !parts.empty? && (codes == [SPACE] || codes == SPACE) && glyph == @subsets[0].glyph_by_code[SPACE]
+            parts.last[1] << SPACE
+          else
+            append(parts, *(@location_by_cluster[codes] ||= code_for([glyph, codes])))
+          end
+        end
+        parts
+      end
+
+      # The same for single characters, by code point: the common case, where a character already given its code
+      # costs a single hash access, and its glyph is only looked up the first time.
+      def encode_codepoints(codepoints, glyph_by_code)
+        parts = []
+        codepoints.each do |codepoint|
+          if codepoint == SPACE && !parts.empty?
+            parts.last[1] << SPACE
+          else
+            index, code = @location_by_cluster[codepoint] ||= code_for([glyph_by_code[codepoint], codepoint])
+            append(parts, index, code)
+          end
+        end
+        parts
+      end
+
+      private
+
+      # Consecutive characters of one subset share a part, as in Prawn's TJ arrays.
+      def append(parts, index, code)
+        last = parts.last
+        if last.nil? || last[0] != index
+          parts << [index, code.chr(::Encoding::BINARY)]
+        else
+          last[1] << code
+        end
+      end
+
+      def code_for(cluster)
+        glyph, codes = cluster
+        key = codes
+        mac_roman = mac_roman_code(codes)
+        if mac_roman
+          @subsets[0].code_by_cluster[key] ||= mac_roman.tap { @subsets[0].glyph_by_code[mac_roman] = glyph }
+          return [0, mac_roman]
+        end
+
+        @subsets.each_with_index.drop(1).each do |subset, index|
+          code = subset.code_by_cluster[key]
+          return [index, code] if code
+        end
+        subset_index = @subsets.rindex { |subset| subset.next_code && !subset.full? } || begin
+          @subsets << Subset.new({[SPACE] => SPACE, SPACE => SPACE}, {SPACE => @glyph_for_cluster.call([SPACE])}, FIRST_FREE_CODE)
+          @subsets.size - 1
+        end
+        subset = @subsets[subset_index]
+        code = subset.next_code
+        subset.code_by_cluster[key] = code
+        subset.glyph_by_code[code] = glyph
+        subset.next_code += 1
+        [subset_index, code]
+      end
+
+      def mac_roman_code(codes)
+        codes = Array(codes)
+        return unless codes.size == 1
+
+        [codes.first].pack("U").encode(::Encoding::MacRoman).getbyte(0)
+      rescue ::Encoding::UndefinedConversionError
+        nil
+      end
+    end
+  end
+end