alhena 0.1.0

data/lib/alhena/rasterizer.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Alhena
+  # Analytic signed-area scan conversion; no supersampling for grayscale.
+  class Rasterizer
+    MAX_PIXELS = 16_777_216
+
+    def initialize(width:, height:, tolerance: 0.25)
+      unless [width, height].all? { |n| n.is_a?(Integer) && n >= 0 && n <= MAX_PIXELS } && width * height <= MAX_PIXELS
+        raise ArgumentError, "invalid or excessively large raster dimensions"
+      end
+      raise ArgumentError, "tolerance must be positive" unless tolerance.is_a?(Numeric) && tolerance.finite? && tolerance > 0
+      @width, @height, @tolerance = width, height, tolerance.to_f
+    end
+
+    # Coordinates increase right and down. Open subpaths are implicitly closed.
+    # darkening is a coverage-space gain (0..1); gamma is a positive exponent.
+    def fill(outline, transform: nil, left: 0, top: 0, gamma: 1.0, darkening: 0.0, lcd: nil)
+      raise ArgumentError, "gamma must be positive" unless gamma.is_a?(Numeric) && gamma.finite? && gamma > 0
+      raise ArgumentError, "darkening must be between 0 and 1" unless darkening.is_a?(Numeric) && darkening.finite? && (0..1).cover?(darkening)
+      raise ArgumentError, "LCD order must be :rgb or :bgr" unless [nil, :rgb, :bgr].include?(lcd)
+      if @width.zero? || @height.zero?
+        return Bitmap.new(width: @width, height: @height, left: left, top: top, coverage: "", channels: lcd ? 3 : 1)
+      end
+      outline = outline.transform(transform) if transform
+      return lcd_bitmap(outline, left: left, top: top, gamma: gamma, darkening: darkening, order: lcd) if lcd
+      @area = Array.new((@width + 1) * @height, 0.0)
+      draw_outline(outline)
+      Bitmap.new(width: @width, height: @height, left: left, top: top, coverage: grayscale_coverage(gamma, darkening))
+    ensure
+      @area = nil
+    end
+
+    private
+
+    def lcd_bitmap(outline, left:, top:, gamma:, darkening:, order:)
+      high = self.class.new(width: @width * 3 + 4, height: @height, tolerance: @tolerance)
+      coverage = high.fill(outline, transform: [3, 0, 0, 1, 2, 0]).coverage
+      output = String.new(capacity: @width * @height * 3, encoding: Encoding::BINARY)
+      @height.times do |y|
+        @width.times do |x|
+          values = 3.times.map do |channel|
+            at = y * (@width * 3 + 4) + x * 3 + channel
+            value = (coverage.getbyte(at) + 2 * coverage.getbyte(at + 1) + 3 * coverage.getbyte(at + 2) +
+                     2 * coverage.getbyte(at + 3) + coverage.getbyte(at + 4)) / (9.0 * 255)
+            encode_coverage(value, gamma, darkening)
+          end
+          values.reverse! if order == :bgr
+          values.each { |value| output << value }
+        end
+      end
+      Bitmap.new(width: @width, height: @height, left: left, top: top, coverage: output, channels: 3)
+    end
+
+    def draw_outline(outline)
+      x = y = sx = sy = 0.0
+      opened = false
+      outline.each do |command, *args|
+        case command
+        when :move_to
+          draw_line(x, y, sx, sy) if opened
+          x, y = args
+          sx, sy = x, y
+          opened = true
+        when :line_to
+          draw_line(x, y, *args)
+          x, y = args
+        when :quad_to
+          flatten_quad(x, y, *args)
+          x, y = args[-2, 2]
+        when :cubic_to
+          flatten_cubic(x, y, *args)
+          x, y = args[-2, 2]
+        when :close
+          draw_line(x, y, sx, sy) if opened
+          x, y, opened = sx, sy, false
+        end
+      end
+      draw_line(x, y, sx, sy) if opened
+    end
+
+    def grayscale_coverage(gamma, darkening)
+      output = String.new(capacity: @width * @height, encoding: Encoding::BINARY)
+      @height.times do |row|
+        acc = 0.0
+        @width.times do |col|
+          acc += @area[row * (@width + 1) + col]
+          output << encode_coverage([acc.abs, 1.0].min, gamma, darkening)
+        end
+      end
+      output
+    end
+
+    def encode_coverage(value, gamma, darkening)
+      value = [value * (1.0 + darkening), 1.0].min
+      ((gamma == 1.0 ? value : value**(1.0 / gamma)) * 255).round
+    end
+
+    def flatten_quad(x0, y0, cx, cy, x1, y1)
+      deviation = [(x0 - 2 * cx + x1).abs, (y0 - 2 * cy + y1).abs].max
+      needed = [Math.sqrt(deviation / @tolerance).ceil, 1].max
+      count = [1 << (needed - 1).bit_length, 4096].min
+      px, py = x0, y0
+      1.upto(count) do |i|
+        t = i.to_f / count
+        s = 1.0 - t
+        x = s * s * x0 + 2 * s * t * cx + t * t * x1
+        y = s * s * y0 + 2 * s * t * cy + t * t * y1
+        draw_line(px, py, x, y)
+        px, py = x, y
+      end
+    end
+
+    def flatten_cubic(x0, y0, c1x, c1y, c2x, c2y, x1, y1, depth = 0)
+      deviation = [(2 * x1 - 3 * c2x + x0).abs, (2 * y1 - 3 * c2y + y0).abs,
+                   (x1 - 3 * c1x + 2 * x0).abs, (y1 - 3 * c1y + 2 * y0).abs].max
+      if deviation <= @tolerance * 2 || depth >= 16
+        draw_line(x0, y0, x1, y1)
+      else
+        ax, ay = (x0 + c1x) / 2.0, (y0 + c1y) / 2.0
+        bx, by = (c1x + c2x) / 2.0, (c1y + c2y) / 2.0
+        cx, cy = (c2x + x1) / 2.0, (c2y + y1) / 2.0
+        dx, dy = (ax + bx) / 2.0, (ay + by) / 2.0
+        ex, ey = (bx + cx) / 2.0, (by + cy) / 2.0
+        mx, my = (dx + ex) / 2.0, (dy + ey) / 2.0
+        flatten_cubic(x0, y0, ax, ay, dx, dy, mx, my, depth + 1)
+        flatten_cubic(mx, my, ex, ey, cx, cy, x1, y1, depth + 1)
+      end
+    end
+
+    # Integral of clamp(x, 0, 1), used to integrate an edge's cell coverage.
+    def coverage_integral(x)
+      x <= 0 ? 0.0 : x >= 1 ? x - 0.5 : x * x * 0.5
+    end
+
+    def draw_line(x0, y0, x1, y1)
+      return if y0 == y1 || @width.zero? || @height.zero?
+      sign = 1.0
+      if y0 > y1
+        x0, y0, x1, y1 = x1, y1, x0, y0
+        sign = -1.0
+      end
+      first, last = [y0.floor, 0].max, [y1.ceil, @height].min
+      slope = (x1 - x0) / (y1 - y0)
+      first.upto(last - 1) do |row|
+        ya, yb = [y0, row].max, [y1, row + 1].min
+        xa, xb = x0 + (ya - y0) * slope, x0 + (yb - y0) * slope
+        xa, xb = xb, xa if xa > xb
+        height = (yb - ya) * sign
+        at = row * (@width + 1)
+        if xb <= 0
+          @area[at] += height
+          next
+        end
+        next if xa >= @width
+        start, finish = [xa.floor, 0].max, [xb.floor, @width - 1].min
+        previous = 0.0
+        start.upto(finish) do |col|
+          fraction = if xb - xa < 1e-12
+            [[col + 1 - xa, 0].max, 1].min
+          else
+            (coverage_integral(col + 1 - xa) - coverage_integral(col + 1 - xb)) / (xb - xa)
+          end
+          value = height * fraction
+          @area[at + col] += value - previous
+          previous = value
+        end
+        @area[at + finish + 1] += height - previous
+      end
+    end
+  end
+end

