gamba 2.0.0

data/lib/gamba/fonts/afm.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Fonts
+    # The 14 standard PDF fonts, measured from Adobe's AFM files and written in WinAnsiEncoding.
+    class AFM < Font
+      BUILT_INS = %w[
+        Courier Helvetica Times-Roman Symbol ZapfDingbats Courier-Bold Courier-Oblique Courier-BoldOblique Times-Bold
+        Times-Italic Times-BoldItalic Helvetica-Bold Helvetica-Oblique Helvetica-BoldOblique
+      ].freeze
+      METRICS_BY_PATH = {}
+      METRICS_LOCK = Mutex.new
+
+      Metrics = Data.define(:width_by_byte, :kerning_by_byte_pair, :attributes)
+
+      class << self
+        attr_accessor :hide_m17n_warning
+      end
+      self.hide_m17n_warning = false
+
+      def self.metrics_path
+        @metrics_path ||= ENV["METRICS"]&.split(":") ||
+          [".", "/usr/lib/afm", "/usr/local/lib/afm", "/usr/openwin/lib/fonts/afm", "#{Prawn::DATADIR}/fonts"]
+      end
+
+      attr_reader :attributes
+
+      def initialize(document, name, options = {})
+        name ||= options[:family]
+        raise Errors::UnknownFont, "#{name} (#{options[:style] || "normal"}) is not a known font." unless BUILT_INS.include?(name)
+        if document.pdf_a?
+          raise Errors::PdfAViolation, "PDF/A embeds every font, which #{name}, a standard PDF font, cannot be: use a TrueType or OpenType font"
+        end
+
+        super
+        file_name = @name.end_with?(".afm") ? @name : "#{@name}.afm"
+        file_name = find_font(file_name) unless file_name.start_with?("/")
+        metrics = METRICS_LOCK.synchronize { METRICS_BY_PATH[file_name] ||= parse_afm(file_name) }
+        @width_by_byte = metrics.width_by_byte
+        @kerning_by_byte_pair = metrics.kerning_by_byte_pair
+        @attributes = metrics.attributes
+        @ascender = Integer(@attributes.fetch("ascender", "0"), 10)
+        @descender = Integer(@attributes.fetch("descender", "0"), 10)
+        @line_gap = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
+      end
+
+      def unicode?
+        false
+      end
+
+      def bbox
+        @bbox ||= @attributes["fontbbox"].split(/\s+/).map { Integer(_1) }
+      end
+
+      def compute_width_of(string, options = {})
+        scale = (options[:size] || size) / 1000.0
+        return unscaled_width_of(string) * scale unless options[:kerning]
+
+        strings, offsets = kern(string).partition { _1.is_a?(String) }
+        (unscaled_width_of(strings.join) - offsets.sum) * scale
+      end
+
+      def has_kerning_data?
+        !@kerning_by_byte_pair.empty?
+      end
+
+      def normalize_encoding(text)
+        text.encode(::Encoding::Windows_1252)
+      rescue ::Encoding::InvalidByteSequenceError, ::Encoding::UndefinedConversionError
+        raise Errors::IncompatibleStringEncoding,
+          "Your document includes text that's not compatible with the Windows-1252 character set.\n" \
+          "If you need full UTF-8 support, use external fonts instead of PDF's built-in fonts.\n"
+      end
+
+      def to_utf8(text)
+        text.encode(::Encoding::UTF_8)
+      end
+
+      def character_count(string)
+        string.length
+      end
+
+      def encode_text(text, options = {})
+        [[0, options[:kerning] ? kern(text) : text]]
+      end
+
+      def glyph_present?(character)
+        !normalize_encoding(character).nil?
+      rescue Errors::IncompatibleStringEncoding
+        false
+      end
+
+      private
+
+      def register(_subset)
+        dictionary = {Type: :Font, Subtype: :Type1, BaseFont: name.to_sym}
+        dictionary[:Encoding] = :WinAnsiEncoding unless symbolic?
+        @document.ref!(dictionary)
+      end
+
+      def symbolic?
+        attributes["characterset"] == "Special"
+      end
+
+      def find_font(file)
+        directory = self.class.metrics_path.find { |path| File.exist?("#{path}/#{file}") }
+        raise Errors::UnknownFont, "Couldn't find the font: #{file} in any of:\n#{self.class.metrics_path.join("\n")}" unless directory
+
+        "#{directory}/#{file}"
+      end
+
+      # Runs of bytes, separated by the kerning offset between two of them, in thousandths of the font size.
+      def kern(string)
+        runs = [String.new(encoding: ::Encoding::BINARY)]
+        last_byte = nil
+        string.each_byte do |byte|
+          offset = last_byte && @kerning_by_byte_pair[(last_byte << 8) | byte]
+          runs << -offset << String.new(encoding: ::Encoding::BINARY) if offset
+          runs.last << byte
+          last_byte = byte
+        end
+        runs.map { |run| run.is_a?(String) ? run.force_encoding(::Encoding::Windows_1252) : run }
+      end
+
+      def unscaled_width_of(string)
+        string.each_byte.sum { @width_by_byte[_1] }
+      end
+
+      def parse_afm(file_name)
+        width_by_name = {}
+        kerning_by_name_pair = {}
+        attributes = {}
+        sections = []
+        File.foreach(file_name) do |line|
+          if (section = line[/^Start(\w+)/, 1])
+            sections.push(section)
+          elsif line.start_with?("End")
+            sections.pop
+          else
+            case sections
+            when %w[FontMetrics CharMetrics]
+              next unless /^CH?\s/.match?(line)
+
+              width_by_name[line[/\bN\s+(\.?\w+)\s*;/, 1]] = Integer(line[/\bWX\s+(\d+)\s*;/, 1], 10)
+            when %w[FontMetrics KernData KernPairs]
+              next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
+
+              kerning_by_name_pair[[$1, $2]] = Integer($3, 10)
+            when %w[FontMetrics KernData TrackKern], %w[FontMetrics Composites]
+              next
+            else
+              next unless line =~ /(^\w+)\s+(.*)/
+
+              key = $1.downcase
+              attributes[key] = attributes[key] ? [*attributes[key], $2] : $2
+            end
+          end
+        end
+
+        byte_by_name = Encoding::WinAnsi::CHARACTERS.each_with_index.to_h
+        kerning_by_byte_pair = kerning_by_name_pair.each_with_object({}) do |((left, right), offset), table|
+          left_byte = byte_by_name[left]
+          right_byte = byte_by_name[right]
+          table[(left_byte << 8) | right_byte] = offset if left_byte && right_byte
+        end
+        width_by_byte = Encoding::WinAnsi::CHARACTERS.map { width_by_name.fetch(_1, 0) }
+        Metrics.new(width_by_byte: width_by_byte.freeze, kerning_by_byte_pair: kerning_by_byte_pair.freeze, attributes: attributes.freeze)
+      end
+    end
+  end
+end

