stationery 0.1.0 → 0.2.0

data/lib/stationery/markdown/block_parser.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../rich/nodes"
+require_relative "inline_parser"
+require_relative "block_parser/containers"
+require_relative "block_parser/tables"
+
+module Stationery
+  module Markdown
+    # Splits CommonMark source into blocks, line by line. Paragraph, heading and table cell text is left
+    # raw (a String in place of inlines) for Markdown.parse to run through the inline parser once every
+    # link reference definition, which this parser collects into `refs`, is known. Raw HTML stays text.
+    class BlockParser
+      include Containers
+      include Tables
+
+      ATX = /\A {0,3}(\#{1,6})(?:[ \t]+(.*?))?[ \t]*\z/
+      SETEXT = /\A {0,3}(=+|-+)[ \t]*\z/
+      THEMATIC = /\A {0,3}(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})\z/
+      FENCE = /\A( {0,3})(`{3,}|~{3,})[ \t]*([^`]*?)[ \t]*\z/
+      DEFINITION = /
+        \A\ {0,3}\[((?:[^\]\\]|\\.)+)\]:[ \t]*
+        (?:<([^<>]*)>|(\S+))
+        (?:[ \t]+(?:"[^"]*"|'[^']*'|\([^)]*\)))?[ \t]*\z
+      /x
+
+      def self.parse(source, refs) = new(lines(source), refs).blocks
+
+      def self.lines(source) = source.to_s.split(/\r\n?|\n/).map { |line| expand_tabs(line) }
+
+      # Tabs in a line's indentation and container markers advance to the next multiple of four columns.
+      def self.expand_tabs(line)
+        prefix = line[/\A[ \t>*+\-\d.)]*/]
+        return line unless prefix.include?("\t")
+
+        expanded = prefix.each_char.with_object(+"") do |char, out|
+          out << (char == "\t" ? " " * (4 - (out.length % 4)) : char)
+        end
+        expanded + line[prefix.length..]
+      end
+
+      def initialize(lines, refs)
+        @lines = lines
+        @refs = refs
+        @index = 0
+      end
+
+      def blocks
+        blocks = []
+        while (line = @lines[@index])
+          block = block(line)
+          blocks << block if block
+        end
+        blocks
+      end
+
+      private
+
+      def block(line)
+        if blank?(line) then skip
+        elsif indent(line) >= 4 then indented_code
+        elsif (match = FENCE.match(line)) then fenced_code(match)
+        elsif (match = ATX.match(line)) then atx(match)
+        elsif THEMATIC.match?(line) then skip(Rich::Rule.new)
+        elsif QUOTE.match?(line) then blockquote
+        elsif (match = list_marker(line)) then list(match)
+        elsif table_start? then table
+        else paragraph
+        end
+      end
+
+      def skip(block = nil)
+        @index += 1
+        block
+      end
+
+      def indented_code
+        lines = []
+        while (line = @lines[@index]) && (blank?(line) || indent(line) >= 4)
+          lines << line.sub(/\A {1,4}/, "")
+          @index += 1
+        end
+        lines.pop while lines.last.strip.empty?
+        Rich::CodeBlock.new(text: lines.join("\n"), language: nil)
+      end
+
+      def fenced_code(match)
+        indent, fence, info = match.captures
+        closing = /\A {0,3}#{Regexp.escape(fence[0])}{#{fence.length},}[ \t]*\z/
+        lines = []
+        while (line = @lines[@index += 1])
+          break @index += 1 if closing.match?(line)
+
+          lines << line.sub(/\A {0,#{indent.length}}/, "")
+        end
+        Rich::CodeBlock.new(text: lines.join("\n"), language: info.split.first)
+      end
+
+      def atx(match)
+        @index += 1
+        Rich::Heading.new(level: match[1].length, inlines: match[2].to_s.sub(/(?:\A|[ \t]+)#+\z/, ""))
+      end
+
+      def paragraph
+        lines = [@lines[@index].lstrip]
+        while (line = @lines[@index += 1]) && !blank?(line)
+          if (underline = SETEXT.match(line)) && definitions(lines).any?
+            @index += 1
+            return Rich::Heading.new(level: underline[1].start_with?("=") ? 1 : 2, inlines: text(lines))
+          end
+          break if interrupts?(line)
+
+          lines << line.lstrip
+        end
+        lines = definitions(lines)
+        Rich::Paragraph.new(inlines: text(lines)) if lines.any?
+      end
+
+      # Strips the link reference definitions leading a paragraph into @refs.
+      def definitions(lines)
+        lines = lines.dup
+        while (match = DEFINITION.match(lines.first.to_s))
+          @refs[InlineParser.label(match[1])] ||= InlineParser.destination(match[2] || match[3])
+          lines.shift
+        end
+        lines
+      end
+
+      def text(lines) = lines.join("\n").rstrip
+
+      def interrupts?(line)
+        FENCE.match?(line) || ATX.match?(line) || THEMATIC.match?(line) || QUOTE.match?(line) ||
+          list_interrupts?(line)
+      end
+
+      def blank?(line) = line.strip.empty?
+      def indent(line) = line[/\A */].length
+      def nested(lines) = BlockParser.new(lines, @refs).blocks
+    end
+  end
+end

data/lib/stationery/markdown/document.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "block_parser"
+require_relative "inline_parser"
+
+module Stationery
+  # A CommonMark subset (plus GFM tables and strikethrough) to rich-text blocks (see Stationery::Rich).
+  module Markdown
+    def self.parse(source)
+      refs = {}
+      Resolver.new(refs).blocks(BlockParser.parse(source, refs))
+    end
+
+    # Runs the raw text the block parser left in paragraphs, headings and cells through the inline parser.
+    class Resolver
+      def initialize(refs)
+        @refs = refs
+      end
+
+      def blocks(blocks) = blocks.flat_map { |block| block(block) }
+
+      private
+
+      def block(block)
+        case block
+        when Rich::Paragraph then Rich::Inlines.paragraphs(inlines(block.inlines)) { |run| trim(run) }
+        when Rich::Heading then [block.with(inlines: Rich::Inlines.merge(inlines(block.inlines).map { |i| alt(i) }))]
+        when Rich::List then [block.with(items: block.items.map { |item| blocks(item) })]
+        when Rich::Blockquote then [block.with(blocks: blocks(block.blocks))]
+        when Rich::Table then [block.with(rows: block.rows.map { |row| cells(row) })]
+        else [block]
+        end
+      end
+
+      def cells(row) = row.map { |cell| cell.with(blocks: blocks(cell.blocks)) }
+
+      def inlines(text) = InlineParser.parse(text, @refs)
+
+      def alt(item) = item.is_a?(Rich::Image) ? Rich::Inline.new(text: item.alt) : item
+
+      # Text around an image loses the space that separated it from the image.
+      def trim(run)
+        run = run.dup
+        run[0] = run[0].with(text: run[0].text.lstrip) unless run[0].break?
+        run[-1] = run[-1].with(text: run[-1].text.rstrip) unless run[-1].break?
+        run
+      end
+    end
+  end
+end

data/lib/stationery/markdown/inline_parser/emphasis.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Markdown
+    class InlineParser
+      # CommonMark's delimiter-run emphasis, simplified: flanking rules and the `_` intraword restriction,
+      # without the rule of three. `~` runs of equal length strike through (GFM).
+      module Emphasis
+        WHITESPACE = /[[:space:]]/
+        PUNCTUATION = /[[:punct:]]|\p{S}/
+
+        module_function
+
+        def delimiter(run, before, after)
+          left = !space?(after) && (!punct?(after) || space?(before) || punct?(before))
+          right = !space?(before) && (!punct?(before) || space?(after) || punct?(after))
+          if run.start_with?("_")
+            Nodes::Delimiter.new("_", run.length, left && (!right || punct?(before)), right && (!left || punct?(after)))
+          else
+            Nodes::Delimiter.new(run[0], run.length, left, right)
+          end
+        end
+
+        # Wraps matched delimiter pairs (and what lies between them) in place.
+        def process(nodes)
+          index = 0
+          while index < nodes.size
+            closer = nodes[index]
+            opener = closer?(closer) && opener_for(nodes, index)
+            next index += 1 unless opener
+
+            index = wrap(nodes, opener, index)
+          end
+        end
+
+        def wrap(nodes, opening, index)
+          opener = nodes[opening]
+          closer = nodes[index]
+          used = used(opener, closer)
+          nodes[(opening + 1)...index] = [Nodes::Wrap.new(marks(closer.char, used), nodes[(opening + 1)...index])]
+          opener.remaining -= used
+          closer.remaining -= used
+          index = opening + 2
+          if opener.remaining.zero?
+            nodes.delete_at(opening)
+            index -= 1
+          end
+          nodes.delete_at(index) if closer.remaining.zero?
+          index
+        end
+
+        def opener_for(nodes, index)
+          closer = nodes[index]
+          (index - 1).downto(0).find do |i|
+            node = nodes[i]
+            node.is_a?(Nodes::Delimiter) && node.opener && node.char == closer.char && node.remaining.positive? &&
+              (closer.char != "~" || node.remaining == closer.remaining)
+          end
+        end
+
+        def closer?(node) = node.is_a?(Nodes::Delimiter) && node.closer && node.remaining.positive?
+
+        def used(opener, closer)
+          return closer.remaining if closer.char == "~"
+
+          opener.remaining >= 2 && closer.remaining >= 2 ? 2 : 1
+        end
+
+        def marks(char, used)
+          return { strike: true } if char == "~"
+
+          used == 2 ? { bold: true } : { italic: true }
+        end
+
+        def space?(char) = WHITESPACE.match?(char)
+        def punct?(char) = PUNCTUATION.match?(char)
+      end
+    end
+  end
+end

data/lib/stationery/markdown/inline_parser/links.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Markdown
+    class InlineParser
+      # Brackets, inline and reference links, images and autolinks.
+      module Links
+        Bracket = Struct.new(:index, :image, :active, :position)
+
+        INLINE = /
+          \(\s*
+          (?:<([^<>\n]*)>|((?:[^\s()\\]|\\.|\((?:[^\s()\\]|\\.)*\))*))
+          (?:\s+(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\((?:[^()\\]|\\.)*\)))?
+          \s*\)
+        /x
+        REFERENCE = /\[((?:[^\[\]\\]|\\.){0,999})\]/
+        AUTOLINK = %r{
+          <((?:https?|mailto):[^\s<>]*)>
+          |<([a-zA-Z0-9.!\#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?
+            (?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*)>
+        }x
+
+        private
+
+        def open_bracket(image: false)
+          @brackets << Bracket.new(@nodes.size, image, true, @scanner.charpos)
+          add(image ? "![" : "[")
+        end
+
+        def close_bracket
+          bracket = @brackets.pop
+          return add("]") unless bracket&.active
+
+          href = inline_destination || reference(@source[bracket.position...(@scanner.charpos - 1)])
+          return add("]") unless href
+
+          children = @nodes.slice!(bracket.index..).drop(1)
+          Emphasis.process(children)
+          return @nodes << Nodes::Picture.new(href, children) if bracket.image
+
+          @nodes << Nodes::Wrap.new({ link: href }, children)
+          @brackets.each { |open| open.active = false unless open.image }
+        end
+
+        def inline_destination
+          return unless @scanner.scan(INLINE)
+
+          InlineParser.destination(@scanner[1] || @scanner[2])
+        end
+
+        def reference(label)
+          position = @scanner.pos
+          if @scanner.scan(REFERENCE)
+            label = @scanner[1] unless @scanner[1].empty?
+            href = @refs[InlineParser.label(label)]
+            @scanner.pos = position unless href
+            href
+          else
+            @refs[InlineParser.label(label)]
+          end
+        end
+
+        def autolink
+          url = @scanner[1] || "mailto:#{@scanner[2]}"
+          @nodes << Nodes::Wrap.new({ link: url }, [Nodes::Text.new(@scanner[1] || @scanner[2])])
+        end
+      end
+    end
+  end
+end

data/lib/stationery/markdown/inline_parser/nodes.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Stationery
+  module Markdown
+    class InlineParser
+      # The intermediate inline tree: text, delimiter runs, code, breaks, and mark or image wrappers.
+      module Nodes
+        Text = Struct.new(:text)
+        Delimiter = Struct.new(:char, :remaining, :opener, :closer)
+        Code = Data.define(:text)
+        Break = Data.define
+        Wrap = Data.define(:marks, :children)
+        Picture = Data.define(:src, :children)
+
+        module_function
+
+        def flatten(nodes, marks = {}, out = [])
+          nodes.each do |node|
+            case node
+            when Text then out << Rich::Inline.new(text: node.text, marks:)
+            when Delimiter then out << Rich::Inline.new(text: node.char * node.remaining, marks:)
+            when Code then out << Rich::Inline.new(text: node.text, marks: marks.merge(code: true))
+            when Break then out << Rich::Inline.break
+            when Wrap then flatten(node.children, marks.merge(node.marks), out)
+            when Picture then out << picture(node)
+            end
+          end
+          out
+        end
+
+        def picture(node) = Rich::Image.new(src: node.src, alt: plain(node.children), width: nil, height: nil)
+
+        def plain(nodes)
+          flatten(nodes).sum("") { |item| item.is_a?(Rich::Image) ? item.alt.to_s : item.text }
+        end
+      end
+    end
+  end
+end

data/lib/stationery/markdown/inline_parser.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "strscan"
+require_relative "../rich/nodes"
+require_relative "../text/entities"
+require_relative "inline_parser/nodes"
+require_relative "inline_parser/emphasis"
+require_relative "inline_parser/links"
+
+module Stationery
+  module Markdown
+    # Parses CommonMark inline content into Rich::Inline runs and Rich::Image items: backslash escapes,
+    # code spans, `*`/`_` emphasis, GFM `~` strikethrough, inline, reference and auto links, images,
+    # hard and soft breaks and entities. Raw HTML stays text.
+    class InlineParser
+      include Links
+
+      PUNCTUATION = /[!-\/:-@\[-`{-~]/
+      PLAIN = /[^\\`*_~\[\]!<&\n]+/
+      ENTITY = /&(?:#[xX]\h{1,6}|#\d{1,7}|[a-zA-Z][a-zA-Z0-9]{1,31});/
+
+      def self.parse(text, refs = {}) = new(text, refs).items
+      def self.label(text) = text.strip.gsub(/\s+/, " ").downcase
+      def self.destination(text) = Text::Entities.decode(text.gsub(/\\(#{PUNCTUATION})/o, '\1'))
+
+      def initialize(text, refs)
+        @source = text.to_s
+        @scanner = StringScanner.new(@source)
+        @refs = refs
+        @nodes = []
+        @brackets = []
+      end
+
+      def items
+        step until @scanner.eos?
+        Emphasis.process(@nodes)
+        Rich::Inlines.merge(Nodes.flatten(@nodes))
+      end
+
+      private
+
+      def step
+        if (text = @scanner.scan(PLAIN)) then add(text)
+        elsif @scanner.skip(/\\\n/) then newline(hard: true)
+        elsif @scanner.scan(/\\(#{PUNCTUATION})/o) then add(@scanner[1])
+        elsif @scanner.skip("\n") then newline
+        elsif @scanner.check("`") then code_span
+        elsif @scanner.check(/[*_~]/) then delimiter
+        elsif @scanner.skip("![") then open_bracket(image: true)
+        elsif @scanner.skip("[") then open_bracket
+        elsif @scanner.skip("]") then close_bracket
+        elsif @scanner.scan(AUTOLINK) then autolink
+        elsif @scanner.scan(ENTITY) then add(Text::Entities.decode(@scanner.matched))
+        else add(@scanner.getch)
+        end
+      end
+
+      def add(text) = @nodes << Nodes::Text.new(text)
+
+      def newline(hard: false)
+        last = @nodes.last
+        if last.is_a?(Nodes::Text)
+          stripped = last.text.sub(/ +\z/, "")
+          hard ||= last.text.length - stripped.length >= 2
+          last.text = stripped
+        end
+        @scanner.skip(/ +/)
+        @nodes << (hard ? Nodes::Break.new : Nodes::Text.new(" "))
+      end
+
+      def code_span
+        run = @scanner.scan(/`+/)
+        content = @scanner.scan_until(/(?<!`)#{run}(?!`)/)
+        return add(run) unless content
+
+        text = content[0...-run.length].tr("\n", " ")
+        text = text[1...-1] if text.start_with?(" ") && text.end_with?(" ") && !text.strip.empty?
+        @nodes << Nodes::Code.new(text)
+      end
+
+      def delimiter
+        position = @scanner.charpos
+        run = @scanner.scan(/\*+|_+|~+/)
+        before = position.zero? ? " " : @source[position - 1]
+        @nodes << Emphasis.delimiter(run, before, @source[@scanner.charpos] || " ")
+      end
+    end
+  end
+end

data/lib/stationery/minitest.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "stationery"
+require_relative "testing/matchers"
+
+module Stationery
+  module Testing
+    # Minitest assertions over the same matchers the RSpec integration uses:
+    #
+    #   class InvoiceTest < Minitest::Test
+    #     include Stationery::Testing::Assertions
+    #   end
+    module Assertions
+      def assert_pdf_text(subject, expected, msg = nil) = assert_pdf(Matchers::HaveText.new(expected), subject, msg)
+      def assert_page_count(subject, count, msg = nil) = assert_pdf(Matchers::HavePageCount.new(count), subject, msg)
+      def assert_pdf_link(subject, url, msg = nil) = assert_pdf(Matchers::HaveLink.new(url), subject, msg)
+      def assert_image_count(subject, count, msg = nil) = assert_pdf(Matchers::HaveImageCount.new(count), subject, msg)
+      def assert_bookmark(subject, title, msg = nil) = assert_pdf(Matchers::HaveBookmark.new(title), subject, msg)
+      def assert_no_pdf_warnings(subject, msg = nil) = assert_pdf(Matchers::HaveNoWarnings.new, subject, msg)
+
+      def refute_pdf_text(subject, expected, msg = nil)
+        matcher = Matchers::HaveText.new(expected)
+        assert(!matcher.matches?(subject), msg || matcher.failure_message_when_negated)
+      end
+
+      private
+
+      def assert_pdf(matcher, subject, msg)
+        assert(matcher.matches?(subject), msg || matcher.failure_message)
+      end
+    end
+  end
+end

data/lib/stationery/outline.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Stationery
+  # The bookmarks a document declares, in build order. Each entry names an
+  # automatic anchor, unique to this outline so a page template's bookmarks
+  # never stand in for the body's; once pages are painted, the entries whose
+  # anchors landed somewhere become outline items.
+  class Outline
+    # A declared bookmark: its title, depth (1 = top level), anchor and
+    # whether it starts expanded.
+    Entry = Data.define(:title, :level, :anchor, :open)
+
+    # A bookmark resolved to the page and top its anchor was painted at.
+    Item = Data.define(:title, :level, :dest, :open)
+
+    attr_reader :entries
+
+    def initialize
+      @entries = []
+    end
+
+    def add(title, level: 1, open: false)
+      level = Integer(level)
+      raise ArgumentError, "bookmark level must be 1 or more, got #{level}" if level < 1
+
+      anchor = "__bookmark-#{object_id}-#{@entries.size + 1}"
+      Entry.new(title.to_s, level, anchor, open ? true : false).tap { @entries << it }
+    end
+
+    def resolve(destinations)
+      @entries.filter_map do |entry|
+        dest = destinations[entry.anchor]
+        dest && Item.new(entry.title, entry.level, dest, entry.open)
+      end
+    end
+  end
+end

data/lib/stationery/page.rb

@@ -2,32 +2,46 @@
 
 module Stationery
   # One page: its size and margins, the drawing operators written to it, the
-  # resources those operators reference and its link annotations.
+  # resources those operators reference, its link annotations and the named
+  # anchors painted on it (PDF-space tops) and the page-number slots waiting
+  # for their anchors' pages.
   class Page
+    # Room for the page number of `anchor`, right-aligned in `width` from `x`
+    # on `baseline` (top-left coordinates), drawn in `style`. `link` is an
+    # [x, y, w, h] area linked to the anchor only once it resolves.
+    Slot = Data.define(:anchor, :x, :baseline, :width, :style, :link)
+
     SIZES = {
       a3: [841.89, 1190.55], a4: [595.28, 841.89], a5: [419.53, 595.28],
       letter: [612, 792], legal: [612, 1008], tabloid: [792, 1224]
     }.freeze
 
-    attr_reader :size, :margin, :content, :annotations, :resource_names
+    attr_reader :size, :margin, :reserve, :content, :annotations, :anchors, :template_anchors, :slots, :resource_names
 
-    def initialize(size: :letter, layout: :portrait, margin: 0)
+    def initialize(size: :letter, layout: :portrait, margin: 0, reserve: [0, 0])
       @size = dimensions(size)
       @size = @size.reverse if layout.to_sym == :landscape
       @margin = Geometry.box(margin)
+      @reserve = reserve
       @content = String.new(encoding: Encoding::BINARY)
       @annotations = []
+      @anchors = []
+      @template_anchors = []
+      @slots = []
       @resource_names = Hash.new { |hash, key| hash[key] = [] }
     end
 
     def width = @size[0]
     def height = @size[1]
 
-    def content_box
+    def margin_box
       top, right, bottom, left = @margin
       Rect.new(left, top, width - left - right, height - top - bottom)
     end
 
+    # The margin box less the space reserved for the header and footer.
+    def content_box = margin_box.inset(@reserve[0], 0, @reserve[1], 0)
+
     def use(category, name)
       names = @resource_names[category]
       names << name unless names.include?(name)

data/lib/stationery/page_templates.rb

@@ -4,32 +4,55 @@ module Stationery
   # What a page template knows about the page it draws on.
   PageInfo = Data.define(:number, :count, :width, :height, :margin, :content_box)
 
-  # Runs a document's page templates on every finished page.
+  # Paints a document's headers, footers and page templates on every
+  # finished page.
   class PageTemplates
-    def initialize(document, book:, resources:)
+    def initialize(document, book:, resources:, debug: false, regions: nil, warnings: [])
       @document = document
+      @debug = debug
       @book = book
       @resources = resources
+      @regions = regions
+      @warnings = warnings
       @templates = document.class.config[:templates]
     end
 
     def apply(pages)
-      return if @templates.empty?
-
       pages.each_with_index do |page, index|
         info = PageInfo.new(index + 1, pages.size, page.width, page.height, page.margin, page.content_box)
-        @templates.each { |layer, block| draw(page, info, layer, block) }
+        paint_regions(page, info) if @regions
+        @templates.each { |layer, block| paint(page, root(info, block), page.content_box, layer) }
       end
     end
 
     private
 
-    def draw(page, info, layer, block)
-      builder = Builder.new(book: @book, text: @document.class.config[:text])
-      @document.build_with(builder) { @document.instance_exec(info, &block) }
+    def paint_regions(page, info)
+      box = page.margin_box
+      Regions::SLOTS.each do |slot|
+        region = @regions.entry_for(slot, info.number, last: info.number == info.count)
+        next unless region&.block
+
+        root = root(info, region.block)
+        height = root.measure(box.width)
+        reserved = @regions.height_of(region, info.number)
+        overflow(info.number, height, reserved)
+        y = slot == :header ? box.y : box.bottom - height
+        paint(page, root, Rect.new(box.x, y, box.width, height))
+      end
+    end
+
+    def overflow(number, height, reserved)
+      return if height <= reserved + Layout::EPSILON
+
+      @warnings << Layout::Overflow.new(page: number, height:, available: reserved)
+    end
+
+    def root(info, block) = @document.template_root(info, book: @book, &block)
+
+    def paint(page, root, rect, layer = :foreground)
       mark = page.content.bytesize
-      box = page.content_box
-      builder.root.paint(Canvas.new(page, @resources), box.x, box.y, box.width)
+      root.paint(Canvas.new(page, @resources, template: true, debug: @debug), rect.x, rect.y, rect.width)
       page.content.prepend(page.content.slice!(mark..)) if layer == :background
     end
   end