prawnx 0.1.1

data/lib/prawn/svg/elements/text_node.rb

@@ -0,0 +1,308 @@
+module Prawn::SVG
+  class Elements::TextNode
+    Chunk = Struct.new(:text, :x, :y, :dx, :dy, :rotate, :base_width, :offset, :fixed_width, :font_runs)
+
+    attr_reader :component, :chunks
+    attr_accessor :text
+
+    def initialize(component, text, leading_space, trailing_space)
+      @component = component
+      @text = text
+      @leading_space = leading_space
+      @trailing_space = trailing_space
+    end
+
+    def leading_space?
+      @leading_space
+    end
+
+    def trailing_space?
+      @trailing_space
+    end
+
+    def calculated_width
+      @chunks.reduce(0) do |total, chunk|
+        total + (chunk.fixed_width || chunk.base_width) + chunk.offset
+      end
+    end
+
+    def total_flexible_and_fixed_width
+      flexible = fixed = 0
+      chunks.each do |chunk|
+        if chunk.fixed_width.nil?
+          flexible += chunk.base_width
+          fixed += chunk.offset
+        else
+          fixed += chunk.offset + chunk.fixed_width
+        end
+      end
+      [flexible, fixed]
+    end
+
+    def lay_out(prawn)
+      remaining_text = @text
+      @chunks = []
+
+      while remaining_text != ''
+        x = y = dx = dy = rotate = nil
+        remaining = rotation_remaining = false
+
+        comp = component
+        while comp
+          shifted = comp.x_values.shift
+          x ||= shifted
+          shifted = comp.y_values.shift
+          y ||= shifted
+          shifted = comp.dx.shift
+          dx ||= shifted
+          shifted = comp.dy.shift
+          dy ||= shifted
+
+          shifted = comp.rotation.length > 1 ? comp.rotation.shift : comp.rotation.first
+          if shifted && rotate.nil?
+            rotate = shifted
+            remaining ||= comp.rotation != [0]
+          end
+
+          remaining ||= comp.x_values.any? || comp.y_values.any? || comp.dx.any? || comp.dy.any? || (rotate && rotate != 0)
+          rotation_remaining ||= comp.rotation.length > 1
+          comp = comp.parent_component
+        end
+
+        rotate = (-rotate if rotate && rotate != 0)
+
+        text_to_draw = remaining ? remaining_text[0..0] : remaining_text
+
+        kerning = component.kerning_enabled?
+        opts = { size: component.computed_properties.numeric_font_size, kerning: kerning }
+
+        fallback_fonts = component.fallback_fonts
+        font_runs = fallback_fonts&.any? ? split_into_font_runs(prawn, text_to_draw, fallback_fonts) : nil
+
+        kerning_spacing = text_to_draw.length > 1 ? (component.kerning_pixels || 0) * (text_to_draw.length - 1) : 0
+        letter_spacing = text_to_draw.length > 1 ? (component.letter_spacing_pixels || 0) * (text_to_draw.length - 1) : 0
+        word_spacing = (component.word_spacing_pixels || 0) * text_to_draw.count(' ')
+        base_width = width_of_text(prawn, text_to_draw, font_runs, opts) + kerning_spacing + letter_spacing + word_spacing
+
+        offset = dx ? [0, dx].max : 0
+
+        @chunks << Chunk.new(text_to_draw, x, y, dx, dy, rotate, base_width, offset, nil, font_runs)
+
+        if remaining
+          remaining_text = remaining_text[1..]
+        else
+          # we can get to this path with rotations still pending
+          # solve this by shifting them out by the number of
+          # characters we've just drawn
+          shift = remaining_text.length - 1
+          if rotation_remaining && shift.positive?
+            comp = component
+            while comp
+              count = [shift, comp.rotation.length - 1].min
+              comp.rotation.shift(count) if count.positive?
+              comp = comp.parent_component
+            end
+          end
+
+          break
+        end
+      end
+    end
+
+    def render(prawn, size, cursor, y_offset)
+      chunks.each do |chunk|
+        cursor.x = chunk.x if chunk.x
+        cursor.x += chunk.dx if chunk.dx
+        cursor.y = chunk.y if chunk.y
+        cursor.y -= chunk.dy if chunk.dy
+
+        width = chunk.fixed_width || chunk.base_width
+
+        unless component.inside_clip_path
+          decoration = component.computed_properties.text_decoration
+          unless decoration == 'none'
+            render_underline(prawn, size, cursor, y_offset, width) if decoration.include?('underline')
+            render_overline(prawn, size, cursor, y_offset, width) if decoration.include?('overline')
+            render_line_through(prawn, size, cursor, y_offset, width) if decoration.include?('line-through')
+          end
+          render_link_annotation(prawn, size, cursor, y_offset, width)
+        end
+
+        kerning = component.kerning_enabled?
+        opts = { size: size, at: [cursor.x, cursor.y + (y_offset || 0)], kerning: kerning }
+        opts[:rotate] = chunk.rotate if chunk.rotate
+
+        scaling =
+          if chunk.fixed_width && component.current_length_adjust_is_scaling?
+            chunk.fixed_width * 100 / chunk.base_width
+          else
+            100
+          end
+
+        spacing_enabled = chunk.fixed_width && !component.current_length_adjust_is_scaling? && chunk.text.length > 1
+
+        # This isn't perfect.  It assumes the parent component which started the textLength context
+        # has a character at the end of its text nodes.  If it doesn't, the last character in its
+        # children should not take the space.  This is possible but would involve a lot more work so
+        # I will park it for now.
+        parent_spacing = spacing_enabled && !component.text_length
+        spacing =
+          if spacing_enabled
+            ((chunk.fixed_width - chunk.base_width) / (chunk.text.length - (parent_spacing ? 0 : 1))) + (component.kerning_pixels || 0) + (component.letter_spacing_pixels || 0)
+          end
+
+        # Inside clip paths, text renders white in a soft mask to define the
+        # clipping region. Override any fill color from the SVG element.
+        prawn.fill_color('ffffff') if component.inside_clip_path
+
+        combined_spacing = spacing || combined_kerning_and_letter_spacing
+        prawn.horizontal_text_scaling(scaling) do
+          prawn.character_spacing(combined_spacing || prawn.character_spacing) do
+            prawn.word_spacing(component.word_spacing_pixels || prawn.word_spacing) do
+              prawn.text_rendering_mode(calculate_text_rendering_mode) do
+                render_text_directly(prawn, chunk.text, chunk.font_runs, opts)
+              end
+            end
+          end
+        end
+
+        cursor.x += chunk.fixed_width || chunk.base_width
+
+        # If we're in a textLength context for one of our parents, we'll need to add spacing
+        # to the end of our string.  See comment above for why this isn't quite right.
+        cursor.x += spacing if parent_spacing
+      end
+    end
+
+    def width_of_text(prawn, text, font_runs, opts)
+      if font_runs.nil?
+        prawn.width_of(text, **opts)
+      else
+        font_runs.sum(0.0) do |font_name, run_text|
+          if font_name
+            width = nil
+            prawn.font(font_name) { width = prawn.width_of(run_text, **opts) }
+            width
+          else
+            prawn.width_of(run_text, **opts)
+          end
+        end
+      end
+    end
+
+    def render_text_directly(prawn, text, font_runs, opts)
+      if font_runs.nil?
+        prawn.draw_text(text, **opts)
+      else
+        kerning = opts[:kerning]
+        x = opts[:at][0]
+        font_runs.each do |font_name, run_text|
+          run_opts = opts.merge(at: [x, opts[:at][1]])
+          if font_name
+            prawn.font(font_name) do
+              prawn.draw_text(run_text, **run_opts)
+              x += prawn.width_of(run_text, size: opts[:size], kerning: kerning)
+            end
+          else
+            prawn.draw_text(run_text, **run_opts)
+            x += prawn.width_of(run_text, size: opts[:size], kerning: kerning)
+          end
+        end
+      end
+    end
+
+    def split_into_font_runs(prawn, text, fallback_fonts)
+      primary_font = prawn.font
+      runs = []
+      current_font = nil
+      current_text = +''
+
+      prawn.save_font do
+        text.each_char do |char|
+          font_for_char = font_for_glyph(prawn, char, primary_font, fallback_fonts)
+
+          if font_for_char != current_font && !current_text.empty?
+            runs << [current_font, current_text]
+            current_text = +''
+          end
+          current_font = font_for_char
+          current_text << char
+        end
+      end
+
+      runs << [current_font, current_text] unless current_text.empty?
+      runs
+    end
+
+    def font_for_glyph(prawn, char, primary_font, fallback_fonts)
+      return nil if primary_font.glyph_present?(char)
+
+      fallback_fonts.each do |fb|
+        prawn.font(fb)
+        return fb if prawn.font.glyph_present?(char)
+      end
+
+      nil
+    end
+
+    def render_underline(prawn, size, cursor, y_offset, width)
+      offset, thickness = FontMetrics.underline_metrics(prawn, size)
+
+      prawn.fill_rectangle [cursor.x, cursor.y + (y_offset || 0) + offset + (thickness / 2.0)], width, thickness
+    end
+
+    def render_overline(prawn, size, cursor, y_offset, width)
+      offset, thickness = FontMetrics.overline_metrics(prawn, size)
+
+      prawn.fill_rectangle [cursor.x, cursor.y + (y_offset || 0) + offset + (thickness / 2.0)], width, thickness
+    end
+
+    def render_line_through(prawn, size, cursor, y_offset, width)
+      offset, thickness = FontMetrics.strikethrough_metrics(prawn, size)
+
+      prawn.fill_rectangle [cursor.x, cursor.y + (y_offset || 0) + offset + (thickness / 2.0)], width, thickness
+    end
+
+    def render_link_annotation(prawn, size, cursor, y_offset, width)
+      href = component.state.anchor_href
+      return unless href
+
+      text_bottom = cursor.y + (y_offset || 0) - scaled_font_size(prawn, :descender, size)
+      font_height = scaled_font_size(prawn, :height, size)
+
+      LinkRenderer.new(href, [cursor.x, text_bottom + font_height, cursor.x + width, text_bottom]).render(prawn)
+    end
+
+    def scaled_font_size(prawn, method_name, size)
+      (prawn.font.public_send(method_name) / prawn.font_size) * size
+    end
+
+    def combined_kerning_and_letter_spacing
+      kerning = component.kerning_pixels
+      letter = component.letter_spacing_pixels
+
+      if kerning && letter
+        kerning + letter
+      else
+        kerning || letter
+      end
+    end
+
+    def calculate_text_rendering_mode
+      return :fill if component.inside_clip_path
+
+      fill = !component.computed_properties.fill.none? # rubocop:disable Style/InverseMethods
+      stroke = !component.computed_properties.stroke.none? # rubocop:disable Style/InverseMethods
+
+      if fill && stroke
+        :fill_stroke
+      elsif fill
+        :fill
+      elsif stroke
+        :stroke
+      else
+        :invisible
+      end
+    end
+  end
+end

