stationery 0.1.0 → 0.2.0

data/lib/stationery/elements/lists.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Stationery
+  # Bulleted and numbered lists.
+  module Elements
+    BULLETS = %i[disc circle square].freeze
+
+    # A bulleted list. `style:` is :disc, :circle, :square, :dash or any
+    # String; unstyled nested lists cycle disc → circle → square. Every node
+    # added inside becomes an item, `li` or not.
+    def ul(style: nil, gap: 4, indent: nil, marker_gap: 6, marker_color: nil, &)
+      shape = style || BULLETS[@_builder.list_depth % BULLETS.size]
+      marker_style = @_builder.style({ color: marker_color }.compact)
+      list(marker_style, gap:, indent:, marker_gap:, marker: ->(_) { list_bullet(shape, marker_style) }, &)
+    end
+
+    # A numbered list. `format:` is :decimal, :alpha, :upper_alpha, :roman,
+    # :upper_roman or a Proc given the number.
+    def ol(format: :decimal, start: 1, suffix: ".", gap: 4, indent: nil, marker_gap: 6, marker_color: nil, &)
+      marker_style = @_builder.style({ color: marker_color }.compact)
+      label = ->(index) { list_label(ListMarkers.label(format, start + index, suffix), marker_style) }
+      list(marker_style, gap:, indent:, marker_gap:, marker: label, &)
+    end
+
+    # A list item: a String becomes a paragraph (taking every text option),
+    # a block a flow of its children.
+    def li(content = nil, gap: 0, **text_options, &)
+      return text(content, **text_options) if content
+
+      @_builder.add(container(gap:, &))
+    end
+
+    private
+
+    def list(marker_style, gap:, indent:, marker_gap:, marker:, &)
+      items = Builder::Items.new
+      @_builder.nested_list { @_builder.within(items) { yield_content(&) } }
+      markers = items.nodes.each_index.map(&marker)
+      indent ||= [markers.map(&:natural_width).max || 0, marker_style.size].max + marker_gap
+      entries = items.nodes.zip(markers).map do |node, mark|
+        Layout::ListItem.new(mark, node.is_a?(Layout::Flow) ? node : Layout::Flow.new([node]), indent:, marker_gap:)
+      end
+      @_builder.add(Layout::Flow.new(entries, gap:))
+    end
+
+    def list_bullet(shape, style)
+      return Layout::Bullet.new(shape, style:, context: @_builder.context(style)) if BULLETS.include?(shape)
+      return list_label(shape.to_s, style) unless shape == :dash
+
+      font = @_builder.book.resolve(style).first
+      list_label(font.glyph?("–") ? "–" : "-", style)
+    end
+
+    def list_label(label, style)
+      Layout::Text.new([Text::Run.new(label, style)], context: @_builder.context(style), align: :right)
+    end
+  end
+end

data/lib/stationery/elements/rich.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Stationery
+  # HTML and Markdown rendered with the element DSL; the parsers load on first use.
+  module Elements
+    # HTML such as ActionText's `record.body.to_s`. `images:` resolves an
+    # image src to a path or IO (nil skips it); otherwise it is read from
+    # under `base_path:`. Remote images are never fetched.
+    def html(source, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false)
+      require_relative "../html/document"
+      rich(HTML.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:)
+    end
+
+    # CommonMark (plus GFM tables and strikethrough); options as for html.
+    def markdown(source, styles: {}, gap: 6, images: nil, base_path: nil, bookmarks: false)
+      require_relative "../markdown/document"
+      rich(Markdown.parse(source.to_s), styles:, gap:, images:, base_path:, bookmarks:)
+    end
+
+    private
+
+    def rich(blocks, **)
+      require_relative "../rich/renderer"
+      Rich::Renderer.new(self, @_builder, **).render(blocks)
+    end
+  end
+end

data/lib/stationery/elements.rb

@@ -7,7 +7,8 @@ module Stationery
 
     # A paragraph. Plain strings are always literal; pass `markup: true` to
     # read inline tags, or a block to build styled runs in Ruby.