data/lib/gamba/fonts/otf.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Fonts
+    # An OpenType font with CFF outlines, embedded as a Type0 font over a CIDFontType0: its character identifiers
+    # are glyph indices, as a CFF program that is not CID-keyed requires (ISO 32000-1 §9.7.4.2).
+    class OTF < TTF
+      def encode_text(text, options = {})
+        text = text.chomp
+        runs =
+          if @layout
+            Array(shaped_runs(text, options[:kerning]))
+          elsif options[:kerning]
+            kern(text).map { |run| run.is_a?(Numeric) ? run : glyph_string(run) }
+          else
+            [glyph_string(text.codepoints)]
+          end
+        runs = space_out_words(runs, options[:word_spacing], options[:font_size]) if options[:word_spacing].to_f.nonzero?
+        [[0, (runs.size == 1) ? runs.first : runs]]
+      end
+
+      private
+
+      def cluster_string(clusters)
+        clusters.map do |glyph, codes|
+          @code_by_glyph[glyph] ||= codes
+          glyph
+        end.pack("n*")
+      end
+
+      def embed(reference, _subset)
+        @code_by_glyph ||= {}
+        glyphs = [0, *@code_by_glyph.keys].uniq
+        font_name = :"#{subset_tag_for(glyphs)}+#{basename.delete("\0")[0, 33]}"
+        font_file = @document.ref!({Subtype: :CIDFontType0C}, Gamba::TrueType::CffSubset.new(@ttf.table("CFF ")).bytes(glyphs))
+        descriptor = @document.ref!(
+          Type: :FontDescriptor, FontName: font_name, FontBBox: bbox, Flags: pdf_flags, StemV: stem_v, ItalicAngle: italic_angle,
+          Ascent: @ascender, Descent: @descender, CapHeight: cap_height, XHeight: x_height, FontFile3: font_file
+        )
+        widths = glyphs.sort.flat_map { |glyph| [glyph, [Integer(@ttf.advance_widths[glyph] * scale_factor)]] }
+        descendant = @document.ref!(
+          Type: :Font, Subtype: :CIDFontType0, BaseFont: font_name, FontDescriptor: descriptor, W: widths,
+          CIDSystemInfo: {Registry: PDF::Core::LiteralString.new("Adobe"), Ordering: PDF::Core::LiteralString.new("Identity"), Supplement: 0}
+        )
+        reference.data.update(Subtype: :Type0, BaseFont: font_name, Encoding: :"Identity-H", DescendantFonts: [descendant],
+          ToUnicode: @document.ref!({}, to_unicode_cmap(@code_by_glyph)))
+      end
+    end
+  end
+end

