zaniah 0.1.0

data/lib/zaniah/scene_renderer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class SceneRenderer
+    def initialize(device) = @device = device
+    def render(scene, clear: "#0000") = @device.render(scene, clear: clear)
+  end
+end

data/lib/zaniah/size.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Zaniah
+  Size = Data.define(:width, :height)
+end

data/lib/zaniah/subscription.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Subscription
+    def initialize(&detach) = @detach = detach
+
+    def detach
+      callback, @detach = @detach, nil
+      callback&.call
+    end
+
+    def attached? = !@detach.nil?
+  end
+end

data/lib/zaniah/svg/path.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Zaniah
+  class SVG
+    class Path
+      # SVG path grammar, including compact arc flags and smooth relative curves.
+      NUMBER = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/
+      def self.parse(source) = new(source).parse
+      def initialize(source)
+        @scanner, @outline = StringScanner.new(source), Alhena::Outline.new
+        @x = @y = @start_x = @start_y = 0.0
+        @previous, @control = nil, nil
+      end
+
+      def parse
+        command, operations = nil, 0
+        loop do
+          separator
+          break if @scanner.eos?
+          explicit = @scanner.scan(/[a-zA-Z]/)
+          command = explicit if explicit
+          raise ArgumentError, "SVG path must start with moveto" if @previous.nil? && !%w[M m].include?(command)
+          raise ArgumentError, "missing SVG path command" unless command
+          operations += 1
+          raise ArgumentError, "SVG path is too complex" if operations > 100_000
+          relative, type = command == command.downcase, command.upcase
+          case type
+          when "M", "L", "T"
+            x, y = point(relative)
+            if type == "M"
+              @outline.move_to(x, y)
+              @start_x, @start_y = x, y
+            elsif type == "T"
+              control = %w[Q T].include?(@previous) ? reflected : [@x, @y]
+              @outline.quad_to(*control, x, y)
+              @control = control
+            else
+              @outline.line_to(x, y)
+            end
+            @x, @y = x, y
+          when "H"
+            @x = number + (relative ? @x : 0)
+            @outline.line_to(@x, @y)
+          when "V"
+            @y = number + (relative ? @y : 0)
+            @outline.line_to(@x, @y)
+          when "C"
+            a, b, endpoint = point(relative), point(relative), point(relative)
+            @outline.cubic_to(*a, *b, *endpoint)
+            @control, (@x, @y) = b, endpoint
+          when "S"
+            a = %w[C S].include?(@previous) ? reflected : [@x, @y]
+            b, endpoint = point(relative), point(relative)
+            @outline.cubic_to(*a, *b, *endpoint)
+            @control, (@x, @y) = b, endpoint
+          when "Q"
+            a, endpoint = point(relative), point(relative)
+            @outline.quad_to(*a, *endpoint)
+            @control, (@x, @y) = a, endpoint
+          when "A"
+            rx, ry, rotation, large, sweep = number, number, number, flag, flag
+            endpoint = point(relative)
+            arc(rx, ry, rotation, large, sweep, *endpoint)
+            @x, @y = endpoint
+          when "Z"
+            raise ArgumentError, "closepath cannot repeat without a command" unless explicit
+            @outline.close
+            @x, @y = @start_x, @start_y
+            command = nil
+          else raise ArgumentError, "unsupported SVG path command #{command}"
+          end
+          @previous = type
+          command = relative ? "l" : "L" if type == "M"
+        end
+        @outline
+      end
+
+      private
+
+      def separator = @scanner.skip(/[\s,]*/)
+      def number
+        separator
+        token = @scanner.scan(NUMBER)
+        raise ArgumentError, "invalid SVG path number near #{@scanner.peek(20).inspect}" unless token
+        value = Float(token)
+        raise ArgumentError, "SVG coordinate is out of range" unless value.finite? && value.abs <= 1e9
+        value
+      end
+      def flag
+        separator
+        token = @scanner.scan(/[01]/)
+        raise ArgumentError, "invalid SVG arc flag" unless token
+        token == "1"
+      end
+      def point(relative) = [number + (relative ? @x : 0), number + (relative ? @y : 0)]
+      def reflected = [2 * @x - @control[0], 2 * @y - @control[1]]
+
+      def arc(rx, ry, rotation, large, sweep, x, y)
+        return if x == @x && y == @y
+        rx, ry = rx.abs, ry.abs
+        return @outline.line_to(x, y) if rx.zero? || ry.zero?
+        phi = rotation * Math::PI / 180
+        cos, sin = Math.cos(phi), Math.sin(phi)
+        dx, dy = (@x - x) / 2, (@y - y) / 2
+        px, py = cos * dx + sin * dy, -sin * dx + cos * dy
+        scale = px * px / (rx * rx) + py * py / (ry * ry)
+        rx, ry = rx * Math.sqrt(scale), ry * Math.sqrt(scale) if scale > 1
+        rx2, ry2 = rx * rx, ry * ry
+        numerator = [rx2 * ry2 - rx2 * py * py - ry2 * px * px, 0].max
+        coefficient = Math.sqrt(numerator / (rx2 * py * py + ry2 * px * px)) * (large == sweep ? -1 : 1)
+        cxp, cyp = coefficient * rx * py / ry, -coefficient * ry * px / rx
+        cx, cy = cos * cxp - sin * cyp + (@x + x) / 2, sin * cxp + cos * cyp + (@y + y) / 2
+        ux, uy, vx, vy = (px - cxp) / rx, (py - cyp) / ry, (-px - cxp) / rx, (-py - cyp) / ry
+        theta = Math.atan2(uy, ux)
+        delta = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy)
+        delta -= 2 * Math::PI if !sweep && delta.positive?
+        delta += 2 * Math::PI if sweep && delta.negative?
+        segments = (delta.abs / (Math::PI / 2)).ceil
+        step = delta / segments
+        mapped = ->(a, b) { [cx + cos * rx * a - sin * ry * b, cy + sin * rx * a + cos * ry * b] }
+        segments.times do
+          ending, factor = theta + step, 4.0 / 3 * Math.tan(step / 4)
+          a = mapped.call(Math.cos(theta) - factor * Math.sin(theta), Math.sin(theta) + factor * Math.cos(theta))
+          b = mapped.call(Math.cos(ending) + factor * Math.sin(ending), Math.sin(ending) - factor * Math.cos(ending))
+          endpoint = mapped.call(Math.cos(ending), Math.sin(ending))
+          @outline.cubic_to(*a, *b, *endpoint)
+          theta = ending
+        end
+      end
+    end
+  end
+end