-    def text(content = nil, markup: false, keep_with_next: nil, break_inside: nil, **options, &)
+    def text(content = nil, markup: false, keep_with_next: nil, break_inside: nil, anchor: nil, bookmark: nil,
+             **options, &)
       settings = PARAGRAPH_DEFAULTS.merge(@_builder.text_defaults.slice(:align, :leading)).merge(options)
       style = @_builder.style(options)
       runs = text_runs(content, style, markup, &)
@@ -15,40 +16,83 @@ module Stationery
                                     leading: settings[:leading])
       node.keep_with_next = keep_with_next
       node.break_inside = break_inside
-      @_builder.add(node)
+      @_builder.add(mark(node, anchor, bookmark))
     end
 
     # A container with padding, background, border and radius. `at: [x, y]`
     # places it at a fixed page position outside the flow.
-    def box(at: nil, align: nil, gap: 0, width: nil, keep_with_next: nil, **, &)
+    # `break_inside: :auto` splits it at any page break, `:avoid` never; by
+    # default it splits only when it does not fit on a page of its own.
+    def box(at: nil, align: nil, gap: 0, width: nil, keep_with_next: nil, break_inside: nil, anchor: nil, bookmark: nil,
+            **, &)
       node = Layout::Box.new(container(align:, gap:, &), width:, **)
       node.keep_with_next = keep_with_next
+      node.break_inside = break_inside
+      node = mark(node, anchor, bookmark)
       @_builder.add(at ? Layout::Positioned.new(node, x: at[0], y: at[1], width:) : node)
     end
 
-    def row(gap: 0, align: :top)
+    # Columns side by side; splits across pages like a box (`break_inside:`).
+    def row(gap: 0, align: :top, break_inside: nil)
       columns = Builder::Columns.new
       @_builder.within(columns) { yield if block_given? }
-      @_builder.add(Layout::Row.new(columns.nodes, gap:, align:))
+      node = Layout::Row.new(columns.nodes, gap:, align:)
+      node.break_inside = break_inside
+      @_builder.add(node)
     end
 
     # A row column: `width:` in points, as a fraction (0.5), :auto or nil for
     # an equal share. Takes every box option.
-    def column(width: nil, align: nil, gap: 0, **, &)
-      @_builder.add(Layout::Box.new(container(align:, gap:, &), width:, **))
+    def column(width: nil, align: nil, gap: 0, break_inside: nil, **, &)
+      node = Layout::Box.new(container(align:, gap:, &), width:, **)
+      node.break_inside = break_inside
+      @_builder.add(node)
     end
 
     # Children kept in one vertical group; `keep_together: true` moves the
     # whole group to the next page rather than splitting it.
-    def group(gap: 0, keep_together: false, keep_with_next: nil, &)
-      flow = container(gap:, &)
+    def group(gap: 0, align: nil, keep_together: false, keep_with_next: nil, anchor: nil, bookmark: nil, &)
+      flow = container(align:, gap:, &)
       flow.break_inside = :avoid if keep_together
       flow.keep_with_next = keep_with_next
-      @_builder.add(flow)
+      @_builder.add(mark(flow, anchor, bookmark))
     end
 