data/lib/prawn/svg/elements/text_path.rb

@@ -0,0 +1,153 @@
+module Prawn::SVG
+  class Elements::TextPath < Elements::TextComponent
+    def parse
+      href = href_attribute
+      unless href&.start_with?('#')
+        warnings << '<textPath> must reference a path element'
+        raise SkipElementQuietly
+      end
+
+      @path_element = document.elements_by_id[href[1..]]
+      unless @path_element.is_a?(Elements::Path)
+        warnings << "<textPath> reference '#{href}' is not a path element"
+        raise SkipElementQuietly
+      end
+
+      @path_length = Calculators::PathLength.new(@path_element.commands)
+
+      raise SkipElementQuietly if @path_length.total_length <= 0
+
+      @start_offset = parse_start_offset
+
+      super
+    end
+
+    def render_component(prawn, renderer, _cursor, _translate_x = nil, accumulated_baseline_shift = 0)
+      raise SkipElementQuietly if computed_properties.display == 'none'
+
+      add_yield_call do
+        size = computed_properties.numeric_font_size
+        y_offset = dominant_baseline_offset(prawn, size || prawn.font_size) || 0
+
+        with_svg_fonts(prawn) do
+          total_baseline_shift = accumulated_baseline_shift + baseline_shift_offset(prawn, size)
+          y_offset += total_baseline_shift
+
+          current_distance = @start_offset
+          render_children_along_path(prawn, children, size, y_offset, current_distance)
+        end
+      end
+
+      renderer.render_calls(prawn, base_calls)
+    end
+
+    def transformable?
+      false
+    end
+
+    private
+
+    def render_children_along_path(prawn, children, size, y_offset, current_distance)
+      children.each do |child|
+        case child
+        when Elements::TextNode
+          current_distance = render_text_node_along_path(prawn, child, size, y_offset, current_distance)
+        when Elements::TextComponent
+          prawn.save_graphics_state
+          child_size = child.computed_properties.numeric_font_size
+          child_y_offset = child.dominant_baseline_offset(prawn, child_size || prawn.font_size)
+          child.with_svg_fonts(prawn) do
+            current_distance = render_children_along_path(prawn, child.children, child_size, child_y_offset, current_distance)
+          end
+          prawn.restore_graphics_state
+        end
+      end
+
+      current_distance
+    end
+
+    def render_text_node_along_path(prawn, text_node, size, y_offset, current_distance)
+      text_node.chunks.each do |chunk|
+        advances = kerned_advances(prawn, text_node, chunk.text, size)
+
+        chunk.text.each_char.with_index do |char, i|
+          char_width = text_node.width_of_text(prawn, char, nil, { size: size, kerning: false })
+          advance = advances[i]
+
+          midpoint = current_distance + (char_width / 2.0)
+          point = @path_length.point_at(midpoint)
+          break unless point
+
+          mid_x, mid_y_svg, angle = point
+          angle_rad = angle * Math::PI / 180.0
+          half_width = char_width / 2.0
+
+          # Offset back from midpoint to left edge along the tangent
+          px = mid_x - (half_width * Math.cos(angle_rad))
+          py_svg = mid_y_svg - (half_width * Math.sin(angle_rad))
+          py = document.sizing.output_height - py_svg
+
+          draw_opts = { size: size, at: [px, py + (y_offset || 0)] }
+          draw_opts[:rotate] = -angle
+
+          render_mode = calculate_text_rendering_mode(text_node.component)
+
+          prawn.text_rendering_mode(render_mode) do
+            text_node.render_text_directly(prawn, char, nil, draw_opts)
+          end
+
+          current_distance += advance
+        end
+      end
+
+      current_distance
+    end
+
+    # Compute the advance width for each character, accounting for kerning
+    # with the following character. The advance is the character's own width
+    # plus any kerning adjustment with its neighbour.
+    def kerned_advances(prawn, text_node, text, size)
+      opts_no_kern = { size: size, kerning: false }
+      opts_kern = { size: size, kerning: true }
+
+      text.each_char.with_index.map do |char, i|
+        char_width = text_node.width_of_text(prawn, char, nil, opts_no_kern)
+        next_char = text[i + 1]
+
+        if next_char
+          pair_width = text_node.width_of_text(prawn, "#{char}#{next_char}", nil, opts_kern)
+          next_width = text_node.width_of_text(prawn, next_char, nil, opts_no_kern)
+          char_width + (pair_width - char_width - next_width)
+        else
+          char_width
+        end
+      end
+    end
+
+    def calculate_text_rendering_mode(component)
+      fill = !component.computed_properties.fill.none? # rubocop:disable Style/InverseMethods
+      stroke = !component.computed_properties.stroke.none? # rubocop:disable Style/InverseMethods
+
+      if fill && stroke
+        :fill_stroke
+      elsif fill
+        :fill
+      elsif stroke
+        :stroke
+      else
+        :invisible
+      end
+    end
+
+    def parse_start_offset
+      value = attributes['startOffset']
+      return 0.0 unless value
+
+      if value.end_with?('%')
+        @path_length.total_length * value.to_f / 100.0
+      else
+        x_pixels(value)
+      end
+    end
+  end
+end