data/lib/zaniah/svg/rasterizable.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class SVG
+    module Rasterizable
+    private
+
+    def contours(outline, tolerance: 0.15)
+      result, points, x, y = [], nil, 0.0, 0.0
+      outline.to_quadratic(tolerance: tolerance).each do |command, *values|
+        case command
+        when :move_to
+          result << [points, false] if points
+          x, y = values
+          points = [[x, y]]
+        when :line_to
+          points ||= [[x, y]]
+          x, y = values
+          points << [x, y]
+        when :quad_to
+          points ||= [[x, y]]
+          cx, cy, endpoint_x, endpoint_y = values
+          flatten_quad(points, x, y, cx, cy, endpoint_x, endpoint_y, tolerance, 0)
+          x, y = endpoint_x, endpoint_y
+        when :close
+          next unless points
+          result << [points, true]
+          x, y = points.first
+          points = nil
+        end
+      end
+      result << [points, false] if points
+      result
+    end
+
+    def flatten_quad(points, x, y, cx, cy, ex, ey, tolerance, depth)
+      raise ArgumentError, "SVG curve is too complex" if points.length > 100_000
+      if depth >= 16 || Math.hypot(x - 2 * cx + ex, y - 2 * cy + ey) <= tolerance * 4
+        points << [ex, ey]
+      else
+        ax, ay, bx, by = (x + cx) / 2, (y + cy) / 2, (cx + ex) / 2, (cy + ey) / 2
+        mx, my = (ax + bx) / 2, (ay + by) / 2
+        flatten_quad(points, x, y, ax, ay, mx, my, tolerance, depth + 1)
+        flatten_quad(points, mx, my, bx, by, ex, ey, tolerance, depth + 1)
+      end
+    end
+
+    def mask(outline, width, height, rule)
+      return Alhena::Rasterizer.new(width: width, height: height).fill(outline).coverage if rule == "nonzero"
+      raise ArgumentError, "unknown SVG fill rule #{rule}" unless rule == "evenodd"
+      # The font rasterizer deliberately uses nonzero winding. Even-odd icons
+      # need parity instead: subpixel scanlines pair sorted edge intersections.
+      edges = contours(outline).flat_map do |points, _closed|
+        next [] if points.length < 2
+        (points + [points.first]).each_cons(2).reject { |a, b| a[1] == b[1] }.to_a
+      end
+      coverage = "\0".b * (width * height)
+      height.times do |row|
+        sums = Array.new(width, 0.0)
+        8.times do |sample|
+          y = row + (sample + 0.5) / 8
+          intersections = edges.filter_map do |a, b|
+            low, high = [a[1], b[1]].minmax
+            a[0] + (y - a[1]) * (b[0] - a[0]) / (b[1] - a[1]) if low <= y && y < high
+          end.sort
+          intersections.each_slice(2) do |left, right|
+            next unless right
+            left, right = left.clamp(0, width), right.clamp(0, width)
+            next if right <= left
+            (left.floor...[right.ceil, width].min).each do |column|
+              sums[column] += [right, column + 1].min - [left, column].max
+            end
+          end
+        end
+        sums.each_with_index { |amount, column| coverage.setbyte(row * width + column, (amount * 255 / 8).round.clamp(0, 255)) }
+      end
+      coverage
+    end
+
+    def clip_mask(element, matrix, width, height, references, inherited = {"clip-rule" => "nonzero"})
+      raise ArgumentError, "SVG clip is too complex" if references.length > 32
+      raise ArgumentError, "objectBoundingBox clips are not supported" if element.attributes["clipPathUnits"] == "objectBoundingBox"
+      style = properties(element, inherited)
+      output = "\0".b * (width * height)
+      return output if style["display"] == "none" || style["visibility"] == "hidden"
+      matrix = multiply(matrix, transform(element.attributes["transform"]))
+      if (outline = @paths[element])
+        return mask(outline.transform(matrix), width, height, style.fetch("clip-rule", "nonzero"))
+      end
+      children = element.elements.to_a
+      if element.name == "use"
+        href = element.attributes["href"] || element.attributes["xlink:href"]
+        raise ArgumentError, "invalid or cyclic clip use" unless href&.start_with?("#") && !references.include?(href)
+        children = [@ids.fetch(href.delete_prefix("#")) { raise ArgumentError, "unknown clip use #{href}" }]
+        matrix = multiply(matrix, [1, 0, 0, 1, length(element.attributes["x"]), length(element.attributes["y"])])
+        references += [href]
+      end
+      children.each do |child|
+        next if %w[title desc metadata defs].include?(child.name)
+        layer = clip_mask(child, matrix, width, height, references, style)
+        output.bytesize.times do |i|
+          a, b = output.getbyte(i), layer.getbyte(i)
+          output.setbyte(i, a + b - (a * b / 255.0).round)
+        end
+      end
+      output
+    end
+
+    def polygon(outline, points)
+      return if points.length < 3
+      # All stroke pieces have matching winding so their overlap is a union.
+      area = (points + [points.first]).each_cons(2).sum { |a, b| a[0] * b[1] - b[0] * a[1] }
+      points = points.reverse if area.negative?
+      outline.move_to(*points.first)
+      points.drop(1).each { |point| outline.line_to(*point) }
+      outline.close
+    end
+
+    def disk(outline, center, radius)
+      segments = [[(Math::PI * Math.sqrt(radius / 0.075)).ceil, 12].max, 512].min
+      polygon(outline, Array.new(segments) do |i|
+        angle = i * 2 * Math::PI / segments
+        [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius]
+      end)
+    end
+
+    def stroke(outline, width, style)
+      cap, join = style["stroke-linecap"], style["stroke-linejoin"]
+      raise ArgumentError, "unknown SVG line cap" unless %w[butt round square].include?(cap)
+      raise ArgumentError, "unknown SVG line join" unless %w[miter round bevel].include?(join)
+      limit = number(style["stroke-miterlimit"])
+      raise ArgumentError, "SVG miter limit must be at least one" if limit < 1
+      radius, result = width / 2.0, Alhena::Outline.new
+      contours(outline).each do |points, closed|
+        points = points.each_with_object([]) { |point, unique| unique << point if unique.last != point }
+        points.pop if closed && points.length > 1 && points.first == points.last
+        if points.length == 1
+          disk(result, points.first, radius) if cap == "round"
+          if cap == "square"
+            x, y = points.first
+            polygon(result, [[x - radius, y - radius], [x + radius, y - radius], [x + radius, y + radius], [x - radius, y + radius]])
+          end
+          next
+        end
+        segments = (closed ? points + [points.first] : points).each_cons(2).map do |a, b|
+          dx, dy = b[0] - a[0], b[1] - a[1]
+          length = Math.hypot(dx, dy)
+          [a, b, dx / length, dy / length]
+        end
+        segments.each_with_index do |(a, b, dx, dy), index|
+          nx, ny = -dy * radius, dx * radius
+          start_cap = !closed && index.zero? && cap == "square" ? radius : 0
+          end_cap = !closed && index == segments.length - 1 && cap == "square" ? radius : 0
+          ax, ay, bx, by = a[0] - dx * start_cap, a[1] - dy * start_cap, b[0] + dx * end_cap, b[1] + dy * end_cap
+          polygon(result, [[ax + nx, ay + ny], [bx + nx, by + ny], [bx - nx, by - ny], [ax - nx, ay - ny]])
+        end
+        pairs = (closed ? segments + [segments.first] : segments).each_cons(2)
+        pairs.each do |left, right|
+          vertex, dx, dy, ex, ey = left[1], left[2], left[3], right[2], right[3]
+          cross = dx * ey - dy * ex
+          next if cross.abs < 1e-10
+          if join == "round"
+            disk(result, vertex, radius)
+            next
+          end
+          sign = cross.positive? ? -1 : 1
+          a = [vertex[0] - dy * radius * sign, vertex[1] + dx * radius * sign]
+          b = [vertex[0] - ey * radius * sign, vertex[1] + ex * radius * sign]
+          distance = ((b[0] - a[0]) * ey - (b[1] - a[1]) * ex) / cross
+          miter = [a[0] + distance * dx, a[1] + distance * dy]
+          if join == "miter" && Math.hypot(miter[0] - vertex[0], miter[1] - vertex[1]) <= radius * limit
+            polygon(result, [vertex, a, miter, b])
+          else
+            polygon(result, [vertex, a, b])
+          end
+        end
+        if !closed && cap == "round"
+          disk(result, points.first, radius)
+          disk(result, points.last, radius)
+        end
+      end
+      result
+    end
+    end
+  end
+end