-    def table(rows, widths: nil, width: :auto, header: false, cell: {}, &)
-      @_builder.add(Layout::Table.new(rows, context: @_builder.context, widths:, width:, header:, cell:, &))
+    # Children side by side at their own widths, wrapping onto new rows.
+    def wrap(gap: 0, row_gap: nil, align: :left, &)
+      flow = container(&)
+      @_builder.add(Layout::Wrap.new(flow.children, gap:, row_gap: row_gap || gap, align:))
+    end
+
+    # An SVG drawing: markup String, or a path to a .svg file. `currentColor`
+    # takes `color:`.
+    def svg(source, width: nil, height: nil, color: "#000000", align: nil)
+      name = source.to_s.lstrip.start_with?("<") ? "inline" : File.basename(source.to_s)
+      source = File.read(source.to_s) unless name == "inline"
+      document = SVG::Document.parse(source)
+      if document.unsupported.any?
+        @_builder.warnings << Warnings::UnsupportedSvg.new(elements: document.unsupported, source: name)
+      end
+      node = Layout::Svg.new(document, width:, height:, color:)
+      @_builder.add(align ? Layout::Flow.new([node], align:) : node)
+    end
+
+    # Cells are strings, layout nodes, procs built with the DSL (`-> { image … }`)
+    # or components.
+    def table(rows, widths: nil, width: :auto, header: false, split_rows: false, cell: {}, anchor: nil, bookmark: nil,
+              &)
+      rows = rows.map { |row| row.map { |content| cell_content(content) } }
+      node = Layout::Table.new(rows, context: @_builder.context, widths:, width:, header:, split_rows:, cell:, &)
+      @_builder.add(mark(node, anchor, bookmark))
+    end
+
+    # The document's bookmarks with their page numbers, one linked row each.
+    # `levels:` is a Range (or an Integer maximum depth); `leader:` is :dots,
+    # :line or nil; text options style the rows.
+    def table_of_contents(levels: 1.., leader: :dots, indent: 12, number_width: nil, gap: 4, **options)
+      node = Layout::TableOfContents.new(@_builder.outline, context: @_builder.context(@_builder.style(options)),
+                                                            levels:, leader:, indent:, number_width:, gap:)
+      @_builder.add(node)
     end
 
     def image(source, align: nil, **)
@@ -60,6 +104,16 @@ module Stationery
     def spacer(height) = @_builder.add(Layout::Spacer.new(height))
     def page_break = @_builder.add(Layout::PageBreak.new)
 
+    # A named link target (`link: "#name"`) at this point; it moves to the
+    # next page with whatever follows it.
+    def anchor(name) = @_builder.add(Layout::Mark.standalone(name))
+
+    # An outline entry (PDF bookmark) at this point; like a standalone anchor
+    # it moves to the next page with whatever follows it.
+    def bookmark(title, level: 1, open: false)
+      @_builder.add(Layout::Mark.standalone(@_builder.outline.add(title, level:, open:).anchor))
+    end
+
     # Draw directly: the block receives the canvas and the reserved rectangle.
     def canvas(height:, at: nil, width: nil, &)
       node = Layout::CanvasNode.new(height:, &)
@@ -73,6 +127,20 @@ module Stationery
 
     private
 
+    # `bookmark:` is a title, or { title:, level:, open: }.
+    def mark(node, anchor, bookmark)
+      names = [anchor&.to_s]
+      names << outline_entry(bookmark).anchor if bookmark
+      names.compact!
+      names.empty? ? node : Layout::Mark.new(node, names)
+    end
+
+    def outline_entry(bookmark)
+      return @_builder.outline.add(bookmark) unless bookmark.is_a?(Hash)
+
+      @_builder.outline.add(bookmark.fetch(:title), **bookmark.slice(:level, :open))
+    end
+
     def container(align: nil, gap: 0, &)
       flow = Layout::Flow.new([], gap:, align: align || :left)
       @_builder.within(flow) do
@@ -80,6 +148,14 @@ module Stationery
       end
     end
 
+    def cell_content(content)
+      case content
+      when Proc then container(&content)
+      when Component then container { render content }
+      else content
+      end
+    end
+
     def text_runs(content, style, markup, &)
       return Text::RunsBuilder.build(style, &) if block_given?
       return Text::Markup.parse(content, style) if markup

data/lib/stationery/errors.rb

@@ -3,9 +3,21 @@
 module Stationery
   class Error < StandardError; end
 
-  # A font file stationery cannot read or embed (CFF, collections, WOFF, …).
+  # A font file stationery cannot read or embed (CFF2, collections, WOFF, …).
   class UnsupportedFont < Error; end
 
   # An image format stationery cannot embed (WebP, GIF, interlaced PNG, …).
   class UnsupportedImage < Error; end
+
+  # Raised by a strict render (`to_pdf(strict: true)`) that produced warnings.
+  class WarningsError < Error
+    attr_reader :warnings
+
+    def initialize(warnings)
+      @warnings = warnings
+      lines = warnings.map { |warning| "  #{warning.message}" }
+      noun = lines.size == 1 ? "warning" : "warnings"
+      super("#{lines.size} #{noun}:\n#{lines.join("\n")}")
+    end
+  end
 end