data/lib/alhena/variation.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+module Alhena
+  # Shared ItemVariationStore interpolation used by CFF2, HVAR and VVAR.
+  class VariationStore
+    def initialize(data, offset, coordinates)
+      @data, @offset, @coordinates = data, offset, coordinates
+      raise InvalidFont, "invalid item variation store" unless data.u16(offset) == 1
+      region_offset = offset + data.u32(offset + 2)
+      count = data.u16(offset + 6)
+      data.validate_bounds(offset + 8, count * 4)
+      @items = count.times.map { |i| offset + data.u32(offset + 8 + i * 4) }
+      axes, regions = data.u16(region_offset), data.u16(region_offset + 2)
+      raise InvalidFont, "variation axis count mismatch" unless axes == coordinates.length
+      data.validate_bounds(region_offset + 4, axes * regions * 6)
+      @scalars = regions.times.map do |region|
+        scalar = 1.0
+        axes.times do |axis|
+          at = region_offset + 4 + (region * axes + axis) * 6
+          start, peak, finish = 3.times.map { |i| data.i16(at + i * 2) / 16_384.0 }
+          next if peak.zero? || start > peak || peak > finish || (start < 0 && finish > 0)
+          coordinate = coordinates[axis]
+          scalar *= if coordinate == peak
+            1.0
+          elsif coordinate <= start || coordinate >= finish
+            0.0
+          elsif coordinate < peak
+            (coordinate - start) / (peak - start)
+          else
+            (finish - coordinate) / (finish - peak)
+          end
+        end
+        scalar
+      end
+    end
+
+    def region_scalars(index)
+      at = @items.fetch(index) { raise InvalidFont, "variation outer index out of range" }
+      count = @data.u16(at + 4)
+      @data.validate_bounds(at + 6, count * 2)
+      count.times.map { |i| @scalars.fetch(@data.u16(at + 6 + i * 2)) { raise InvalidFont, "variation region out of range" } }
+    end
+
+    def delta(outer, inner)
+      return 0.0 if outer == 0xffff && inner == 0xffff
+      at = @items.fetch(outer) { raise InvalidFont, "variation outer index out of range" }
+      items, words, count = @data.u16(at), @data.u16(at + 2), @data.u16(at + 4)
+      raise InvalidFont, "variation inner index out of range" unless inner >= 0 && inner < items
+      long = words & 0x8000 != 0
+      words &= 0x7fff
+      raise InvalidFont, "invalid variation word count" if words > count
+      stride = long ? words * 4 + (count - words) * 2 : words * 2 + count - words
+      position = at + 6 + count * 2 + inner * stride
+      scalars = region_scalars(outer)
+      @data.validate_bounds(position, stride)
+      @data.position = position
+      scalars.each_with_index.sum do |scalar, i|
+        value = long ? (i < words ? @data.i32 : @data.i16) : (i < words ? @data.i16 : @data.i8)
+        value * scalar
+      end
+    end
+
+    def self.index(data, at, glyph)
+      return [0, glyph] if at.zero?
+      format, entry_format = data.u8(at), data.u8(at + 1)
+      raise InvalidFont, "invalid variation index map" unless [0, 1].include?(format)
+      count = format.zero? ? data.u16(at + 2) : data.u32(at + 2)
+      return [0xffff, 0xffff] if count.zero?
+      width = ((entry_format >> 4) & 3) + 1
+      bits = (entry_format & 15) + 1
+      start = at + (format.zero? ? 4 : 6) + [glyph, count - 1].min * width
+      value = 0
+      width.times { |i| value = (value << 8) | data.u8(start + i) }
+      [value >> bits, value & ((1 << bits) - 1)]
+    end
+  end
+
+  class Font
+    # Axis descriptors are in fvar order; coordinates use user-space values.
+    def axes
+      @axes ||= begin
+        if @tables.key?("fvar")
+          data = table("fvar")
+          offset, count, stride = data.u16(4), data.u16(8), data.u16(10)
+          raise InvalidFont, "invalid fvar axis record size" if stride < 20
+          data.validate_bounds(offset, count * stride)
+          count.times.to_h do |i|
+            at = offset + i * stride
+            tag = data.bytes(at, 4)
+            minimum, default, maximum = data.fixed(at + 4), data.fixed(at + 8), data.fixed(at + 12)
+            raise InvalidFont, "invalid fvar axis range" unless minimum <= default && default <= maximum
+            [tag, {min: minimum, default: default, max: maximum, hidden: data.u16(at + 16) & 1 != 0, name: names[data.u16(at + 18)]}.freeze]
+          end.freeze
+        else
+          {}.freeze
+        end
+      end
+    end
+
+    def variation(values)
+      self.class.new(@binary.data, index: @index, axes: @axis_values.merge(values.transform_keys(&:to_s)))
+    end
+
+    def normalized_coordinates
+      @normalized_coordinates ||= begin
+        unknown = @axis_values.keys - axes.keys
+        raise ArgumentError, "unknown variation axes: #{unknown.join(', ')}" unless unknown.empty?
+        values = axes.map do |tag, axis|
+          value = @axis_values.fetch(tag, axis[:default])
+          raise ArgumentError, "axis values must be finite" unless value.is_a?(Numeric) && value.finite?
+          value = [[value, axis[:min]].max, axis[:max]].min
+          value == axis[:default] ? 0.0 : (value - axis[:default]) / (value < axis[:default] ? axis[:default] - axis[:min] : axis[:max] - axis[:default])
+        end
+        if @tables.key?("avar")
+          data = table("avar")
+          raise UnsupportedFont, "avar version 2 is unsupported" unless data.u16(0) == 1
+          raise InvalidFont, "avar axis count mismatch" unless data.u16(6) == values.length
+          data.position = 8
+          values.map! do |value|
+            count = data.u16
+            maps = count.times.map { [data.i16 / 16_384.0, data.i16 / 16_384.0] }
+            raise InvalidFont, "invalid avar segment map" unless maps.length >= 3 && maps.each_cons(2).all? { |a, b| a[0] < b[0] }
+            match = maps.find { |from, _| from == value }
+            if match
+              match[1]
+            else
+              pair = maps.each_cons(2).find { |a, b| value > a[0] && value < b[0] }
+              raise InvalidFont, "avar map does not cover coordinate" unless pair
+              a, b = pair
+              a[1] + (b[1] - a[1]) * (value - a[0]) / (b[0] - a[0])
+            end
+          end
+        end
+        values.freeze
+      end
+    end
+
+    private
+
+    def variable? = @tables.key?("fvar") && normalized_coordinates.any? { |n| n != 0 }
+
+    def metric(glyph, vertical: false)
+      result = raw_metric(glyph, vertical: vertical)
+      return result unless variable?
+      tag = vertical ? "VVAR" : "HVAR"
+      if @tables.key?(tag)
+        data = table(tag)
+        @metric_stores ||= {}
+        store = @metric_stores[tag] ||= VariationStore.new(data, data.u32(4), normalized_coordinates)
+        result[0] += store.delta(*VariationStore.index(data, data.u32(8), glyph))
+        mapping = data.u32(12)
+        result[1] += store.delta(*VariationStore.index(data, mapping, glyph)) unless mapping.zero?
+      elsif @tables.key?("gvar")
+        @metric_deltas ||= {}
+        truetype_glyph(glyph, []) unless @metric_deltas.key?(glyph)
+        deltas = @metric_deltas.fetch(glyph, [0, 0])
+        result[0] += deltas[vertical ? 1 : 0]
+      end
+      result
+    end
+
+    def vary_points(glyph, points, ends, glyph_data)
+      return points unless variable? && @tables.key?("gvar")
+      # Phantom points let gvar supply advances when HVAR/VVAR are absent.
+      advance, bearing = raw_metric(glyph)
+      xmin = glyph_data.size >= 10 ? glyph_data.i16(2) : 0
+      ymax = glyph_data.size >= 10 ? glyph_data.i16(8) : 0
+      left = xmin - bearing
+      vadvance, vbearing = @tables.key?("vmtx") ? raw_metric(glyph, vertical: true) : [ascent - descent, ascent - ymax]
+      top = ymax + vbearing
+      all = points + [[left, 0], [left + advance, 0], [0, top], [0, top - vadvance]]
+      deltas = glyph_deltas(glyph, all, ends)
+      @metric_deltas ||= {}
+      @metric_deltas[glyph] = [deltas[-3][0] - deltas[-4][0], deltas[-2][1] - deltas[-1][1]]
+      points.each_with_index.map { |(x, y), i| [x + deltas[i][0], y + deltas[i][1]] }
+    end
+
+    def glyph_deltas(glyph, points, ends)
+      data = table("gvar")
+      axis_count = data.u16(4)
+      raise InvalidFont, "gvar axis count mismatch" unless axis_count == normalized_coordinates.length
+      raise InvalidFont, "gvar glyph count mismatch" unless data.u16(12) == glyph_count
+      long = data.u16(14) & 1 != 0
+      base = data.u32(16)
+      first = long ? data.u32(20 + glyph * 4) : data.u16(20 + glyph * 2) * 2
+      last = long ? data.u32(24 + glyph * 4) : data.u16(22 + glyph * 2) * 2
+      result = Array.new(points.length) { [0.0, 0.0] }
+      return result if first == last
+      record = Binary.new(data.bytes(base + first, last - first))
+      flags, serialized = record.u16, record.u16
+      headers = (flags & 0xfff).times.map do
+        size, index = record.u16, record.u16
+        peak = if index & 0x8000 != 0
+          axis_count.times.map { record.i16 / 16_384.0 }
+        else
+          shared = index & 0xfff
+          raise InvalidFont, "gvar shared tuple out of range" if shared >= data.u16(6)
+          location = data.u32(8) + shared * axis_count * 2
+          axis_count.times.map { |i| data.i16(location + i * 2) / 16_384.0 }
+        end
+        start, finish = if index & 0x4000 != 0
+          [axis_count.times.map { record.i16 / 16_384.0 }, axis_count.times.map { record.i16 / 16_384.0 }]
+        end
+        [size, index, peak, start, finish]
+      end
+      raise InvalidFont, "gvar expansion exceeds work limit" if points.length * headers.length > 4_000_000
+      raise InvalidFont, "overlapping gvar header and data" if record.position > serialized
+      record.position = serialized
+      shared_points = flags & 0x8000 != 0 ? packed_points(record, points.length) : nil
+      headers.each do |size, index, peak, start, finish|
+        tuple = Binary.new(record.bytes(record.position, size))
+        record.position += size
+        scalar = tuple_scalar(peak, start, finish)
+        next if scalar.zero?
+        selected = index & 0x2000 != 0 ? packed_points(tuple, points.length) : shared_points
+        selected ||= (0...points.length).to_a
+        dx, dy = packed_deltas(tuple, selected.length), packed_deltas(tuple, selected.length)
+        offsets = Array.new(points.length)
+        selected.each_with_index do |point, i|
+          offsets[point] ||= [0.0, 0.0]
+          offsets[point][0] += dx[i]
+          offsets[point][1] += dy[i]
+        end
+        interpolate_untouched(points, offsets, ends)
+        offsets.each_with_index do |delta, i|
+          next unless delta
+          result[i][0] += delta[0] * scalar
+          result[i][1] += delta[1] * scalar
+        end
+      end
+      result
+    end
+
+    def tuple_scalar(peak, start, finish)
+      scalar = 1.0
+      peak.each_with_index do |p, i|
+        next if p.zero?
+        value = normalized_coordinates[i]
+        if start
+          return 0.0 if value < start[i] || value > finish[i]
+          next if value == p
+          scalar *= value < p ? (value - start[i]) / (p - start[i]) : (finish[i] - value) / (finish[i] - p)
+        else
+          return 0.0 if value.zero? || value * p < 0
+          scalar *= value / p if value.abs < p.abs
+        end
+      end
+      scalar
+    end
+
+    def packed_points(data, maximum)
+      count = data.u8
+      return nil if count.zero?
+      count = ((count & 0x7f) << 8) | data.u8 if count & 0x80 != 0
+      points, previous = [], 0
+      while points.length < count
+        control = data.u8
+        run = (control & 0x7f) + 1
+        raise InvalidFont, "gvar point run overflow" if points.length + run > count
+        run.times do
+          previous += control & 0x80 != 0 ? data.u16 : data.u8
+          raise InvalidFont, "gvar point out of bounds" if previous >= maximum
+          points << previous
+        end
+      end
+      points
+    end
+
+    def packed_deltas(data, count)
+      result = []
+      while result.length < count
+        control = data.u8
+        length = (control & 0x3f) + 1
+        raise InvalidFont, "gvar delta run overflow" if result.length + length > count
+        length.times { result << (control & 0x80 != 0 ? 0 : control & 0x40 != 0 ? data.i16 : data.i8) }
+      end
+      result
+    end
+
+    def interpolate_untouched(points, deltas, ends)
+      first = 0
+      ends.each do |last|
+        touched = (first..last).select { |i| deltas[i] }
+        if touched.length == 1
+          (first..last).each { |i| deltas[i] ||= deltas[touched[0]].dup }
+        elsif touched.length > 1
+          touched.each_with_index do |a, index|
+            b = touched[(index + 1) % touched.length]
+            cursor = a == last ? first : a + 1
+            while cursor != b
+              deltas[cursor] = 2.times.map do |axis|
+                c1, c2 = points[a][axis], points[b][axis]
+                d1, d2 = deltas[a][axis], deltas[b][axis]
+                c1, c2, d1, d2 = c2, c1, d2, d1 if c1 > c2
+                value = points[cursor][axis]
+                if c1 == c2
+                  d1 == d2 ? d1 : 0.0
+                elsif value <= c1
+                  d1
+                elsif value >= c2
+                  d2
+                else
+                  d1 + (d2 - d1) * (value - c1).to_f / (c2 - c1)
+                end
+              end
+              cursor = cursor == last ? first : cursor + 1
+            end
+          end
+        end
+        first = last + 1
+      end
+    end
+  end
+end

