okab 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8ccd04c824a28ca26ec41d2610efdcd2912a51adc0a6d9cb49fe26a8aa858751
+  data.tar.gz: 26a86a7f3b03e6406015ea712f8b2dac25909b947c22cc6d0d36d0edde7f58ff
+SHA512:
+  metadata.gz: 0e98d8261aff467b1e97f93242a73e6cacbc75d3a7d964e20da9f2fd1d900656342a31b72da32e715b593984e06c5ba08f9e5a4a70b4edddeb49b15c3cb269a8
+  data.tar.gz: 81794209eebf9639ecd66023f0d42872d2573906a27de87a6a3d05f36e8e619522a8ac0fbf4d12677cf58aae5c80350b836548c3a49b7458aa4861c3465f2163

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 — 2026-09-23
+
+- Initial release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# Okab
+
+Okab (ζ Aquilae) takes its name from Arabic *ʿuqāb*, “eagle”. It is a small Ruby library for creating searchable PDF 1.7 documents with embedded TrueType and supported CFF1-outline fonts.
+
+## Features
+
+- TrueType and static name-keyed CFF1 font subsetting through [Alhena](https://github.com/noxdea/alhena), with CID fonts and `ToUnicode` mappings for text search and copy
+- Text, wrapped text, paths, clipping, transforms, opacity, links, and outlines
+- PNG images with alpha and JPEG images embedded without re-encoding
+- Stable output for the same document inputs; timestamps are omitted
+
+PDF reading/editing, encryption, signatures, forms, and PDF/A are out of scope. CFF2, variable CFF1, and already CID-keyed CFF fonts are not supported; CFF embedding requires `subset: true`. PNG input is limited to non-interlaced 8-bit images; JPEG input is limited to 8-bit grayscale or RGB baseline, extended-sequential, or progressive images, and Exif orientation is not applied.
+
+## Installation
+
+```ruby
+gem "okab"
+```
+
+Okab requires Ruby 3.2 or later and Alhena 0.3.0 or later.
+
+## Usage
+
+```ruby
+require "okab"
+
+font = Okab::Font.load("/path/to/font.ttf")
+document = Okab::Document.new(title: "Quarterly report", author: "Yudai Takada")
+page = document.page(width: 595, height: 842) # points
+page.text("四半期報告", x: 48, y: 790, font: font, size: 24)
+page.text_block("A searchable report with embedded fonts.", x: 48, y: 750,
+  width: 360, font: font, size: 12, line_height: 18)
+page.rect(48, 700, 120, 28).fill([0.2, 0.4, 0.8])
+page.link([48, 700, 120, 28], uri: "https://example.com")
+document.outline("Report", page: page)
+document.write("report.pdf")
+```
+
+Coordinates use PDF points, with the origin at the lower-left corner. Text must be UTF-8. Supply a font that contains the characters you want to render.
+
+## Development
+
+Run `bundle exec rake` and `bundle exec rbs -I sig validate`. To exercise real Japanese extraction locally, set `OKAB_TEST_FONT` to a TrueType font containing Japanese characters and install Poppler's `pdftotext` utility:
+
+```sh
+OKAB_TEST_FONT=/path/to/japanese-font.ttf bundle exec rake
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/okab/document.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Okab
+  class Document
+    def initialize(title: nil, author: nil, creator: "Okab")
+      @metadata = {Title: title || "", Author: author || "", Creator: creator}
+      @pages, @fonts, @images, @opacities, @outlines = [], {}, {}, {}, []
+    end
+
+    def page(width:, height:)
+      page = Page.new(self, width: width, height: height)
+      @pages << page
+      yield page if block_given?
+      page
+    end
+
+    def outline(title, page:, level: 0)
+      raise ArgumentError, "outline page belongs to another document" unless @pages.include?(page)
+      raise ArgumentError, "outline level must be a nonnegative integer" unless level.is_a?(Integer) && level >= 0
+      raise ArgumentError, "outline level cannot skip a parent" if level > (@outlines.last&.last || -1) + 1
+
+      @outlines << [String(title).dup.freeze, page, level]
+      self
+    end
+
+    def owns_page?(page)
+      @pages.include?(page)
+    end
+
+    def embed_font(font, subset: true)
+      font = Font.new(font) if font.is_a?(Alhena::Font)
+      raise ArgumentError, "font must be an Okab::Font or Alhena::Font" unless font.is_a?(Font)
+
+      key = [font.object_id, !!subset]
+      @fonts[key] ||= EmbeddedFont.new(self, font, subset: subset)
+    end
+
+    def register_image(image)
+      raise ArgumentError, "expected an Okab::Image" unless image.is_a?(Image)
+
+      key = image.object_id
+      @images[key] ||= ["Im#{@images.length + 1}", image]
+      @images.fetch(key).first
+    end
+
+    def opacity_name(value)
+      raise ArgumentError, "opacity must be finite and between 0 and 1" unless value.is_a?(Numeric) && !value.is_a?(Complex) && value.finite? && value.between?(0, 1)
+
+      @opacities[value.to_f] ||= "GS#{@opacities.length + 1}"
+    end
+
+    def render
+      raise InvalidDocument, "document has no pages" if @pages.empty?
+
+      writer = PDF::Writer.new
+      pages_ref, catalog_ref, info_ref = writer.reserve, writer.reserve, writer.reserve
+      page_refs = @pages.map { writer.reserve }
+      font_resources = render_fonts(writer)
+      image_resources = render_images(writer)
+      opacity_resources = @opacities.to_h do |opacity, name|
+        [name, writer.add("<< /Type /ExtGState /ca #{number(opacity)} /CA #{number(opacity)} >>")]
+      end
+
+      @pages.zip(page_refs).each do |page, page_ref|
+        font_names = font_resources.to_h { |key, resource| [key.object_id, resource[:name]] }
+        content = page.content(fonts: font_names)
+        content_ref = writer.stream(content)
+        annotations = page.annotations.map { |annotation| annotation_object(writer, annotation, page_refs) }
+        fonts = font_resources.values.to_h { |font| [font[:name], font[:ref]] }
+        resources = "<< /Font #{resource_dictionary(fonts)} " \
+          "/XObject #{resource_dictionary(image_resources)} " \
+          "/ExtGState #{resource_dictionary(opacity_resources)} >>"
+        box = "[0 0 #{number(page.width)} #{number(page.height)}]"
+        annotation_refs = annotations.empty? ? "" : "/Annots [#{annotations.map { |ref| "#{ref} 0 R" }.join(' ')}]"
+        writer.set(page_ref, "<< /Type /Page /Parent #{pages_ref} 0 R /MediaBox #{box} /Resources #{resources} /Contents #{content_ref} 0 R #{annotation_refs} >>")
+      end
+
+      writer.set(pages_ref, "<< /Type /Pages /Count #{@pages.length} /Kids [#{page_refs.map { |ref| "#{ref} 0 R" }.join(' ')}] >>")
+      outline_root = render_outlines(writer, page_refs)
+      catalog = "<< /Type /Catalog /Pages #{pages_ref} 0 R"
+      catalog << " /Outlines #{outline_root} 0 R /PageMode /UseOutlines" if outline_root
+      catalog << " >>"
+      writer.set(catalog_ref, catalog)
+      writer.set(info_ref, "<< #{@metadata.map { |key, value| "/#{key} #{pdf_text(value)}" }.join(' ')} >>")
+      writer.render(root: catalog_ref, info: info_ref)
+    end
+
+    def write(path)
+      File.binwrite(path, render)
+      path
+    end
+
+    private
+
+    def render_fonts(writer)
+      @fonts.values.each_with_index.filter_map do |embedded, index|
+        data, subset_face, subset_map, cff = embedded.subset_font
+        base_name = embedded.base_name(data)
+        font_file = writer.stream(data, cff ? "/Subtype /CIDFontType0C" : "/Length1 #{data.bytesize}")
+        bbox = subset_face.bbox.map { |value| scale(value, subset_face.units_per_em) }
+        ascent = scale(subset_face.ascent, subset_face.units_per_em)
+        descent = scale(subset_face.descent, subset_face.units_per_em)
+        font_file_key = cff ? "FontFile3" : "FontFile2"
+        descriptor = writer.add("<< /Type /FontDescriptor /FontName /#{base_name} /Flags 32 " \
+          "/FontBBox [#{bbox.join(' ')}] /ItalicAngle 0 /Ascent #{ascent} /Descent #{descent} " \
+          "/CapHeight #{ascent} /StemV 80 /#{font_file_key} #{font_file} 0 R >>")
+        cid_to_gid = +"\0\0".b
+        widths, mappings = [], []
+        embedded.characters.each do |cid, (character, old_gid)|
+          next if cid.zero?
+
+          cid_to_gid << [subset_map.fetch(old_gid)].pack("n") unless cff
+          widths << "#{cid} [#{scale(embedded.face.advance_width(old_gid), embedded.face.units_per_em)}]"
+          mappings << "<#{format('%04X', cid)}> #{PDF::Encoding.unicode_hex(character)}"
+        end
+        cid_map = cff ? "" : " /CIDToGIDMap #{writer.stream(cid_to_gid)} 0 R"
+        subtype = cff ? "CIDFontType0" : "CIDFontType2"
+        cid_font = writer.add("<< /Type /Font /Subtype /#{subtype} /BaseFont /#{base_name} " \
+          "/CIDSystemInfo << /Registry (Adobe) /Ordering (Identity) /Supplement 0 >> " \
+          "/FontDescriptor #{descriptor} 0 R /DW 1000 /W [#{widths.join(' ')}]#{cid_map} >>")
+        cmap = to_unicode_cmap(mappings)
+        cmap_ref = writer.stream(cmap)
+        type0 = writer.add("<< /Type /Font /Subtype /Type0 /BaseFont /#{base_name} /Encoding /Identity-H " \
+          "/DescendantFonts [#{cid_font} 0 R] /ToUnicode #{cmap_ref} 0 R >>")
+        [embedded, {name: "F#{index + 1}", ref: type0}]
+      end.to_h
+    end
+
+    def render_images(writer)
+      @images.values.to_h do |name, image|
+        smask = image.alpha && writer.stream(Zlib::Deflate.deflate(image.alpha),
+          "/Type /XObject /Subtype /Image /Width #{image.width} /Height #{image.height} " \
+          "/ColorSpace /DeviceGray /BitsPerComponent 8 /Filter /FlateDecode")
+        filter = image.filter == :dct ? "/Filter /DCTDecode" : "/Filter /FlateDecode"
+        data = image.filter == :dct ? image.data : Zlib::Deflate.deflate(image.data)
+        color_space = image.color_space == :gray ? "/DeviceGray" : "/DeviceRGB"
+        decode = image.decode_parms ? "/DecodeParms << #{image.decode_parms} >>" : ""
+        mask = smask ? "/SMask #{smask} 0 R" : ""
+        ref = writer.stream(data, "/Type /XObject /Subtype /Image /Width #{image.width} /Height #{image.height} " \
+          "/ColorSpace #{color_space} /BitsPerComponent 8 #{filter} #{decode} #{mask}")
+        [name, ref]
+      end
+    end
+
+    def render_outlines(writer, page_refs)
+      return nil if @outlines.empty?
+
+      root = writer.reserve
+      top, parents = [], []
+      @outlines.each do |title, page, requested_level|
+        parents = parents.take(requested_level)
+        siblings = requested_level.zero? ? top : parents.fetch(requested_level - 1)[:children]
+        item = {title: title, page: page_refs.fetch(@pages.index(page)), children: []}
+        siblings << item
+        parents[requested_level] = item
+      end
+      refs = {}
+      allocate = lambda do |siblings|
+        siblings.each { |item| refs[item.object_id] = writer.reserve; allocate.call(item[:children]) unless item[:children].empty? }
+      end
+      allocate.call(top)
+      write_items = lambda do |siblings, parent_ref|
+        siblings.each_with_index do |item, index|
+          ref = refs.fetch(item.object_id)
+          sibling_refs = siblings.map { |sibling| refs.fetch(sibling.object_id) }
+          values = "/Title #{pdf_text(item[:title])} /Parent #{parent_ref} 0 R /Dest [#{item[:page]} 0 R /Fit]"
+          values << " /Prev #{sibling_refs[index - 1]} 0 R" if index.positive?
+          values << " /Next #{sibling_refs[index + 1]} 0 R" if index + 1 < sibling_refs.length
+          unless item[:children].empty?
+            child_refs = item[:children].map { |child| refs.fetch(child.object_id) }
+            values << " /First #{child_refs.first} 0 R /Last #{child_refs.last} 0 R /Count #{descendant_count(item)}"
+          end
+          writer.set(ref, "<< #{values} >>")
+          write_items.call(item[:children], ref) unless item[:children].empty?
+        end
+      end
+      write_items.call(top, root)
+      top_refs = top.map { |item| refs.fetch(item.object_id) }
+      count = top.sum { |item| 1 + descendant_count(item) }
+      writer.set(root, "<< /Type /Outlines /First #{top_refs.first} 0 R /Last #{top_refs.last} 0 R /Count #{count} >>")
+      root
+    end
+
+    def descendant_count(item)
+      item[:children].sum { |child| 1 + descendant_count(child) }
+    end
+
+    def annotation_object(writer, annotation, page_refs)
+      x, y, width, height, type, target = annotation
+      rect = "[#{number(x)} #{number(y)} #{number(x + width)} #{number(y + height)}]"
+      action = if type == :uri
+        "/A << /S /URI /URI #{pdf_text(target)} >>"
+      else
+        "/Dest [#{page_refs.fetch(@pages.index(target))} 0 R /Fit]"
+      end
+      writer.add("<< /Type /Annot /Subtype /Link /Rect #{rect} /Border [0 0 0] #{action} >>")
+    end
+
+    def resource_dictionary(resources)
+      entries = resources.map { |name, ref| "/#{PDF::Encoding.name(name)} #{ref} 0 R" }
+      "<< #{entries.join(' ')} >>"
+    end
+
+    def to_unicode_cmap(mappings)
+      chunks = mappings.each_slice(100).map do |entries|
+        "#{entries.length} beginbfchar\n#{entries.join("\n")}\nendbfchar\n"
+      end.join
+      "/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n" \
+        "/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n" \
+        "/CMapName /Adobe-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000> <FFFF>\nendcodespacerange\n" \
+        "#{chunks}endcmap\nCMapName currentdict /CMap defineresource pop\nend\nend"
+    end
+
+    def pdf_text(value)
+      text = String(value).encode(::Encoding::UTF_8)
+      if text.ascii_only?
+        "(#{text.gsub(/[\\()]/) { |character| "\\#{character}" }.gsub(/[\x00-\x1f\x7f]/) { |character| format('\\%03o', character.ord) }})"
+      else
+        PDF::Encoding.hex("\xFE\xFF".b + text.encode(::Encoding::UTF_16BE).b)
+      end
+    rescue EncodingError
+      raise ArgumentError, "PDF text must be valid UTF-8"
+    end
+
+    def scale(value, units_per_em)
+      (value.to_f * 1000 / units_per_em).round
+    end
+
+    def number(value)
+      PDF::Encoding.number(value)
+    end
+  end
+end

data/lib/okab/font.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Okab
+  class Font
+    attr_reader :face
+
+    def self.load(path) = new(Alhena::Font.open(path))
+    def self.embed(document, font, subset: true) = document.embed_font(font, subset: subset)
+
+    def initialize(face)
+      raise ArgumentError, "expected an Alhena::Font" unless face.is_a?(Alhena::Font)
+
+      @face = face
+    end
+
+    def measure(text, size:)
+      raise ArgumentError, "text must be valid UTF-8" unless text.is_a?(String) && text.encoding == Encoding::UTF_8 && text.valid_encoding?
+      raise ArgumentError, "size must be finite and positive" unless size.is_a?(Numeric) && size.finite? && size.positive?
+
+      @face.glyph_ids(text).sum { |glyph| @face.advance_width(glyph) } * size.to_f / @face.units_per_em
+    end
+  end
+
+  class EmbeddedFont
+    attr_reader :document, :font, :subset
+
+    def initialize(document, font, subset: true)
+      @document, @font, @subset = document, font, !!subset
+      @cid_by_character, @characters = {}, {0 => ["\u0000", 0]}
+    end
+
+    def face = @font.face
+    def measure(text, size:) = @font.measure(text, size: size)
+
+    def encode(string)
+      codepoints = string.codepoints
+      cids = []
+      codepoints.each_with_index do |codepoint, index|
+        next if variation_selector?(codepoint)
+
+        selector = variation_selector?(codepoints[index + 1]) ? codepoints[index + 1] : nil
+        glyph = face.glyph_id(codepoint, variation_selector: selector)
+        glyph = face.glyph_id(codepoint) if glyph.zero? && selector
+        character = [codepoint, *([selector] if selector)].pack("U*")
+        key = [character, glyph]
+        cid = @cid_by_character[key]
+        unless cid
+          cid = @characters.length
+          raise ArgumentError, "a PDF font cannot encode more than 65,535 characters" if cid > 65_535
+
+          @cid_by_character[key] = cid
+          @characters[cid] = [character, glyph]
+        end
+        cids << cid
+      end
+      cids.pack("n*")
+    end
+
+    def glyph_ids
+      @characters.values.map(&:last).uniq
+    end
+
+    def subset_font
+      if face.cff?
+        raise Alhena::UnsupportedFont, "CID CFF embedding requires subset: true" unless @subset
+
+        data = Alhena::Subset.build_cid(face, @characters.values.map(&:last))
+        return [data, face, {}, true]
+      end
+
+      selected = @subset ? glyph_ids : (0...face.glyph_count).to_a
+      data = Alhena::Subset.build(face, selected)
+      subset_face = Alhena::Font.new(data)
+      old_ids = Alhena::Subset.closure(face, [0, *selected].uniq)
+      [data, subset_face, old_ids.each_with_index.to_h, false]
+    end
+
+    def characters = @characters
+
+    def base_name(data)
+      prefix = Digest::SHA256.hexdigest(data).upcase[0, 6].tr("0-9", "A-J")
+      family = face.family.to_s.gsub(/[^A-Za-z0-9]/, "")
+      "#{prefix}+#{family.empty? ? 'EmbeddedFont' : family}"
+    end
+
+    private
+
+    def variation_selector?(codepoint)
+      codepoint && ((0xfe00..0xfe0f).cover?(codepoint) || (0xe0100..0xe01ef).cover?(codepoint))
+    end
+
+  end
+end

data/lib/okab/image.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Okab
+  class Image
+    # ponytail: cap decoded memory at 50 MP; add streaming raster output if larger images are needed.
+    MAX_PIXELS = 50_000_000
+    private_constant :MAX_PIXELS
+    PNG_SIGNATURE = "\x89PNG\r\n\x1a\n".b.freeze
+    private_constant :PNG_SIGNATURE
+
+    attr_reader :width, :height, :color_space, :data, :alpha, :filter, :decode_parms
+
+    def self.decode(bytes, format: :auto)
+      raise ArgumentError, "image data must be a String" unless bytes.is_a?(String)
+      format = :png if format == :auto && bytes.start_with?(PNG_SIGNATURE)
+      format = :jpeg if format == :auto && bytes.start_with?("\xff\xd8".b)
+      raise ArgumentError, "unsupported image format" unless %i[png jpeg].include?(format)
+
+      format == :png ? decode_png(bytes) : decode_jpeg(bytes)
+    end
+
+    def initialize(width:, height:, color_space:, data:, alpha: nil, filter: nil, decode_parms: nil)
+      raise InvalidDocument, "invalid image dimensions" unless width.is_a?(Integer) && height.is_a?(Integer) &&
+        width.positive? && height.positive? && width * height <= MAX_PIXELS
+      raise InvalidDocument, "invalid image color space" unless %i[gray rgb].include?(color_space)
+      raise InvalidDocument, "invalid image data" unless data.is_a?(String)
+      if filter == :dct
+        raise InvalidDocument, "invalid JPEG data" unless data.start_with?("\xff\xd8".b) && alpha.nil?
+        raise InvalidDocument, "invalid JPEG decode parameters" unless [nil, "/ColorTransform 1"].include?(decode_parms)
+      else
+        channels = color_space == :gray ? 1 : 3
+        raise InvalidDocument, "invalid pixel data length" unless filter.nil? && decode_parms.nil? && data.bytesize == width * height * channels
+        raise InvalidDocument, "invalid alpha data length" if alpha && (!alpha.is_a?(String) || alpha.bytesize != width * height)
+      end
+
+      @width, @height, @color_space = width, height, color_space
+      @data, @alpha, @filter, @decode_parms = data.b.freeze, alpha&.b&.freeze, filter, decode_parms
+      freeze
+    end
+
+    def self.decode_png(bytes)
+      at, header, palette, transparency, compressed = PNG_SIGNATURE.bytesize, nil, nil, nil, +"".b
+      while at < bytes.bytesize
+        raise InvalidDocument, "truncated PNG chunk" if at + 12 > bytes.bytesize
+        length = bytes.byteslice(at, 4).unpack1("N")
+        type = bytes.byteslice(at + 4, 4)
+        raise InvalidDocument, "invalid PNG chunk length" if length > bytes.bytesize - at - 12
+        payload = bytes.byteslice(at + 8, length)
+        checksum = bytes.byteslice(at + 8 + length, 4).unpack1("N")
+        raise InvalidDocument, "PNG checksum mismatch" unless Zlib.crc32(type + payload) == checksum
+        case type
+        when "IHDR" then header = payload
+        when "PLTE" then palette = payload
+        when "tRNS" then transparency = payload
+        when "IDAT" then compressed << payload
+        when "IEND" then break
+        end
+        at += length + 12
+      end
+      raise InvalidDocument, "missing PNG header" unless header&.bytesize == 13
+      width, height, depth, type, compression, filtering, interlace = header.unpack("NNC5")
+      raise InvalidDocument, "unsupported PNG format" unless depth == 8 && compression.zero? && filtering.zero? && interlace.zero?
+      # ponytail: only 8-bit non-interlaced PNG is decoded; packed, 16-bit, and Adam7 modes add separate row walkers.
+      raise InvalidDocument, "invalid PNG dimensions" unless width.positive? && height.positive? && width * height <= MAX_PIXELS
+      channels = {0 => 1, 2 => 3, 3 => 1, 4 => 2, 6 => 4}[type]
+      raise InvalidDocument, "unsupported PNG color type" unless channels
+      raise InvalidDocument, "indexed PNG has no palette" if type == 3 && (!palette || palette.empty? || palette.bytesize % 3 != 0)
+      decoded = inflate_bounded(compressed, (width * channels + 1) * height)
+      row_bytes, bpp = width * channels, channels
+      prior = "\0" * row_bytes
+      rgb, alpha = +"".b, +"".b
+      height.times do |row|
+        offset = row * (row_bytes + 1)
+        filter = decoded.getbyte(offset)
+        current = decoded.byteslice(offset + 1, row_bytes).bytes
+        prior_bytes = prior.bytes
+        current.each_index do |index|
+          left = index >= bpp ? current[index - bpp] : 0
+          above = prior_bytes[index]
+          upper_left = index >= bpp ? prior_bytes[index - bpp] : 0
+          current[index] = (current[index] + case filter
+          when 0 then 0
+          when 1 then left
+          when 2 then above
+          when 3 then (left + above) / 2
+          when 4 then paeth(left, above, upper_left)
+          else raise InvalidDocument, "invalid PNG filter"
+          end) & 255
+        end
+        prior = current.pack("C*")
+        width.times do |column|
+          pixel = column * channels
+          case type
+          when 0
+            gray = current[pixel]
+            rgb << gray.chr * 3
+            alpha << (transparency&.unpack1("n") == gray ? 0 : 255)
+          when 2
+            values = current[pixel, 3]
+            rgb << values.pack("C*")
+            alpha << (transparency && transparency.unpack("n*") == values ? 0 : 255)
+          when 3
+            index = current[pixel]
+            raise InvalidDocument, "PNG palette index out of range" if index * 3 + 2 >= palette.bytesize
+            rgb << palette.byteslice(index * 3, 3)
+            alpha << (transparency&.getbyte(index) || 255)
+          when 4
+            rgb << current[pixel].chr * 3
+            alpha << current[pixel + 1]
+          when 6
+            rgb << current[pixel, 3].pack("C*")
+            alpha << current[pixel + 3]
+          end
+        end
+      end
+      alpha = nil if alpha.each_byte.all? { |value| value == 255 }
+      new(width: width, height: height, color_space: :rgb, data: rgb, alpha: alpha)
+    rescue Zlib::Error => error
+      raise InvalidDocument, "invalid PNG compression: #{error.message}"
+    end
+
+    def self.decode_jpeg(bytes)
+      raise InvalidDocument, "invalid JPEG marker" unless bytes.start_with?("\xff\xd8".b)
+      at, frame = 2, nil
+      while at + 4 <= bytes.bytesize
+        at += 1 while at < bytes.bytesize && bytes.getbyte(at) != 0xff
+        at += 1 while at < bytes.bytesize && bytes.getbyte(at) == 0xff
+        marker = bytes.getbyte(at)
+        at += 1
+        next if [0xd8, 0xd9, 0x01, *0xd0..0xd7].include?(marker)
+        length = bytes.byteslice(at, 2)&.unpack1("n")
+        raise InvalidDocument, "truncated JPEG segment" unless length && length >= 2 && at + length <= bytes.bytesize
+        # ponytail: support Huffman DCT SOF modes only; lossless/arithmetic JPEG needs another PDF image filter.
+        if [0xc0, 0xc1, 0xc2].include?(marker)
+          precision, height, width, components = bytes.byteslice(at + 2, 6).unpack("CnnC")
+          raise InvalidDocument, "unsupported JPEG component count" unless [1, 3].include?(components)
+          raise InvalidDocument, "unsupported JPEG precision" unless precision == 8
+          frame = [width, height, components]
+        elsif marker == 0xda
+          raise InvalidDocument, "JPEG frame header not found" unless frame
+          eoi = bytes.rindex("\xff\xd9".b)
+          raise InvalidDocument, "JPEG image data is incomplete" unless eoi && eoi >= at + length
+          width, height, components = frame
+          return new(width: width, height: height, color_space: components == 1 ? :gray : :rgb,
+            data: bytes, filter: :dct, decode_parms: components == 3 ? "/ColorTransform 1" : nil)
+        end
+        at += length
+      end
+      raise InvalidDocument, frame ? "JPEG scan header not found" : "JPEG frame header not found"
+    end
+
+    def self.inflate_bounded(bytes, expected)
+      inflater, output = Zlib::Inflate.new, +"".b
+      offset = 0
+      while offset < bytes.bytesize
+        output << inflater.inflate(bytes.byteslice(offset, 4096))
+        raise InvalidDocument, "PNG data exceeds declared dimensions" if output.bytesize > expected
+        offset += 4096
+      end
+      output << inflater.finish
+      raise InvalidDocument, "PNG data length does not match dimensions" unless output.bytesize == expected
+      output
+    ensure
+      inflater&.close
+    end
+
+    def self.paeth(left, above, upper_left)
+      estimate = left + above - upper_left
+      left_distance = (estimate - left).abs
+      above_distance = (estimate - above).abs
+      corner_distance = (estimate - upper_left).abs
+      if left_distance <= above_distance && left_distance <= corner_distance
+        left
+      elsif above_distance <= corner_distance
+        above
+      else
+        upper_left
+      end
+    end
+  end
+end

data/lib/okab/page.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Okab
+  class Path
+    attr_reader :commands
+
+    def initialize = (@commands = [])
+    def move_to(x, y) = command("#{number(x)} #{number(y)} m")
+    def line_to(x, y) = command("#{number(x)} #{number(y)} l")
+    def curve_to(x1, y1, x2, y2, x3, y3) = command("#{[x1, y1, x2, y2, x3, y3].map { |v| number(v) }.join(' ')} c")
+    def close = command("h")
+    def rect(x, y, width, height) = command("#{[x, y, width, height].map { |v| number(v) }.join(' ')} re")
+
+    def ellipse(x, y, width, height)
+      k = 0.5522847498307936
+      cx, cy, rx, ry = x + width / 2.0, y + height / 2.0, width / 2.0, height / 2.0
+      move_to(cx + rx, cy)
+      curve_to(cx + rx, cy + k * ry, cx + k * rx, cy + ry, cx, cy + ry)
+      curve_to(cx - k * rx, cy + ry, cx - rx, cy + k * ry, cx - rx, cy)
+      curve_to(cx - rx, cy - k * ry, cx - k * rx, cy - ry, cx, cy - ry)
+      curve_to(cx + k * rx, cy - ry, cx + rx, cy - k * ry, cx + rx, cy)
+      close
+    end
+
+    private
+
+    def command(value)
+      @commands << value
+      self
+    end
+
+    def number(value)
+      raise ArgumentError, "coordinates must be finite numbers" unless value.is_a?(Numeric) && !value.is_a?(Complex) && value.finite?
+      PDF::Encoding.number(value)
+    end
+  end
+
+  class Page
+    attr_reader :width, :height, :operations, :annotations, :document
+
+    def initialize(document, width:, height:)
+      @document, @width, @height = document, Float(width), Float(height)
+      raise ArgumentError, "page dimensions must be finite and positive" unless [@width, @height].all? { |value| value.finite? && value.positive? }
+      @operations, @annotations, @open_clips = [], [], 0
+    end
+
+    def text(string, x:, y:, font:, size:, color: [0, 0, 0], tracking: 0, bold: false, italic: false)
+      validate_text(string)
+      size, tracking = finite(size, "font size"), finite(tracking, "tracking")
+      raise ArgumentError, "font size must be positive" unless size.positive?
+      raise ArgumentError, "bold and italic must be true or false" unless [bold, italic].all? { |value| value == true || value == false }
+      embedded = @document.embed_font(font)
+      encoded = embedded.encode(string)
+      @operations << [:text, finite(x, "x"), finite(y, "y"), embedded, encoded, size, rgb(color), tracking, bold, italic]
+      self
+    end
+
+    def text_block(string, x:, y:, width:, font:, size:, line_height:, align: :left, color: [0, 0, 0], tracking: 0)
+      validate_text(string)
+      x, y = finite(x, "x"), finite(y, "y")
+      width, size, line_height = finite(width, "width"), finite(size, "font size"), finite(line_height, "line height")
+      raise ArgumentError, "text block dimensions must be positive" unless width.positive? && size.positive? && line_height.positive?
+      raise ArgumentError, "align must be left, center, right, or justify" unless %i[left center right justify].include?(align)
+      face = font.is_a?(EmbeddedFont) ? font.font : normalize_font(font)
+      lines = wrap_lines(string, face, size, width)
+      lines.each_with_index do |line, index|
+        line_width = face.measure(line, size: size)
+        offset = case align
+        when :center then (width - line_width) / 2.0
+        when :right then width - line_width
+        else 0
+        end
+        extra = align == :justify && index < lines.length - 1 ? (width - line_width) / [line.length, 1].max : 0
+        text(line, x: x + offset, y: y - index * line_height, font: face, size: size,
+          color: color, tracking: tracking + extra)
+      end
+      self
+    end
+
+    def move_to(x, y) = raw(Path.new.move_to(x, y).commands.last)
+    def line_to(x, y) = raw(Path.new.line_to(x, y).commands.last)
+    def curve_to(x1, y1, x2, y2, x3, y3) = raw(Path.new.curve_to(x1, y1, x2, y2, x3, y3).commands.last)
+    def close = raw("h")
+    def rect(x, y, width, height) = raw(Path.new.rect(x, y, width, height).commands.last)
+
+    def ellipse(x, y, width, height)
+      path = Path.new.ellipse(*[x, y, width, height].map { |value| finite(value, "ellipse bounds") })
+      raw(path.commands.join("\n"))
+    end
+
+    def fill(color) = raw("#{rgb(color).join(' ')} rg\nf")
+    def stroke(color, width: 1) = raw("#{rgb(color).join(' ')} RG\n#{positive(width, 'line width')} w\nS")
+    def fill_and_stroke(color, width: 1) = raw("#{rgb(color).join(' ')} rg\n#{rgb(color).join(' ')} RG\n#{positive(width, 'line width')} w\nB")
+
+    def clip
+      raise ArgumentError, "clip requires a block" unless block_given?
+      path = Path.new
+      yield path
+      raise ArgumentError, "clip path must not be empty" if path.commands.empty?
+      @operations << [:raw, "q\n#{path.commands.join("\n")}\nW n"]
+      @open_clips += 1
+      self
+    end
+
+    def transform(a, b, c, d, e, f)
+      raise ArgumentError, "transform requires a block" unless block_given?
+      values = [a, b, c, d, e, f].map { |value| finite(value, 'transform') }
+      start = @operations.length
+      @operations << [:raw, "q\n#{values.map { |value| PDF::Encoding.number(value) }.join(' ')} cm"]
+      begin
+        yield self
+      rescue StandardError
+        @operations.slice!(start..)
+        raise
+      end
+      @operations << [:raw, "Q"]
+      self
+    end
+
+    def opacity(value)
+      raise ArgumentError, "opacity requires a block" unless block_given?
+      name = @document.opacity_name(value)
+      start = @operations.length
+      @operations << [:raw, "q\n/#{name} gs"]
+      begin
+        yield self
+      rescue StandardError
+        @operations.slice!(start..)
+        raise
+      end
+      @operations << [:raw, "Q"]
+      self
+    end
+
+    def image(data, x:, y:, width:, height:, format: :auto)
+      image = data.is_a?(Image) ? data : Image.decode(data, format: format)
+      name = @document.register_image(image)
+      @operations << [:image, name, finite(x, "x"), finite(y, "y"), finite(width, "width"), finite(height, "height")]
+      self
+    end
+
+    def link(bounds, uri: nil, page: nil)
+      raise ArgumentError, "provide either uri or page" if (!!uri == !!page)
+      x, y, width, height = normalize_bounds(bounds)
+      action = if uri
+        parsed = URI.parse(uri.to_s)
+        valid = (parsed.is_a?(URI::HTTP) && parsed.host && %w[http https].include?(parsed.scheme)) ||
+          (parsed.is_a?(URI::MailTo) && !parsed.to.empty?)
+        raise ArgumentError, "link URI must use http, https, or mailto" unless valid
+        [:uri, uri.to_s.freeze]
+      else
+        raise ArgumentError, "destination page belongs to another document" unless page.is_a?(Page) && @document.owns_page?(page)
+        [:page, page]
+      end
+      @annotations << [x, y, width, height, *action]
+      self
+    rescue URI::InvalidURIError
+      raise ArgumentError, "invalid link URI"
+    end
+
+    def content(fonts:)
+      output = +"".b
+      @operations.each do |operation|
+        case operation[0]
+        when :raw then output << operation[1].b << "\n".b
+        when :text
+          _, x, y, font, encoded, size, color, tracking, bold, italic = operation
+          output << "#{color.join(' ')} rg\n"
+          if bold
+            output << "#{color.join(' ')} RG\n#{PDF::Encoding.number((size * 0.035).round(4))} w\n"
+          end
+          matrix = italic ? "1 0 0.2 1 #{PDF::Encoding.number(x)} #{PDF::Encoding.number(y)} Tm" : "#{PDF::Encoding.number(x)} #{PDF::Encoding.number(y)} Td"
+          output << "BT /#{fonts.fetch(font.object_id)} #{PDF::Encoding.number(size)} Tf #{PDF::Encoding.number(tracking)} Tc #{bold ? 2 : 0} Tr #{matrix} #{PDF::Encoding.hex(encoded)} Tj ET\n".b
+        when :image
+          _, name, x, y, width, height = operation
+          output << "q\n#{PDF::Encoding.number(width)} 0 0 #{PDF::Encoding.number(height)} #{PDF::Encoding.number(x)} #{PDF::Encoding.number(y)} cm\n/#{name} Do\nQ\n".b
+        end
+      end
+      @open_clips.times { output << "Q\n".b }
+      output
+    end
+
+    private
+
+    def raw(value)
+      @operations << [:raw, value]
+      self
+    end
+
+    def validate_text(string)
+      raise ArgumentError, "text must be valid UTF-8" unless string.is_a?(String) && string.encoding == Encoding::UTF_8 && string.valid_encoding?
+    end
+
+    def finite(value, label)
+      raise ArgumentError, "#{label} must be finite" unless value.is_a?(Numeric) && !value.is_a?(Complex) && value.finite?
+      value = value.to_f
+      raise ArgumentError, "#{label} must be finite" unless value.finite?
+      value
+    end
+
+    def positive(value, label)
+      value = finite(value, label)
+      raise ArgumentError, "#{label} must be positive" unless value.positive?
+      value
+    end
+
+    def rgb(color)
+      valid = color.is_a?(Array) && color.length == 3 && color.all? { |value| value.is_a?(Numeric) && !value.is_a?(Complex) && value.finite? && value.between?(0, 1) }
+      raise ArgumentError, "color must contain three finite values between 0 and 1" unless valid
+      color.map { |value| PDF::Encoding.number(value) }
+    end
+
+    def normalize_bounds(bounds)
+      values = if bounds.is_a?(Array)
+        bounds
+      elsif %i[x y width height].all? { |name| bounds.respond_to?(name) }
+        %i[x y width height].map { |name| bounds.public_send(name) }
+      end
+      raise ArgumentError, "bounds must be [x, y, width, height]" unless values.is_a?(Array) && values.length == 4
+      x, y, width, height = values.map { |value| finite(value, "bounds") }
+      raise ArgumentError, "bounds dimensions must be positive" unless width.positive? && height.positive?
+      [x, y, width, height]
+    end
+
+    def normalize_font(font)
+      return font if font.is_a?(Font)
+      return Font.new(font) if font.is_a?(Alhena::Font)
+      raise ArgumentError, "font must be an Okab::Font or Alhena::Font"
+    end
+
+    def wrap_lines(string, font, size, width)
+      string.split("\n", -1).flat_map do |paragraph|
+        tokens = paragraph.split(/(?<=\s)/)
+        lines, line = [], +""
+        tokens.each do |token|
+          if !line.empty? && font.measure(line + token, size: size) > width
+            lines << line.rstrip
+            line = +""
+          end
+          if font.measure(token, size: size) > width
+            token.grapheme_clusters.each do |cluster|
+              lines << line if !line.empty? && font.measure(line + cluster, size: size) > width
+              line = +"" if !line.empty? && font.measure(line + cluster, size: size) > width
+              line << cluster
+            end
+          else
+            line << token
+          end
+        end
+        lines << line.rstrip unless line.empty?
+        lines << "" if paragraph.empty? && lines.empty?
+        lines
+      end
+    end
+  end
+end

data/lib/okab/pdf/writer.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Okab
+  module PDF
+    class Writer
+      def initialize
+        @objects = []
+      end
+
+      def reserve
+        @objects << nil
+        @objects.length
+      end
+
+      def add(value)
+        @objects << value.b
+        @objects.length
+      end
+
+      def set(reference, value)
+        raise InvalidDocument, "invalid PDF object reference" unless reference.between?(1, @objects.length)
+        raise InvalidDocument, "PDF object already assigned" if @objects[reference - 1]
+
+        @objects[reference - 1] = value.b
+      end
+
+      def stream(data, dictionary = "")
+        add("<< /Length #{data.bytesize} #{dictionary} >>\nstream\n".b + data.b + "\nendstream".b)
+      end
+
+      def render(root:, info:)
+        raise InvalidDocument, "unassigned PDF object" if @objects.any?(&:nil?)
+
+        output = +"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n".b
+        offsets = [0]
+        @objects.each_with_index do |object, index|
+          offsets << output.bytesize
+          output << "#{index + 1} 0 obj\n".b << object << "\nendobj\n".b
+        end
+        xref = output.bytesize
+        output << "xref\n0 #{@objects.length + 1}\n0000000000 65535 f \n".b
+        offsets.drop(1).each { |offset| output << format("%010d 00000 n \n", offset).b }
+        output << "trailer\n<< /Size #{@objects.length + 1} /Root #{root} 0 R /Info #{info} 0 R >>\n".b
+        output << "startxref\n#{xref}\n%%EOF\n".b
+      end
+    end
+
+    module Encoding
+      module_function
+
+      def hex(bytes) = "<#{bytes.b.unpack1('H*')}>"
+
+      def number(value)
+        number = value.to_f
+        raise ArgumentError, "PDF numbers must be finite" unless number.finite?
+
+        BigDecimal(number.to_s).to_s("F")
+      end
+
+      def unicode_hex(text)
+        hex(text.encode(::Encoding::UTF_16BE).b)
+      end
+
+      def name(value)
+        value.to_s.b.gsub(/[^A-Za-z0-9_.+-]/) { |byte| format("#%02X", byte.ord) }
+      end
+    end
+  end
+end

data/lib/okab/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Okab
+  VERSION = "0.1.0"
+end

data/lib/okab.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "okab/version"
+require "alhena"
+
+module Okab
+  class Error < StandardError; end
+  class InvalidDocument < Error; end
+end
+
+require_relative "okab/pdf/writer"
+require_relative "okab/font"
+require_relative "okab/image"
+require_relative "okab/page"
+require_relative "okab/document"

data/sig/okab.rbs

@@ -0,0 +1,91 @@
+module Okab
+  class Error < StandardError
+  end
+
+  class InvalidDocument < Error
+  end
+
+  class Document
+    def initialize: (?title: String?, ?author: String?, ?creator: String?) -> void
+    def page: (width: Numeric, height: Numeric) { (Page) -> void } -> Page
+           | (width: Numeric, height: Numeric) -> Page
+    def outline: (String title, page: Page, ?level: Integer) -> self
+    def owns_page?: (Page page) -> bool
+    def render: () -> String
+    def write: (String path) -> String
+    def embed_font: (Font | Alhena::Font font, ?subset: bool) -> EmbeddedFont
+    def register_image: (Image image) -> String
+    def opacity_name: (Numeric value) -> String
+  end
+
+  class Path
+    attr_reader commands: Array[String]
+    def initialize: () -> void
+    def move_to: (Numeric x, Numeric y) -> self
+    def line_to: (Numeric x, Numeric y) -> self
+    def curve_to: (Numeric x1, Numeric y1, Numeric x2, Numeric y2, Numeric x3, Numeric y3) -> self
+    def close: () -> self
+    def rect: (Numeric x, Numeric y, Numeric width, Numeric height) -> self
+    def ellipse: (Numeric x, Numeric y, Numeric width, Numeric height) -> self
+  end
+
+  class Page
+    attr_reader width: Float
+    attr_reader height: Float
+    attr_reader operations: Array[Array[untyped]]
+    attr_reader annotations: Array[Array[untyped]]
+    attr_reader document: Document
+    def initialize: (Document document, width: Numeric, height: Numeric) -> void
+    def text: (String string, x: Numeric, y: Numeric, font: Font | EmbeddedFont | Alhena::Font, size: Numeric, ?color: Array[Numeric], ?tracking: Numeric, ?bold: bool, ?italic: bool) -> self
+    def text_block: (String string, x: Numeric, y: Numeric, width: Numeric, font: Font | EmbeddedFont | Alhena::Font, size: Numeric, line_height: Numeric, ?align: Symbol, ?color: Array[Numeric], ?tracking: Numeric) -> self
+    def move_to: (Numeric x, Numeric y) -> self
+    def line_to: (Numeric x, Numeric y) -> self
+    def curve_to: (Numeric x1, Numeric y1, Numeric x2, Numeric y2, Numeric x3, Numeric y3) -> self
+    def close: () -> self
+    def rect: (Numeric x, Numeric y, Numeric width, Numeric height) -> self
+    def ellipse: (Numeric x, Numeric y, Numeric width, Numeric height) -> self
+    def fill: (Array[Numeric] color) -> self
+    def stroke: (Array[Numeric] color, ?width: Numeric) -> self
+    def fill_and_stroke: (Array[Numeric] color, ?width: Numeric) -> self
+    def clip: () { (Path) -> void } -> self
+    def transform: (Numeric a, Numeric b, Numeric c, Numeric d, Numeric e, Numeric f) { (Page) -> void } -> self
+    def opacity: (Numeric value) { (Page) -> void } -> self
+    def image: (String | Image data, x: Numeric, y: Numeric, width: Numeric, height: Numeric, ?format: Symbol) -> self
+    def link: (Array[Numeric] bounds, ?uri: String, ?page: Page) -> self
+    def content: (fonts: Hash[Integer, String]) -> String
+  end
+
+  class Font
+    attr_reader face: Alhena::Font
+    def self.load: (String path) -> Font
+    def self.embed: (Document document, Font | Alhena::Font font, ?subset: bool) -> EmbeddedFont
+    def initialize: (Alhena::Font face) -> void
+    def measure: (String text, size: Numeric) -> Float
+  end
+
+  class EmbeddedFont
+    attr_reader document: Document
+    attr_reader font: Font
+    attr_reader subset: bool
+    def initialize: (Document document, Font font, ?subset: bool) -> void
+    def face: () -> Alhena::Font
+    def measure: (String text, size: Numeric) -> Float
+    def encode: (String string) -> String
+    def glyph_ids: () -> Array[Integer]
+    def subset_font: () -> [String, Alhena::Font, Hash[Integer, Integer], bool]
+    def characters: () -> Hash[Integer, [String, Integer]]
+    def base_name: (String data) -> String
+  end
+
+  class Image
+    attr_reader width: Integer
+    attr_reader height: Integer
+    attr_reader color_space: Symbol
+    attr_reader data: String
+    attr_reader alpha: String?
+    attr_reader filter: Symbol?
+    attr_reader decode_parms: String?
+    def self.decode: (String bytes, ?format: Symbol) -> Image
+    def initialize: (width: Integer, height: Integer, color_space: Symbol, data: String, ?alpha: String?, ?filter: Symbol?, ?decode_parms: String?) -> void
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: okab
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: alhena
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: A Ruby library for deterministic PDF generation with embedded TrueType
+  fonts, Japanese text extraction, vector graphics, PNG/JPEG images, links, and outlines.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/okab.rb
+- lib/okab/document.rb
+- lib/okab/font.rb
+- lib/okab/image.rb
+- lib/okab/page.rb
+- lib/okab/pdf/writer.rb
+- lib/okab/version.rb
+- sig/okab.rbs
+homepage: https://github.com/noxdea/okab
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/noxdea/okab
+  source_code_uri: https://github.com/noxdea/okab/tree/main
+  changelog_uri: https://github.com/noxdea/okab/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Generate searchable, font-embedded PDF documents
+test_files: []