data/lib/stationery/fonts/bundled.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Families shipped inside the gem. Only file names live here; a face is
+    # read the first time a document draws with it, so requiring the gem
+    # never touches the files.
+    module Bundled
+      DIR = File.expand_path("data", __dir__)
+      DEFAULT = "Inter"
+      FAMILIES = {
+        "Inter" => { regular: "Inter-Regular.ttf", bold: "Inter-Bold.ttf",
+                     italic: "Inter-Italic.ttf", bold_italic: "Inter-BoldItalic.ttf" }
+      }.freeze
+
+      def self.names = FAMILIES.keys
+
+      # A Family for a bundled name, or nil.
+      def self.family(name)
+        files = FAMILIES[name.to_s]
+        files && Family.new(name, **files.transform_values { |file| File.join(DIR, file) })
+      end
+    end
+  end
+end

data/lib/stationery/fonts/catalog.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Font packs `stationery fonts install` can put in vendor/fonts. Each file
+    # is [url, sha256, filename]; a URL with a `#member` fragment names a file
+    # inside a .tar.gz, and a nil URL copies the file bundled with the gem.
+    # `rake fonts:verify` downloads everything and checks the SHAs.
+    module Catalog
+      Pack = Data.define(:key, :family, :license, :files, :license_file)
+
+      NOTO = "https://raw.githubusercontent.com/notofonts/notofonts.github.io/" \
+             "f145d86c53996717bc4c25d4602eb9294e43dccc/fonts"
+      NOTO_OFL = ["https://raw.githubusercontent.com/notofonts/latin-greek-cyrillic/NotoSans-v2.015/OFL.txt",
+                  "cee9892f9f0cc8fe882c9e9537ee6a89621d86ee7ceaf70b02e2b2b1c25c061a", "OFL.txt"].freeze
+      LIBERATION = "https://github.com/liberationfonts/liberation-fonts/files/7261482/" \
+                   "liberation-fonts-ttf-2.1.5.tar.gz#liberation-fonts-ttf-2.1.5"
+      LIBERATION_OFL = ["#{LIBERATION}/LICENSE",
+                        "93fed46019c38bbe566b479d22148e2e8a1e85ada614accb0211c37b2c61c19b", "OFL.txt"].freeze
+      LIBERATION_LICENSE = 'OFL-1.1, Reserved Font Name "Liberation"'
+
+      # { style => [url, sha, "Family-Style.ttf"] } with the URL built from the file name.
+      def self.faces(family, shas)
+        shas.to_h do |style, sha|
+          file = "#{family}-#{style.to_s.split("_").map(&:capitalize).join}.ttf"
+          [style, [yield(file), sha, file].freeze]
+        end.freeze
+      end
+
+      def self.noto(family, shas) = faces(family, shas) { "#{NOTO}/#{family}/unhinted/ttf/#{it}" }
+      def self.liberation(family, shas) = faces(family, shas) { "#{LIBERATION}/#{it}" }
+      private_class_method :faces, :noto, :liberation
+
+      PACKS = [
+        Pack.new(
+          key: :inter, family: "Inter", license: "OFL-1.1",
+          files: {
+            regular: [nil, "40d692fce188e4471e2b3cba937be967878f631ad3ebbbdcd587687c7ebe0c82", "Inter-Regular.ttf"],
+            bold: [nil, "288316099b1e0a47a4716d159098005eef7c0066921f34e3200393dbdb01947f", "Inter-Bold.ttf"],
+            italic: [nil, "bbc051dd204b5019a1aa0bc0ae2aa8a05ab13e7a3f979fa357631dc7feb6833a", "Inter-Italic.ttf"],
+            bold_italic: [nil, "948405a16cdc62701da5f4005ed068ca5f4d27061d98f7974ccfc37831d9581d",
+                          "Inter-BoldItalic.ttf"]
+          },
+          license_file: [nil, "262481e844521b326f5ecd053e59b98c8b2da78c8ee1bdbb6e8174305e54935a", "OFL.txt"]
+        ),
+        Pack.new(
+          key: :noto_sans, family: "Noto Sans", license: "OFL-1.1", license_file: NOTO_OFL,
+          files: noto("NotoSans",
+                      regular: "f3961a9cde016d41a4879aecda1474d3a36d6bf54fa0e4643de029cc2248b0e8",
+                      bold: "87cb2d84472a7d66da659ee47b6cdb9552326e8c128245231f191b6ac72529d9",
+                      italic: "678288f868807d4d64a6f3b51466871d117d915780381ce9d0ed4b3bcbd06d37",
+                      bold_italic: "3d367743f371f28671d2764e911a53d7c20ec9b6aa8791d059e7090389fc52a5")
+        ),
+        Pack.new(
+          key: :noto_serif, family: "Noto Serif", license: "OFL-1.1", license_file: NOTO_OFL,
+          files: noto("NotoSerif",
+                      regular: "a15cfbbc1539d707115111d672d590a3d70d4f74b4c0a315956da20ae19a14e1",
+                      bold: "24ad531e6b05ddad8c3d89572d2c93eb86a6b74e652ce7ee3c3e171de68e84c3",
+                      italic: "c4b3c971741ecdb40f5a443bce754e8fe91efe761b6ea10c92be7c3597cdadc4",
+                      bold_italic: "1bc4f86502eaa368718f6192bee022ea9a703d5af1c18b7d291212657b63074a")
+        ),
+        Pack.new(
+          key: :noto_sans_mono, family: "Noto Sans Mono", license: "OFL-1.1", license_file: NOTO_OFL,
+          files: noto("NotoSansMono",
+                      regular: "87f8ce0522a6c99b743ee5fc75b4073cfdd575639119672828b7b9944b65b4f4",
+                      bold: "1100772b2f79c102402a1011df5e2226517d0f40ac553a25fb12fdbad8c11b85")
+        ),
+        Pack.new(
+          key: :liberation_sans, family: "Liberation Sans", license: LIBERATION_LICENSE, license_file: LIBERATION_OFL,
+          files: liberation("LiberationSans",
+                            regular: "76d04c18ea243f426b7de1f3ad208e927008f961dc5945e5aad352d0dfde8ee8",
+                            bold: "788abee4c806d660e8aee46689dd8540cd4bb98da03dcc9d171ce3efd99a9173",
+                            italic: "e5bae5c4cde31f22142753855f4f8fb86da6ff39955ed3c0a11248b0d16948b0",
+                            bold_italic: "698da70fc191cc5f33ad4d6d3fe830fe4624b898ea2e3169955928b7c491f1ee")
+        ),
+        Pack.new(
+          key: :liberation_serif, family: "Liberation Serif", license: LIBERATION_LICENSE,
+          license_file: LIBERATION_OFL,
+          files: liberation("LiberationSerif",
+                            regular: "058ea80864aef09a23f45cbec2bb5400bc3dfbdea01c3f10538a21fcb497fb74",
+                            bold: "d754ba427cfe0bca54ae052384baa8f842da5bd6550ad4da024ac441e7a7d5ce",
+                            italic: "0e3dea9f8d613e006ccfa62201f33e265d19167bd0907725c3e145368b04fc2e",
+                            bold_italic: "f17db8af71e24d2066b587546021d4f0b296be389512b658dec3c09affeb11a7")
+        ),
+        Pack.new(
+          key: :liberation_mono, family: "Liberation Mono", license: LIBERATION_LICENSE, license_file: LIBERATION_OFL,
+          files: liberation("LiberationMono",
+                            regular: "f2b83c763e8afd21709333370bed4774337fae82267937e2b5aea7e2fbd922c1",
+                            bold: "bd62a0672d0b9b6710b01df434c80ad54fa5f0835207eb7b17b7a761463067bb",
+                            italic: "605c01c711b44480a7508d349dfbf3264e81fa43d69e61cfa7d10b86e764c4d1",
+                            bold_italic: "79451f3c09fe25116098853b7a2ca6e2436220ccc11af022979adbcf195be130")
+        )
+      ].freeze
+
+      def self.fetch(key)
+        PACKS.find { |pack| pack.key.to_s == key.to_s } ||
+          raise(Error, "unknown font pack #{key.to_s.inspect} (available: #{PACKS.map(&:key).join(", ")})")
+      end
+    end
+  end
+end