data/lib/alhena/version.rb

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

data/lib/alhena.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "alhena/version"
+require_relative "alhena/data_compat"
+
+module Alhena
+  class Error < StandardError; end
+  class InvalidFont < Error; end
+  class UnsupportedFont < Error; end
+end
+
+require_relative "alhena/bitmap"
+require_relative "alhena/outline"
+require_relative "alhena/binary"
+require_relative "alhena/rasterizer"
+require_relative "alhena/cff"
+require_relative "alhena/font"
+require_relative "alhena/variation"
+require_relative "alhena/png"
+require_relative "alhena/color"
+require_relative "alhena/cache"

data/sig/alhena.rbs

@@ -0,0 +1,117 @@
+module Alhena
+  VERSION: String
+  type matrix = Array[Numeric]
+  class Error < StandardError
+  end
+  class InvalidFont < Error
+  end
+  class UnsupportedFont < Error
+  end
+  class Binary
+    attr_reader data: String
+    attr_accessor position: Integer
+    def initialize: (String data) -> void
+    def size: () -> Integer
+    def bytes: (Integer offset, Integer length) -> String
+    def validate_bounds: (Integer offset, Integer length) -> void
+    def check: (Integer offset, Integer length) -> void
+    def u8: (?Integer? offset) -> Integer
+    def i8: (?Integer? offset) -> Integer
+    def u16: (?Integer? offset) -> Integer
+    def i16: (?Integer? offset) -> Integer
+    def u24: (?Integer? offset) -> Integer
+    def u32: (?Integer? offset) -> Integer
+    def i32: (?Integer? offset) -> Integer
+    def fixed: (?Integer? offset) -> Float
+  end
+  class Outline
+    attr_reader commands: Array[Symbol]
+    attr_reader coordinates: Array[Float]
+    def initialize: () -> void
+    def move_to: (Numeric x, Numeric y) -> self
+    def line_to: (Numeric x, Numeric y) -> self
+    def quad_to: (Numeric cx, Numeric cy, Numeric x, Numeric y) -> self
+    def cubic_to: (Numeric c1x, Numeric c1y, Numeric c2x, Numeric c2y, Numeric x, Numeric y) -> self
+    def close: () -> self
+    def empty?: () -> bool
+    def each: () { (Symbol, *Float) -> void } -> self
+            | () -> Enumerator[untyped, self]
+    def transform: (matrix) -> Outline
+    def append: (Outline) -> self
+    def bounds: () -> [Numeric, Numeric, Numeric, Numeric]
+    def to_quadratic: (?tolerance: Numeric) -> Outline
+  end
+  class Bitmap
+    attr_reader width: Integer
+    attr_reader height: Integer
+    attr_reader left: Integer
+    attr_reader top: Integer
+    attr_reader coverage: String
+    attr_reader channels: Integer
+    def initialize: (width: Integer, height: Integer, coverage: String, ?left: Integer, ?top: Integer, ?channels: Integer) -> void
+    def to_ascii: (?ramp: String) -> String
+  end
+  class Font
+    attr_reader index: Integer
+    attr_reader tables: Hash[String, [Integer, Integer]]
+    attr_reader axis_values: Hash[String, Numeric]
+    def data: () -> String
+    def self.open: (String path, ?index: Integer, ?axes: Hash[String | Symbol, Numeric]) -> Font
+    def initialize: (String data, ?index: Integer, ?axes: Hash[String | Symbol, Numeric]) -> void
+    def table: (String tag) -> Binary
+    def units_per_em: () -> Integer
+    def glyph_count: () -> Integer
+    def ascent: () -> Integer
+    def descent: () -> Integer
+    def line_gap: () -> Integer
+    def names: () -> Hash[Integer, String]
+    def family: () -> String?
+    def os2: () -> Hash[Symbol, Integer]
+    def post: () -> Hash[Symbol, Numeric | bool]
+    def glyph_id: (String | Integer character, ?variation_selector: String | Integer | nil) -> Integer
+    def advance: (Integer glyph, ?size: Numeric, ?vertical: bool) -> Float
+    def bearing: (Integer glyph, ?size: Numeric, ?vertical: bool) -> Float
+    def outline: (Integer glyph) -> Outline
+    def axes: () -> Hash[String, Hash[Symbol, Numeric | bool | String | nil]]
+    def variation: (Hash[String | Symbol, Numeric]) -> Font
+    def normalized_coordinates: () -> Array[Float]
+    def palettes: () -> Array[Array[Array[Integer]]]
+    def color_layers: (Integer glyph) -> Array[[Integer, Integer]]?
+    def color_bitmap: (Integer glyph, size: Numeric, ?palette: Integer, ?foreground: Array[Integer], ?subpixel_x: Numeric) -> ColorBitmap?
+    def embedded_bitmap: (Integer glyph, size: Numeric) -> EmbeddedBitmap?
+    def rasterize: (Integer glyph, size: Numeric, ?subpixel_x: Numeric, ?tolerance: Numeric, ?gamma: Numeric, ?darkening: Numeric, ?lcd: :rgb | :bgr | nil) -> Bitmap
+  end
+  class ColorBitmap
+    attr_reader width: Integer
+    attr_reader height: Integer
+    attr_reader left: Integer
+    attr_reader top: Integer
+    attr_reader rgba: String
+    def initialize: (width: Integer, height: Integer, rgba: String, ?left: Integer, ?top: Integer) -> void
+    def to_bitmap: () -> Bitmap
+    def resize: (Numeric factor) -> ColorBitmap
+  end
+  class EmbeddedBitmap < Data
+    attr_reader format: Symbol
+    attr_reader data: String
+    attr_reader ppem: Integer
+    attr_reader left: Integer
+    attr_reader top: Integer?
+    attr_reader width: Integer?
+    attr_reader height: Integer?
+  end
+  class Rasterizer
+    MAX_PIXELS: Integer
+    def initialize: (width: Integer, height: Integer, ?tolerance: Numeric) -> void
+    def fill: (Outline, ?transform: matrix?, ?left: Integer, ?top: Integer, ?gamma: Numeric, ?darkening: Numeric, ?lcd: :rgb | :bgr | nil) -> Bitmap
+  end
+  class Cache
+    attr_reader capacity: Integer
+    attr_reader bytesize: Integer
+    def initialize: (?capacity: Integer, ?max_bytes: Integer?) -> void
+    def size: () -> Integer
+    def rasterize: (Font font, Integer glyph, size: Numeric, ?subpixel_x: Numeric, **untyped options) -> Bitmap
+    def prewarm: (Font font, String text, ?Numeric? size, **untyped options) -> self
+    def clear: () -> self
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: alhena
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Read sfnt and TTC fonts, extract outlines, and produce antialiased grayscale
+  or LCD glyph bitmaps without native dependencies.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- examples/color.rb
+- examples/render.rb
+- lib/alhena.rb
+- lib/alhena/binary.rb
+- lib/alhena/bitmap.rb
+- lib/alhena/cache.rb
+- lib/alhena/cff.rb
+- lib/alhena/color.rb
+- lib/alhena/data_compat.rb
+- lib/alhena/font.rb
+- lib/alhena/outline.rb
+- lib/alhena/png.rb
+- lib/alhena/rasterizer.rb
+- lib/alhena/variation.rb
+- lib/alhena/version.rb
+- sig/alhena.rbs
+homepage: https://github.com/noxdea/alhena
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/noxdea/alhena
+  changelog_uri: https://github.com/noxdea/alhena/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.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: Pure Ruby TrueType and CFF font rasterization
+test_files: []