data/lib/prawn/svg/elements/use.rb

@@ -0,0 +1,142 @@
+class Prawn::SVG::Elements::Use < Prawn::SVG::Elements::Base
+  attr_reader :referenced_element_class, :referenced_element_source
+
+  def parse
+    href = href_attribute
+    raise SkipElementError, 'use tag must have an href or xlink:href' if href.nil?
+
+    if href.start_with?('#')
+      resolve_local_reference(href[1..])
+    else
+      resolve_external_reference(href)
+    end
+
+    raise SkipElementError, "use tag references '#{href}' which could not be resolved" if referenced_element_class.nil?
+
+    @referenced_element_class = Prawn::SVG::Elements::Viewport if referenced_element_source.name == 'symbol'
+
+    state.inside_use = true
+
+    @x = attributes['x']
+    @y = attributes['y']
+    @width = attributes['width']
+    @height = attributes['height']
+  end
+
+  def container?
+    true
+  end
+
+  def apply
+    add_call_and_enter 'translate', x_pixels(@x || 0), -y_pixels(@y || 0) if @x || @y
+  end
+
+  def process_child_elements
+    add_call 'save'
+
+    source = clone_element_source(referenced_element_source)
+
+    if referenced_element_class == Prawn::SVG::Elements::Viewport
+      source.attributes['width'] = @width || '100%'
+      source.attributes['height'] = @height || '100%'
+    end
+
+    child = referenced_element_class.new(document, source, calls, state.dup)
+    child.process
+
+    add_call 'restore'
+  end
+
+  private
+
+  def resolve_local_reference(id)
+    referenced_element = @document.elements_by_id[id]
+
+    if referenced_element
+      @referenced_element_class = referenced_element.class
+      @referenced_element_source = referenced_element.source
+    else
+      # Perhaps the element is defined further down in the document.  This is not recommended but still valid SVG,
+      # so we'll support it with an exception case that's not particularly performant.
+      raw_element = REXML::XPath.match(@document.root, %(//*[@id="#{id.gsub('"', '\"')}"])).first
+
+      if raw_element
+        @referenced_element_class = Prawn::SVG::Elements::TAG_CLASS_MAPPING[raw_element.name.to_sym]
+        @referenced_element_source = raw_element
+      end
+    end
+  end
+
+  def resolve_external_reference(href)
+    url, fragment = split_href(href)
+    raise SkipElementError, 'use tag with external href must include a fragment identifier' unless fragment
+
+    external_root, external_element_styles = load_external_svg(url)
+
+    raw_element = REXML::XPath.match(external_root, %(//*[@id="#{fragment.gsub('"', '\"')}"])).first
+    return unless raw_element
+
+    @referenced_element_class = Prawn::SVG::Elements::TAG_CLASS_MAPPING[raw_element.name.to_sym]
+    return unless @referenced_element_class
+
+    @referenced_element_source = raw_element
+
+    import_external_styles(raw_element, external_element_styles)
+    import_external_defs(external_root, external_element_styles)
+  end
+
+  def split_href(href)
+    if href.include?('#')
+      fragment_index = href.rindex('#')
+      [href[0...fragment_index], href[(fragment_index + 1)..]]
+    else
+      [href, nil]
+    end
+  end
+
+  def load_external_svg(url)
+    @document.external_svg_cache[url] ||= begin
+      data = @document.url_loader.load(url)
+
+      root = begin
+        REXML::Document.new(data).root
+      rescue REXML::ParseException
+        raise SkipElementError, "use tag references external SVG at '#{url}' which could not be parsed"
+      end
+
+      raise SkipElementError, "use tag references external URL '#{url}' which does not contain SVG" unless root
+
+      css_parser = CssParser::Parser.new
+      stylesheets = Prawn::SVG::CSS::Stylesheets.new(css_parser, root)
+      element_styles = stylesheets.load
+
+      [root, element_styles]
+    end
+  rescue Prawn::SVG::UrlLoader::Error => e
+    raise SkipElementError, "use tag could not load external SVG from '#{url}': #{e.message}"
+  end
+
+  def import_external_styles(element, external_element_styles)
+    copy_styles_recursive(element, external_element_styles)
+  end
+
+  def import_external_defs(external_root, external_element_styles)
+    REXML::XPath.match(external_root, '//defs').each do |defs_element|
+      defs_element.elements.each do |child|
+        id = child.attributes['id']
+        next unless id && !id.empty?
+
+        copy_styles_recursive(child, external_element_styles)
+      end
+    end
+  end
+
+  def copy_styles_recursive(element, external_element_styles)
+    styles = external_element_styles[element]
+    @document.element_styles[element] = styles if styles
+
+    element.elements.each do |child|
+      copy_styles_recursive(child, external_element_styles)
+    end
+  end
+end

data/lib/prawn/svg/elements/viewport.rb

@@ -0,0 +1,29 @@
+class Prawn::SVG::Elements::Viewport < Prawn::SVG::Elements::Base
+  def parse
+    parent_dimensions = [state.viewport_sizing.viewport_width, state.viewport_sizing.viewport_height]
+
+    @sizing = Prawn::SVG::Calculators::DocumentSizing.new(parent_dimensions, attributes)
+    @sizing.calculate
+
+    @x = x_pixels(attributes['x'] || 0)
+    @y = y_pixels(attributes['y'] || 0)
+
+    state.viewport_sizing = @sizing
+  end
+
+  def apply
+    add_call 'transformation_matrix', 1, 0, 0, 1, @x, -@y if @x != 0 || @y != 0
+
+    if overflow_hidden?
+      add_call 'rectangle', [0, y(0)], @sizing.output_width, @sizing.output_height
+      add_call 'clip'
+    end
+
+    add_call 'transformation_matrix', @sizing.x_scale, 0, 0, @sizing.y_scale, 0, 0
+    add_call 'transformation_matrix', 1, 0, 0, 1, -@sizing.x_offset, @sizing.y_offset
+  end
+
+  def container?
+    true
+  end
+end

data/lib/prawn/svg/elements.rb

@@ -0,0 +1,46 @@
+module Prawn::SVG::Elements
+  COMMA_WSP_REGEXP = /(?:\s+,?\s*|,\s*)/.freeze
+end
+
+require 'prawn/svg/elements/call_duplicator'
+require 'prawn/svg/elements/bbox_scaling'
+
+%w[base direct_render_base root anchor container switch clip_path mask viewport text text_component text_node text_path line polyline polygon circle ellipse
+   rect path use image gradient pattern marker ignored].each do |filename|
+  require "prawn/svg/elements/#{filename}"
+end
+
+module Prawn::SVG::Elements
+  TAG_CLASS_MAPPING = {
+    g:              Prawn::SVG::Elements::Container,
+    symbol:         Prawn::SVG::Elements::Container,
+    defs:           Prawn::SVG::Elements::Container,
+    a:              Prawn::SVG::Elements::Anchor,
+    clipPath:       Prawn::SVG::Elements::ClipPath,
+    switch:         Prawn::SVG::Elements::Switch,
+    svg:            Prawn::SVG::Elements::Viewport,
+    text:           Prawn::SVG::Elements::Text,
+    line:           Prawn::SVG::Elements::Line,
+    polyline:       Prawn::SVG::Elements::Polyline,
+    polygon:        Prawn::SVG::Elements::Polygon,
+    circle:         Prawn::SVG::Elements::Circle,
+    ellipse:        Prawn::SVG::Elements::Ellipse,
+    rect:           Prawn::SVG::Elements::Rect,
+    path:           Prawn::SVG::Elements::Path,
+    use:            Prawn::SVG::Elements::Use,
+    image:          Prawn::SVG::Elements::Image,
+    linearGradient: Prawn::SVG::Elements::Gradient,
+    radialGradient: Prawn::SVG::Elements::Gradient,
+    pattern:        Prawn::SVG::Elements::Pattern,
+    marker:         Prawn::SVG::Elements::Marker,
+    style:          Prawn::SVG::Elements::Ignored, # because it is pre-parsed by Document
+    title:          Prawn::SVG::Elements::Ignored,
+    desc:           Prawn::SVG::Elements::Ignored,
+    metadata:       Prawn::SVG::Elements::Ignored,
+    foreignObject:  Prawn::SVG::Elements::Ignored,
+    'font-face':    Prawn::SVG::Elements::Ignored,
+    filter:         Prawn::SVG::Elements::Ignored, # unsupported
+    mask:           Prawn::SVG::Elements::Mask,
+    view:           Prawn::SVG::Elements::Ignored
+  }.freeze
+end

data/lib/prawn/svg/extension.rb

@@ -0,0 +1,25 @@
+module Prawn
+  module SVG
+    module Extension
+      #
+      # Draws an SVG document into the PDF.
+      #
+      # +options+ must contain the key :at, which takes a tuple of x and y co-ordinates.
+      #
+      # +options+ can optionally contain the key :width or :height.  If both are
+      # specified, only :width will be used.  If neither are specified, the resolution
+      # given in the SVG will be used.
+      #
+      # Example usage:
+      #
+      #   svg IO.read("example.svg"), :at => [100, 300], :width => 600
+      #
+      def svg(data, options = {}, &block)
+        svg = Prawn::SVG::Interface.new(data, self, options, &block)
+        svg.draw
+        { warnings: svg.document.warnings, width: svg.document.sizing.output_width,
+          height: svg.document.sizing.output_height }
+      end
+    end
+  end
+end