data/lib/stationery/fonts/cff.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Reads the Compact Font Format table of an OpenType font (.otf): the
+    # INDEX structures, the Top DICT and, for a CID-keyed font, the charset
+    # that maps glyph ids to CIDs. Charstrings are not interpreted.
+    class CFF
+      STANDARD_STRINGS = 391
+      CHARSET = 15
+      ENCODING = 16
+      CHARSTRINGS = 17
+      PRIVATE = 18
+      ROS = 1230
+      FD_ARRAY = 1236
+      FD_SELECT = 1237
+      SUBRS = 19
+      REAL_NIBBLES = [*"0".."9", ".", "E", "E-", nil, "-"].freeze
+
+      # An INDEX from `start` to `stop` (exclusive); items are [offset, length].
+      Index = Data.define(:start, :items, :stop)
+
+      attr_reader :data, :top, :num_glyphs, :name_index, :top_index, :string_index, :global_subrs, :charstrings
+
+      def initialize(data)
+        @data = data.b
+        @name_index = index_at(@data.getbyte(2))
+        @top_index = index_at(@name_index.stop)
+        @string_index = index_at(@top_index.stop)
+        @global_subrs = index_at(@string_index.stop)
+        @top = self.class.parse_dict(item(@top_index, 0))
+        @charstrings = index_at(@top.fetch(CHARSTRINGS).first)
+        @num_glyphs = @charstrings.items.size
+        @charset = self.class.parse_charset(@data, @top.fetch(CHARSET).first, @num_glyphs) if cid_keyed?
+      end
+
+      def inspect = "#<#{self.class} glyphs=#{@num_glyphs}#{" cid" if cid_keyed?}>"
+
+      def cid_keyed? = @top.key?(ROS)
+
+      # [registry, ordering, supplement] of a CID-keyed font.
+      def ros
+        return unless cid_keyed?
+
+        registry, ordering, supplement = @top[ROS]
+        [string(registry), string(ordering), supplement]
+      end
+
+      # A name-keyed font has no CIDs; PDF addresses its glyphs by glyph id.
+      def cid_for(gid)
+        cid_keyed? ? @charset.fetch(gid, 0) : gid
+      end
+
+      def item(index, number) = @data.byteslice(*index.items.fetch(number))
+
+      def string(sid) = item(@string_index, sid - STANDARD_STRINGS)
+
+      class << self
+        # { operator => operands }; two-byte operators are 1200 + the second byte.
+        def parse_dict(bytes) = dict_entries(bytes).to_h { |op, operands, _| [op, operands] }
+
+        # [operator, operands, raw bytes of operands and operator] in order.
+        def dict_entries(bytes)
+          entries = []
+          operands = []
+          start = pos = 0
+          while pos < bytes.bytesize
+            b0 = bytes.getbyte(pos)
+            if b0 <= 21
+              op = b0 == 12 ? 1200 + bytes.getbyte(pos + 1) : b0
+              pos += b0 == 12 ? 2 : 1
+              entries << [op, operands, bytes.byteslice(start, pos - start)]
+              operands = []
+              start = pos
+            else
+              value, pos = operand(bytes, pos)
+              operands << value
+            end
+          end
+          entries
+        end
+
+        # The SID (name-keyed) or CID (CID-keyed) of every glyph, by glyph id.
+        def parse_charset(data, offset, num_glyphs)
+          format = data.getbyte(offset)
+          return [0, *data.byteslice(offset + 1, (num_glyphs - 1) * 2).unpack("n*")] if format.zero?
+
+          ids = [0]
+          pos = offset + 1
+          while ids.size < num_glyphs
+            first, left = data.byteslice(pos, format == 1 ? 3 : 4).unpack(format == 1 ? "nC" : "nn")
+            ids.concat((first..(first + left)).to_a)
+            pos += format == 1 ? 3 : 4
+          end
+          ids.first(num_glyphs)
+        end
+
+        private
+
+        def operand(bytes, pos)
+          b0 = bytes.getbyte(pos)
+          case b0
+          when 28 then [bytes.byteslice(pos + 1, 2).unpack1("s>"), pos + 3]
+          when 29 then [bytes.byteslice(pos + 1, 4).unpack1("l>"), pos + 5]
+          when 30 then real(bytes, pos + 1)
+          when 32..246 then [b0 - 139, pos + 1]
+          when 247..250 then [((b0 - 247) * 256) + bytes.getbyte(pos + 1) + 108, pos + 2]
+          when 251..254 then [((251 - b0) * 256) - bytes.getbyte(pos + 1) - 108, pos + 2]
+          else raise UnsupportedFont, "malformed CFF DICT operand #{b0}"
+          end
+        end
+
+        def real(bytes, pos)
+          text = +""
+          loop do
+            byte = bytes.getbyte(pos)
+            pos += 1
+            [byte >> 4, byte & 0x0F].each do |nibble|
+              return [Float(text), pos] if nibble == 0x0F
+
+              text << REAL_NIBBLES.fetch(nibble)
+            end
+          end
+        end
+      end
+
+      def index_at(offset)
+        count = @data.byteslice(offset, 2).unpack1("n")
+        return Index.new(offset, [], offset + 2) if count.zero?
+
+        size = @data.getbyte(offset + 2)
+        offsets = Array.new(count + 1) do |i|
+          @data.byteslice(offset + 3 + (i * size), size).bytes.inject(0) { |value, byte| (value << 8) | byte }
+        end
+        base = offset + 2 + ((count + 1) * size)
+        Index.new(offset, offsets.each_cons(2).map { |a, b| [base + a, b - a] }, base + offsets.last)
+      end
+    end
+  end
+end