data/lib/gamba/fonts/ttf.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+
+module Prawn
+  module Fonts
+    # A TrueType font, measured like Prawn measures it, embedded as one composite font per document: a Type0 font
+    # with Identity-H encoding over a subset of the glyphs used.
+    class TTF < Font
+      class Error < StandardError
+        DEFAULT_MESSAGE = "TTF font error"
+
+        def initialize(message = DEFAULT_MESSAGE, font: nil)
+          super((font && message == DEFAULT_MESSAGE) ? "TTF font error in font #{font}" : message)
+        end
+      end
+
+      class NoUnicodeCMap < Error
+        def initialize(message = "No unicode cmap found in font", font: nil)
+          super(font ? "No unicode cmap found in font #{font}" : message)
+        end
+      end
+
+      class NoPostscriptName < Error
+        def initialize(message = "Can not detect a postscript name", font: nil)
+          super(font ? "Can not detect a postscript name in font #{font}" : message)
+        end
+      end
+
+      LINE_FEED = 10
+      # FontDescriptor flags, ISO 32000-1 table 123.
+      FIXED_PITCH_FLAG = 0x0001
+      SERIF_FLAG = 0x0002
+      SYMBOLIC_FLAG = 0x0004
+      SCRIPT_FLAG = 0x0008
+      ITALIC_FLAG = 0x0040
+      # OS/2 sFamilyClass high bytes of serif and script families.
+      SERIF_FAMILY_CLASSES = [1, 2, 3, 4, 5, 7].freeze
+      SCRIPT_FAMILY_CLASS = 10
+      TO_UNICODE_ENTRIES_PER_BLOCK = 100
+
+      attr_reader :ttf
+
+      def initialize(document, name, options = {})
+        super
+        @ttf = read_ttf_file
+        raise NoUnicodeCMap.new(font: name) unless @ttf.unicode_cmap?
+        @code_by_glyph = {}
+
+        @subset = Gamba::TrueType::Subset.new(@ttf)
+        @cid_by_cluster = {}
+        @simple_subsets = Gamba::TrueType::SimpleSubsets.new(->(codes) { cmap[Array(codes).first] })
+        @layout = Gamba::TrueType::OpenTypeLayout.new(@ttf, options[:features]) if options[:features]&.any?
+        @width_by_code = {}
+        @ascender = Integer(@ttf.ascent * scale_factor)
+        @descender = Integer(@ttf.descent * scale_factor)
+        @line_gap = Integer(@ttf.line_gap * scale_factor)
+      end
+
+      def unicode?
+        true
+      end
+
+      # One pass over the characters, adding each kerning offset before the character it precedes: the same
+      # sums, in the same order, as measuring the runs of #kern.
+      def compute_width_of(string, options = {})
+        return shaped_width_of(string, options) if @layout
+
+        scale = (options[:size] || size) / 1000.0
+        kerning = options[:kerning]
+        width = 0
+        previous_glyph = nil
+        string.each_codepoint do |code|
+          glyph = cmap[code]
+          if kerning && previous_glyph && (offset = @ttf.kerning_offset(previous_glyph, glyph))
+            width -= -(offset * scale_factor)
+          end
+          width += character_width_by_code(code)
+          previous_glyph = glyph
+        end
+        width * scale
+      end
+
+      def bbox
+        @bbox ||= @ttf.header.to_h.values_at(:x_min, :y_min, :x_max, :y_max).map! { Integer(_1 * scale_factor) }
+      end
+
+      def has_kerning_data?
+        @ttf.kerning?
+      end
+
+      def encode_text(text, options = {})
+        text = text.chomp
+        unless @layout
+          return options[:kerning] ? encode_kerned_codepoints(text.codepoints) : @simple_subsets.encode_codepoints(text.codepoints, cmap)
+        end
+
+        clusters = @layout ? @layout.shape(text.codepoints) : text.codepoints.map { |code| [cmap[code], code] }
+        return @simple_subsets.encode(clusters) unless options[:kerning]
+
+        encoded = []
+        run = []
+        clusters.each do |cluster|
+          if run.any? && (offset = kerning_between(run.last[0], cluster[0]))
+            append_encoded_run(encoded, run)
+            encoded.last[1] = Array(encoded.last[1]) << -(offset * scale_factor)
+            run = []
+          end
+          run << cluster
+        end
+        append_encoded_run(encoded, run)
+      end
+
+      def basename
+        @basename ||= @ttf.postscript_name
+      end
+
+      def stem_v
+        0
+      end
+
+      # The post table's Fixed italic angle, read the way Prawn reads it.
+      def italic_angle
+        @italic_angle ||= begin
+          raw = @ttf.italic_angle_fixed
+          if raw
+            high = raw >> 16
+            low = raw & 0xFF
+            high = -((high ^ 0xFFFF) + 1) if high & 0x8000 != 0
+            Float("#{high}.#{low}")
+          else
+            0
+          end
+        end
+      end
+
+      def cap_height
+        @cap_height ||= @ttf.os2[:cap_height].to_i.then { |cap_height| cap_height.zero? ? @ascender : cap_height }
+      end
+
+      def x_height
+        @ttf.os2[:x_height] || 0
+      end
+
+      def family_class
+        @family_class ||= @ttf.os2[:family_class].to_i >> 8
+      end
+
+      def serif?
+        SERIF_FAMILY_CLASSES.include?(family_class)
+      end
+
+      def script?
+        family_class == SCRIPT_FAMILY_CLASS
+      end
+
+      def pdf_flags
+        flags = SYMBOLIC_FLAG
+        flags |= FIXED_PITCH_FLAG if @ttf.fixed_pitch?
+        flags |= SERIF_FLAG if serif?
+        flags |= SCRIPT_FLAG if script?
+        flags |= ITALIC_FLAG if italic_angle != 0
+        flags
+      end
+
+      def normalize_encoding(text)
+        text.encode(::Encoding::UTF_8)
+      rescue
+        raise Errors::IncompatibleStringEncoding,
+          "Encoding #{text.encoding} can not be transparently converted to UTF-8. " \
+          "Please ensure the encoding of the string you are attempting to use is set correctly"
+      end
+
+      def to_utf8(text)
+        text.encode(::Encoding::UTF_8)
+      end
+
+      def measured_string(string)
+        (string.encoding == ::Encoding::UTF_8) ? string : normalize_encoding(string)
+      end
+
+      def glyph_present?(character)
+        cmap[character.codepoints.first].positive?
+      end
+
+      # Glyphs, which character spacing applies to: fewer than characters once ligatures join some.
+      def character_count(string)
+        @layout ? @layout.shape(string.codepoints).size : string.length
+      end
+
+      private
+
+      def read_ttf_file
+        Gamba::TrueType::File.open(@name)
+      end
+
+      def cmap
+        @ttf.glyph_by_code
+      end
+
+      def scale_factor
+        @scale_factor ||= 1000.0 / @ttf.header.units_per_em
+      end
+
+      def character_width_by_code(code)
+        return 0.0 if code == LINE_FEED
+
+        @width_by_code[code] ||= Integer(@ttf.advance_widths[cmap[code]] * scale_factor)
+      end
+
+      # Runs of code points, separated by the kerning offset between two glyphs, in thousandths of the font size.
+      def kern(string)
+        runs = []
+        string.each_codepoint do |code|
+          if runs.empty?
+            runs << [code]
+          elsif (offset = @ttf.kerning_offset(cmap[runs.last.last], cmap[code]))
+            runs << -(offset * scale_factor) << [code]
+          else
+            runs.last << code
+          end
+        end
+        runs
+      end
+
+      def glyph_string(codes)
+        cluster_string(codes.map { |code| [cmap[code], code] })
+      end
+
+      # One character identifier per cluster of characters, in order of first use (0 stays .notdef): characters
+      # sharing a glyph keep their own Unicode value for text extraction, a ligature all of its characters.
+      def cluster_string(clusters)
+        clusters.map do |glyph, codes|
+          @cid_by_cluster[codes] ||= begin
+            (@glyph_by_cid ||= [0]) << glyph
+            @glyph_by_cid.size - 1
+          end
+        end.pack("n*")
+      end
+
+      # PDF word spacing (Tw) only reaches byte 32 of single-byte encodings (ISO 32000-1 §9.3.3): with two-byte
+      # codes, each space gets the same shift as a TJ offset instead.
+      def space_out_words(runs, word_spacing, font_size)
+        space = @layout ? cluster_string([[cmap[32], [32]]]) : glyph_string([32])
+        # From the spacing as Tw would write it, rounded to five decimals, so spaces land where Prawn's do.
+        offset = -(Float(PDF::Core.real(word_spacing)) * 1000.0 / font_size)
+        runs.flat_map do |run|
+          next [run] unless run.is_a?(String)
+
+          run.b.scan(/../mn).slice_after(space).flat_map { |codes| (codes.last == space) ? [codes.join, offset] : [codes.join] }
+        end
+      end
+
+      def shaped_width_of(string, options)
+        width = 0
+        previous_glyph = nil
+        @layout.shape(string.codepoints).each do |glyph, codes|
+          if options[:kerning] && previous_glyph && (offset = kerning_between(previous_glyph, glyph))
+            width += offset * scale_factor
+          end
+          width += (codes == [LINE_FEED]) ? 0.0 : Integer(@ttf.advance_widths[glyph] * scale_factor)
+          previous_glyph = glyph
+        end
+        width * ((options[:size] || size) / 1000.0)
+      end
+
+      def shaped_runs(text, kerning)
+        clusters = @layout.shape(text.codepoints)
+        return cluster_string(clusters) unless kerning
+
+        runs = []
+        run = []
+        clusters.each do |cluster|
+          if run.any? && (offset = kerning_between(run.last[0], cluster[0]))
+            runs << cluster_string(run) << -(offset * scale_factor)
+            run = []
+          end
+          run << cluster
+        end
+        runs << cluster_string(run)
+      end
+
+      def kerning_between(left, right)
+        return @ttf.kerning_offset(left, right) unless @layout
+
+        @layout.kerning(left, right) || (@ttf.kerning_offset(left, right) unless options[:features].include?(:kern))
+      end
+
+      def encode_kerned_codepoints(codepoints)
+        encoded = []
+        run_start = 0
+        previous_glyph = nil
+        codepoints.each_with_index do |code, index|
+          glyph = cmap[code]
+          if previous_glyph && (offset = @ttf.kerning_offset(previous_glyph, glyph))
+            merge_encoded_parts(encoded, @simple_subsets.encode_codepoints(codepoints[run_start...index], cmap))
+            encoded.last[1] = Array(encoded.last[1]) << -(offset * scale_factor)
+            run_start = index
+          end
+          previous_glyph = glyph
+        end
+        merge_encoded_parts(encoded, @simple_subsets.encode_codepoints(codepoints[run_start..], cmap))
+      end
+
+      # Runs of one subset merge into the previous part when it is of the same subset, as in Prawn's TJ arrays.
+      def append_encoded_run(encoded, run)
+        merge_encoded_parts(encoded, @simple_subsets.encode(run))
+      end
+
+      def merge_encoded_parts(encoded, parts)
+        return encoded if parts.empty?
+
+        if encoded.any? && parts.first[0] == encoded.last[0]
+          encoded.last[1] << parts.shift[1]
+        end
+        encoded.concat(parts)
+      end
+
+      def register(subset)
+        reference = @document.ref!(Type: :Font, BaseFont: basename.delete("\0").to_sym)
+        @document.before_render { embed(reference, subset) }
+        reference
+      end
+
+      # A simple TrueType font of single-byte codes, as Prawn embeds them: a font program with a Mac Roman cmap
+      # from those codes to its glyphs, widths per code, and a ToUnicode map.
+      def embed(reference, subset_index)
+        subset = @simple_subsets[subset_index]
+        program = Gamba::TrueType::Subset.new(@ttf)
+        # Glyphs numbered as TTFunk numbers them, by character code then components: TrueType hinting can depend
+        # on glyph indices, and a different order rasterizes differently in MuPDF.
+        subset.glyph_by_code.sort.each { |_code, glyph| program.glyph_for(glyph) unless glyph.zero? }
+        program.add_components(subset.glyph_by_code.values.uniq.sort!)
+        glyph_by_code = subset.glyph_by_code.transform_values { program.glyph_for(_1) }
+        mac_roman_cmap = [0, 1, 1, 0, 12, 0, 262, 0].pack("n4 N n3") + Array.new(256) { |code| glyph_by_code[code] || 0 }.pack("C*")
+        font_name = :"#{subset_tag_for(program.original_glyphs)}+#{basename.delete("\0")[0, 33]}"
+        font_bytes = program.bytes("cmap" => mac_roman_cmap)
+        font_file = @document.ref!({Length1: font_bytes.bytesize}, font_bytes)
+        descriptor = @document.ref!(
+          Type: :FontDescriptor, FontName: font_name, FontBBox: bbox, Flags: pdf_flags, StemV: stem_v, ItalicAngle: italic_angle,
+          Ascent: @ascender, Descent: @descender, CapHeight: cap_height, XHeight: x_height, FontFile2: font_file
+        )
+        first_code, last_code = subset.glyph_by_code.keys.minmax
+        widths = (first_code..last_code).map do |code|
+          glyph = subset.glyph_by_code[code]
+          glyph ? Integer(@ttf.advance_widths[glyph] * scale_factor) : 0
+        end
+        codes_by_code = subset.code_by_cluster.each_with_object({}) { |(codes, code), map| map[code] ||= Array(codes) }
+        reference.data.update(Subtype: :TrueType, BaseFont: font_name, FontDescriptor: descriptor, FirstChar: first_code, LastChar: last_code,
+          Widths: @document.ref!(widths), ToUnicode: @document.ref!({}, to_unicode_cmap(codes_by_code, code_bytes: 1)))
+      end
+
+      # Six capital letters derived from the glyphs kept, as ISO 32000-1 §9.6.4 asks of a subset's name.
+      def subset_tag
+        subset_tag_for(@subset.original_glyphs)
+      end
+
+      def subset_tag_for(glyphs)
+        Digest::MD5.digest(glyphs.pack("n*")).bytes.first(6).map! { |byte| ("A".ord + (byte % 26)).chr }.join
+      end
+
+      def to_unicode_cmap(codes_by_cid, code_bytes: 2)
+        entries = codes_by_cid.map { |cid, codes| format("<%0*X> <%s>", code_bytes * 2, cid, Array(codes).pack("U*").encode(::Encoding::UTF_16BE).unpack1("H*").upcase) }
+        blocks = entries.each_slice(TO_UNICODE_ENTRIES_PER_BLOCK).map { |block_entries| "#{block_entries.size} beginbfchar\n#{block_entries.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
+          #{(code_bytes == 1) ? "<00> <FF>" : "<0000> <FFFF>"}
+          endcodespacerange
+          #{blocks.join("\n")}
+          endcmap
+          CMapName currentdict /CMap defineresource pop
+          end
+          end
+        CMAP
+      end
+    end
+
+    class TTC < TTF
+      def self.font_names(file)
+        collection = ::File.binread(file)
+        Array.new(collection.unpack1("@8 N")) { |index| Gamba::TrueType::File.new(collection, index:).font_name }
+      end
+
+      private
+
+      def read_ttf_file
+        index = @options[:font].is_a?(Numeric) ? @options[:font] : self.class.font_names(@name).index(@options[:font]) || 0
+        Gamba::TrueType::File.open(@name, index:)
+      end
+    end
+
+    class DFont < TTF
+      private
+
+      def read_ttf_file
+        Gamba::TrueType::File.open(@name, index: @options[:font] || 0, resource: true)
+      end
+    end
+  end
+
+  class Font
+    AFM = Fonts::AFM
+    TTF = Fonts::TTF
+    TTC = Fonts::TTC
+    DFont = Fonts::DFont
+  end
+end