data/lib/zaniah/svg.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+
+module Zaniah
+  # Static vector icons. No scripting, external resources, or browser engine.
+  class SVG < Element
+    IDENTITY = [1, 0, 0, 1, 0, 0].freeze
+    DEFAULTS = {"fill" => "black", "stroke" => "none", "stroke-width" => "1",
+      "fill-rule" => "nonzero", "fill-opacity" => "1", "stroke-opacity" => "1",
+      "stroke-linecap" => "butt", "stroke-linejoin" => "miter", "stroke-miterlimit" => "4"}.freeze
+    PRESENTATION = (DEFAULTS.keys + %w[color opacity display visibility clip-path clip-rule]).freeze
+    ELEMENTS = %w[svg g path rect circle ellipse line polyline polygon defs use clipPath title desc metadata].freeze
+    NAMES = {"black" => "#000", "white" => "#fff", "red" => "#f00", "green" => "#008000",
+      "blue" => "#00f", "yellow" => "#ff0", "gray" => "#808080", "grey" => "#808080",
+      "silver" => "#c0c0c0", "maroon" => "#800000", "purple" => "#800080", "fuchsia" => "#f0f",
+      "lime" => "#0f0", "olive" => "#808000", "navy" => "#000080", "teal" => "#008080",
+      "aqua" => "#0ff", "orange" => "#ffa500", "transparent" => "#0000", "rebeccapurple" => "#639"}.freeze
+    attr_reader :width, :height, :view_box
+
+    def self.parse(source, **options) = new(source, **options)
+    def self.open(path, **options) = new(File.binread(path), **options)
+
+    def initialize(source, color: "#000")
+      super()
+      require "alhena"
+      raise ArgumentError, "SVG exceeds 2 MiB" if source.bytesize > 2 * 1024 * 1024
+      raise ArgumentError, "SVG document types and entities are forbidden" if source.match?(/<!\s*(?:DOCTYPE|ENTITY)/i)
+      @root = REXML::Document.new(source).root
+      raise ArgumentError, "expected an SVG root" unless @root&.name == "svg"
+      @ids, @paths, @textures, @color = {}, {}, {}, color
+      validate(@root, 0, [0])
+      @view_box = numbers(@root.attributes["viewBox"]) if @root.attributes["viewBox"]
+      if @view_box && (@view_box.length != 4 || !@view_box[2].positive? || !@view_box[3].positive?)
+        raise ArgumentError, "viewBox must contain x y width height with positive dimensions"
+      end
+      @width = length(@root.attributes["width"], @view_box ? @view_box[2] : 300, percentage: true)
+      @height = length(@root.attributes["height"], @view_box ? @view_box[3] : 150, percentage: true)
+      raise ArgumentError, "SVG dimensions must be positive" unless @width.positive? && @height.positive?
+      @view_box ||= [0, 0, @width, @height]
+    rescue REXML::ParseException => error
+      raise ArgumentError, "invalid SVG: #{error.message.lines.first}"
+    end
+
+    def request_layout(_cx)
+      @layout_node = Layout::Node.new(style: @style, measure: ->(_w, _h) { [@width, @height] })
+    end
+
+    def paint(bounds, _state, _pre, cx)
+      return if bounds.width <= 0 || bounds.height <= 0
+      scale = cx.window.respond_to?(:scale_factor) ? cx.window.scale_factor : 1
+      raster = texture(width: (bounds.width * scale).ceil, height: (bounds.height * scale).ceil)
+      cx.scene.sprite(bounds.x, bounds.y, bounds.width, bounds.height, texture: raster)
+    end
+
+    def texture(width: @width.ceil, height: @height.ceil, color: @color)
+      unless width.is_a?(Integer) && height.is_a?(Integer) && width.positive? && height.positive? && width * height <= 1_048_576
+        raise ArgumentError, "SVG raster dimensions must be positive and at most 1 megapixel"
+      end
+      key = [width, height, color]
+      return @textures[key] if @textures.key?(key)
+      pixels = "\0".b * (width * height * 4)
+      render(@root, pixels, viewport(width, height), DEFAULTS.merge("color" => color), width, height, [])
+      @textures.shift if @textures.length >= 8
+      @textures[key] = GPU::Texture.new(width, height, data: pixels)
+    end
+
+    private
+
+    def validate(element, depth, count)
+      count[0] += 1
+      raise ArgumentError, "SVG tree is too complex" if depth > 64 || count[0] > 10_000
+      raise ArgumentError, "unsupported SVG element #{element.name}" unless ELEMENTS.include?(element.name)
+      raise ArgumentError, "nested SVG viewports are not supported" if depth.positive? && element.name == "svg"
+      %w[filter mask stroke-dasharray marker-start marker-mid marker-end].each do |attribute|
+        raise ArgumentError, "unsupported SVG attribute #{attribute}" if element.attributes[attribute]
+      end
+      @ids[element.attributes["id"]] = element if element.attributes["id"]
+      @paths[element] = geometry(element) if %w[path rect circle ellipse line polyline polygon].include?(element.name)
+      element.elements.each { |child| validate(child, depth + 1, count) }
+    end
+
+    def number(value)
+      text = value.to_s.strip
+      raise ArgumentError, "invalid SVG number #{value.inspect}" unless text.match?(/\A#{Path::NUMBER}\z/)
+      result = Float(text)
+      raise ArgumentError, "SVG number out of range" unless result.finite? && result.abs <= 1e9
+      result
+    end
+
+    def numbers(value)
+      scanner, result = StringScanner.new(value.to_s), []
+      until scanner.eos?
+        scanner.skip(/[\s,]*/)
+        break if scanner.eos?
+        token = scanner.scan(Path::NUMBER)
+        raise ArgumentError, "invalid SVG number list" unless token
+        result << number(token)
+      end
+      result
+    end
+
+    def length(value, fallback = 0, percentage: false)
+      return fallback unless value
+      text = value.to_s.strip
+      if text.end_with?("%")
+        raise ArgumentError, "percentage SVG geometry is not supported" unless percentage
+        return number(text.delete_suffix("%")) * fallback / 100
+      end
+      number(text.delete_suffix("px"))
+    end
+
+    def geometry(element)
+      attr = element.attributes
+      get = ->(key, fallback = 0) { length(attr[key], fallback) }
+      case element.name
+      when "path" then Path.parse(attr["d"].to_s)
+      when "line" then Alhena::Outline.new.move_to(get.call("x1"), get.call("y1")).line_to(get.call("x2"), get.call("y2"))
+      when "polyline", "polygon"
+        points = numbers(attr["points"])
+        raise ArgumentError, "polygon needs coordinate pairs" if points.length.odd?
+        outline = Alhena::Outline.new
+        points.each_slice(2).with_index { |point, i| outline.public_send(i.zero? ? :move_to : :line_to, *point) }
+        outline.close if element.name == "polygon" && !outline.empty?
+        outline
+      when "circle", "ellipse"
+        cx, cy = get.call("cx"), get.call("cy")
+        rx, ry = element.name == "circle" ? [get.call("r")] * 2 : [get.call("rx"), get.call("ry")]
+        raise ArgumentError, "negative ellipse radius" if rx.negative? || ry.negative?
+        return Alhena::Outline.new if rx.zero? || ry.zero?
+        Path.parse("M#{cx + rx} #{cy} A#{rx} #{ry} 0 1 1 #{cx - rx} #{cy} A#{rx} #{ry} 0 1 1 #{cx + rx} #{cy}Z")
+      when "rect"
+        x, y, w, h = get.call("x"), get.call("y"), get.call("width"), get.call("height")
+        raise ArgumentError, "negative rectangle size" if w.negative? || h.negative?
+        return Alhena::Outline.new if w.zero? || h.zero?
+        rx, ry = get.call("rx", get.call("ry")), get.call("ry", get.call("rx"))
+        raise ArgumentError, "negative rectangle radius" if rx.negative? || ry.negative?
+        rx, ry = [rx, w / 2].min, [ry, h / 2].min
+        if rx.zero? || ry.zero?
+          Alhena::Outline.new.move_to(x, y).line_to(x + w, y).line_to(x + w, y + h).line_to(x, y + h).close
+        else
+          Path.parse("M#{x + rx} #{y}H#{x + w - rx}A#{rx} #{ry} 0 0 1 #{x + w} #{y + ry}V#{y + h - ry}A#{rx} #{ry} 0 0 1 #{x + w - rx} #{y + h}H#{x + rx}A#{rx} #{ry} 0 0 1 #{x} #{y + h - ry}V#{y + ry}A#{rx} #{ry} 0 0 1 #{x + rx} #{y}Z")
+        end
+      end
+    end
+
+    def multiply(left, right)
+      a, b, c, d, e, f = left
+      g, h, i, j, k, l = right
+      [a * g + c * h, b * g + d * h, a * i + c * j, b * i + d * j, a * k + c * l + e, b * k + d * l + f]
+    end
+
+    def transform(source)
+      scanner, matrix = StringScanner.new(source.to_s), IDENTITY
+      until scanner.eos?
+        scanner.skip(/[\s,]*/)
+        break if scanner.eos?
+        name = scanner.scan(/[a-zA-Z]+/)
+        scanner.skip(/\s*/)
+        raise ArgumentError, "invalid SVG transform" unless name && scanner.scan(/\(/)
+        values = scanner.scan(/[^)]*/)
+        raise ArgumentError, "unclosed SVG transform" unless scanner.scan(/\)/)
+        values = numbers(values)
+        operation = case name
+        when "matrix" then values if values.length == 6
+        when "translate" then [1, 0, 0, 1, values[0], values.fetch(1, 0)] if (1..2).cover?(values.length)
+        when "scale" then [values[0], 0, 0, values.fetch(1, values[0]), 0, 0] if (1..2).cover?(values.length)
+        when "rotate"
+          if [1, 3].include?(values.length)
+            angle = values[0] * Math::PI / 180
+            rotation = [Math.cos(angle), Math.sin(angle), -Math.sin(angle), Math.cos(angle), 0, 0]
+            values.length == 1 ? rotation : multiply(multiply([1, 0, 0, 1, values[1], values[2]], rotation), [1, 0, 0, 1, -values[1], -values[2]])
+          end
+        when "skewX", "skewY"
+          if values.length == 1
+            tangent = Math.tan(values[0] * Math::PI / 180)
+            name == "skewX" ? [1, 0, tangent, 1, 0, 0] : [1, tangent, 0, 1, 0, 0]
+          end
+        end
+        raise ArgumentError, "invalid SVG transform #{name}" unless operation && operation.all?(&:finite?)
+        matrix = multiply(matrix, operation)
+      end
+      matrix
+    end
+
+    def viewport(width, height)
+      x, y, w, h = @view_box
+      sx, sy = width.to_f / w, height.to_f / h
+      alignment, mode = (@root.attributes["preserveAspectRatio"] || "xMidYMid meet").split
+      return [sx, 0, 0, sy, -x * sx, -y * sy] if alignment == "none"
+      raise ArgumentError, "invalid preserveAspectRatio" unless alignment.match?(/\Ax(Min|Mid|Max)Y(Min|Mid|Max)\z/) && [nil, "meet", "slice"].include?(mode)
+      scale = mode == "slice" ? [sx, sy].max : [sx, sy].min
+      ax = alignment.include?("xMin") ? 0 : (alignment.include?("xMax") ? 1 : 0.5)
+      ay = alignment.include?("YMin") ? 0 : (alignment.include?("YMax") ? 1 : 0.5)
+      [scale, 0, 0, scale, (width - w * scale) * ax - x * scale, (height - h * scale) * ay - y * scale]
+    end
+
+    def properties(element, inherited)
+      style = inherited.reject { |key, _| %w[opacity clip-path display].include?(key) }
+      PRESENTATION.each { |key| style[key] = element.attributes[key] if element.attributes[key] }
+      element.attributes["style"].to_s.split(";").each do |declaration|
+        key, value = declaration.split(":", 2).map(&:strip)
+        next unless key && value
+        raise ArgumentError, "unsupported SVG style #{key}" unless PRESENTATION.include?(key)
+        style[key] = value
+      end
+      style.each { |key, value| style[key] = inherited.fetch(key, DEFAULTS[key]) if value == "inherit" }
+      style
+    end
+
+    def render(element, pixels, matrix, inherited, width, height, references, definition: false)
+      return if %w[title desc metadata].include?(element.name)
+      return if %w[defs clipPath].include?(element.name) && !definition
+      style = properties(element, inherited)
+      return if style["display"] == "none"
+      matrix = multiply(matrix, transform(element.attributes["transform"]))
+      opacity = number(style.fetch("opacity", "1")).clamp(0, 1)
+      isolated = opacity < 1 || style["clip-path"]
+      target = isolated ? "\0".b * pixels.bytesize : pixels
+      if element.name == "use"
+        href = element.attributes["href"] || element.attributes["xlink:href"]
+        raise ArgumentError, "SVG use must reference a local id" unless href&.start_with?("#")
+        raise ArgumentError, "cyclic SVG use" if references.include?(href) || references.length >= 32
+        referenced = @ids.fetch(href.delete_prefix("#")) { raise ArgumentError, "unknown SVG reference #{href}" }
+        shifted = multiply(matrix, [1, 0, 0, 1, length(element.attributes["x"]), length(element.attributes["y"])])
+        render(referenced, target, shifted, style, width, height, references + [href], definition: true)
+      elsif (outline = @paths[element]) && style["visibility"] != "hidden"
+        unless style["fill"] == "none" || outline.empty?
+          paint_mask(target, mask(outline.transform(matrix), width, height, style["fill-rule"]), color(style["fill"], style["color"]), number(style["fill-opacity"]).clamp(0, 1))
+        end
+        unless style["stroke"] == "none" || outline.empty?
+          thickness = length(style["stroke-width"])
+          raise ArgumentError, "negative SVG stroke width" if thickness.negative?
+          if thickness.positive?
+            stroked = stroke(outline, thickness, style).transform(matrix)
+            paint_mask(target, mask(stroked, width, height, "nonzero"), color(style["stroke"], style["color"]), number(style["stroke-opacity"]).clamp(0, 1))
+          end
+        end
+      else
+        element.elements.each { |child| render(child, target, matrix, style, width, height, references) }
+      end
+      if isolated
+        if style["clip-path"] && style["clip-path"] != "none"
+          id = style["clip-path"][/\Aurl\(\s*#([^\s)]+)\s*\)\z/, 1]
+          clipping = @ids[id]
+          raise ArgumentError, "invalid SVG clipping reference" unless clipping&.name == "clipPath"
+          raise ArgumentError, "cyclic SVG clip" if references.include?(id) || references.length >= 32
+          clip = clip_mask(clipping, matrix, width, height, references + [id])
+          (width * height).times { |i| target.setbyte(i * 4 + 3, (target.getbyte(i * 4 + 3) * clip.getbyte(i) / 255.0).round) }
+        end
+        composite(pixels, target, opacity)
+      end
+    end
+
+    def color(value, current)
+      value = current if value == "currentColor"
+      value = NAMES.fetch(value.downcase, value)
+      if (match = value.match(/\Argba?\(([^)]+)\)\z/i))
+        channels = match[1].split(/[\s,\/]+/)
+        raise ArgumentError, "invalid SVG rgb color" unless (3..4).cover?(channels.length)
+        rgba = channels.each_with_index.map { |channel, i| channel.end_with?("%") ? number(channel.delete_suffix("%")) / 100 : number(channel) / (i == 3 ? 1 : 255.0) }
+        rgba << 1 if rgba.length == 3
+        return rgba.map { |channel| (channel.clamp(0, 1) * 255).round }
+      end
+      Color.parse(value).to_a.map { |channel| (channel * 255).round }
+    end
+
+    def paint_mask(pixels, coverage, rgba, opacity)
+      coverage.bytes.each_with_index do |alpha, index|
+        next if alpha.zero?
+        blend(pixels, index * 4, rgba[0], rgba[1], rgba[2], (alpha * rgba[3] * opacity / 255.0).round)
+      end
+    end
+
+    def composite(pixels, layer, opacity)
+      (pixels.bytesize / 4).times do |index|
+        offset = index * 4
+        blend(pixels, offset, layer.getbyte(offset), layer.getbyte(offset + 1), layer.getbyte(offset + 2), (layer.getbyte(offset + 3) * opacity).round)
+      end
+    end
+
+    def blend(pixels, offset, r, g, b, alpha)
+      return if alpha.zero?
+      previous = pixels.getbyte(offset + 3) * (255 - alpha) / 255.0
+      result = alpha + previous
+      [r, g, b].each_with_index { |channel, i| pixels.setbyte(offset + i, ((channel * alpha + pixels.getbyte(offset + i) * previous) / result).round) }
+      pixels.setbyte(offset + 3, result.round)
+    end
+  end
+
+end
+
+require_relative "svg/path"
+require_relative "svg/rasterizable"
+Zaniah::SVG.include(Zaniah::SVG::Rasterizable)

data/lib/zaniah/task/cancelled.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Task
+    class Cancelled < Error; end
+  end
+end

data/lib/zaniah/task/timeout.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Zaniah
+  class Task
+    class Timeout < Error; end
+  end
+end