data/lib/stationery/fonts/cff_subset.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Fonts
+    # Rewrites a CFF font so every glyph a document did not draw is a bare
+    # `endchar`. Glyph ids, the charset, FDSelect, the Private DICTs and all
+    # Subrs are kept byte for byte, so CIDs and hinting are unchanged; only the
+    # CharStrings INDEX shrinks. Offsets in the Top DICT and the Font DICTs are
+    # written as fixed five-byte integers so their size does not depend on the
+    # layout they describe. Charstrings are not interpreted: a deprecated
+    # `seac` accent in a drawn glyph would lose its base and accent glyphs.
+    module CffSubset
+      ENDCHAR = "\x0E".b
+
+      module_function
+
+      # Header, Name INDEX, Top DICT INDEX, String and Global Subr INDEXes,
+      # then the blocks the Top DICT points at.
+      def build(cff, gids)
+        blocks = blocks(cff, gids)
+        head = cff.data.byteslice(0, cff.name_index.stop)
+        globals = cff.data.byteslice(cff.string_index.start, cff.global_subrs.stop - cff.string_index.start)
+        pos = head.bytesize + index([top_dict(cff, blocks.transform_values { 0 })]).bytesize + globals.bytesize
+        offsets = blocks.transform_values { |block| pos.tap { pos += block.bytesize } }
+        blocks[:fd_array] = fd_array(cff, offsets) if cff.cid_keyed?
+
+        [head, index([top_dict(cff, offsets)]), globals, *blocks.values].join
+      end
+
+      # The FDArray is sized here with placeholder offsets; build fills them in.
+      def blocks(cff, gids)
+        keep = Set.new(gids) << 0
+        charstrings = Array.new(cff.num_glyphs) { |gid| keep.include?(gid) ? cff.item(cff.charstrings, gid) : ENDCHAR }
+        blocks = tables(cff).merge(charstrings: index(charstrings))
+        privates(cff).each_with_index { |region, i| blocks[[:private, i]] = region }
+        blocks[:fd_array] = fd_array(cff, Hash.new(0)) if cff.cid_keyed?
+        blocks
+      end
+
+      # Charset, custom Encoding and FDSelect, copied as they are.
+      def tables(cff)
+        data = cff.data
+        top = cff.top
+        blocks = {}
+        if (offset = top.fetch(CFF::CHARSET, [0]).first) > 2
+          blocks[:charset] = data.byteslice(offset, charset_size(data, offset, cff.num_glyphs))
+        end
+        if (offset = top.fetch(CFF::ENCODING, [0]).first) > 1
+          blocks[:encoding] = data.byteslice(offset, encoding_size(data, offset))
+        end
+        if (offset = top[CFF::FD_SELECT]&.first)
+          blocks[:fd_select] = data.byteslice(offset, fd_select_size(data, offset, cff.num_glyphs))
+        end
+        blocks
+      end
+
+      # Each Private DICT with its local Subrs, as one region so the Subrs
+      # offset (relative to the Private DICT) still holds.
+      def privates(cff)
+        font_dicts(cff).map do |dict|
+          size, offset = dict.fetch(CFF::PRIVATE)
+          stop = offset + size
+          if (subrs = CFF.parse_dict(cff.data.byteslice(offset, size))[CFF::SUBRS])
+            stop = [stop, cff.index_at(offset + subrs.first).stop].max
+          end
+          cff.data.byteslice(offset, stop - offset)
+        end
+      end
+
+      def font_dicts(cff)
+        return [cff.top] unless cff.cid_keyed?
+
+        fd_array = cff.index_at(cff.top.fetch(CFF::FD_ARRAY).first)
+        fd_array.items.each_index.map { |i| CFF.parse_dict(cff.item(fd_array, i)) }
+      end
+
+      def top_dict(cff, offsets)
+        encode(CFF.dict_entries(cff.item(cff.top_index, 0))) do |op, operands|
+          case op
+          when CFF::CHARSET then offsets.key?(:charset) ? [offsets[:charset]] : operands
+          when CFF::ENCODING then offsets.key?(:encoding) ? [offsets[:encoding]] : operands
+          when CFF::CHARSTRINGS then [offsets[:charstrings]]
+          when CFF::FD_SELECT then [offsets[:fd_select]]
+          when CFF::FD_ARRAY then [offsets[:fd_array]]
+          when CFF::PRIVATE then [operands.first, offsets[[:private, 0]]]
+          end
+        end
+      end
+
+      def fd_array(cff, offsets)
+        fd_array = cff.index_at(cff.top.fetch(CFF::FD_ARRAY).first)
+        dicts = fd_array.items.each_index.map do |i|
+          encode(CFF.dict_entries(cff.item(fd_array, i))) do |op, operands|
+            [operands.first, offsets[[:private, i]]] if op == CFF::PRIVATE
+          end
+        end
+        index(dicts)
+      end
+
+      # Entries the block answers are rewritten with five-byte integers; the
+      # rest keep their original bytes.
+      def encode(entries)
+        entries.map do |op, operands, raw|
+          values = yield(op, operands)
+          next raw unless values
+
+          values.map { |value| [29, value].pack("Cl>") }.join + (op >= 1200 ? [12, op - 1200].pack("CC") : op.chr)
+        end.join.b
+      end
+
+      def index(items)
+        offsets = items.each_with_object([1]) { |item, acc| acc << (acc.last + item.bytesize) }
+        size = [1, 2, 3, 4].find { |bytes| offsets.last < 256**bytes }
+        [items.size, size].pack("nC") + offsets.map { |offset| [offset].pack("N").byteslice(4 - size, size) }.join +
+          items.join
+      end
+
+      def charset_size(data, offset, num_glyphs)
+        format = data.getbyte(offset)
+        return 1 + ((num_glyphs - 1) * 2) if format.zero?
+
+        range = format == 1 ? 3 : 4
+        pos = offset + 1
+        covered = 1
+        while covered < num_glyphs
+          covered += 1 + (format == 1 ? data.getbyte(pos + 2) : data.byteslice(pos + 2, 2).unpack1("n"))
+          pos += range
+        end
+        pos - offset
+      end
+
+      def encoding_size(data, offset)
+        format = data.getbyte(offset)
+        count = data.getbyte(offset + 1)
+        size = 2 + (format.nobits?(0x7F) ? count : count * 2)
+        size += 1 + (data.getbyte(offset + size) * 3) if format.allbits?(0x80)
+        size
+      end
+
+      def fd_select_size(data, offset, num_glyphs)
+        data.getbyte(offset).zero? ? 1 + num_glyphs : 5 + (data.byteslice(offset + 1, 2).unpack1("n") * 3)
+      end
+    end
+  end
+end