asciidoctor-epub3 1.5.0.alpha.12

data/lib/asciidoctor-epub3.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'asciidoctor'
+require 'asciidoctor/extensions'
+require 'gepub'
+require_relative 'asciidoctor-epub3/ext'
+require_relative 'asciidoctor-epub3/converter'
+require_relative 'asciidoctor-epub3/packager'
+
+# We need to be able to write files with unicode names. See https://github.com/asciidoctor/asciidoctor-epub3/issues/217
+::Zip.unicode_names = true

data/lib/asciidoctor-epub3/converter.rb

@@ -0,0 +1,951 @@
+# frozen_string_literal: true
+
+require_relative 'spine_item_processor'
+require_relative 'font_icon_map'
+
+module Asciidoctor
+  module Epub3
+    # Public: The main converter for the epub3 backend that handles packaging the
+    # EPUB3 or KF8 publication file.
+    class Converter
+      include ::Asciidoctor::Converter
+      include ::Asciidoctor::Logging
+      include ::Asciidoctor::Writer
+
+      register_for 'epub3'
+
+      def initialize backend, opts
+        super
+        basebackend 'html'
+        outfilesuffix '.epub' # dummy outfilesuffix since it may be .mobi
+        htmlsyntax 'xml'
+        @validate = false
+        @extract = false
+        @kindlegen_path = nil
+        @epubcheck_path = nil
+      end
+
+      def convert node, name = nil
+        if (name ||= node.node_name) == 'document'
+          @validate = node.attr? 'ebook-validate'
+          @extract = node.attr? 'ebook-extract'
+          @compress = node.attr 'ebook-compress'
+          @kindlegen_path = node.attr 'ebook-kindlegen-path'
+          @epubcheck_path = node.attr 'ebook-epubcheck-path'
+          spine_items = node.references[:spine_items]
+          if spine_items.nil?
+            logger.error %(#{::File.basename node.document.attr('docfile')}: failed to find spine items, produced file will be invalid)
+            spine_items = []
+          end
+          Packager.new node, spine_items, node.attributes['ebook-format'].to_sym
+          # converting an element from the spine document, such as an inline node in the doctitle
+        elsif name.start_with? 'inline_'
+          (@content_converter ||= ::Asciidoctor::Converter::Factory.default.create 'epub3-xhtml5').convert node, name
+        else
+          raise ::ArgumentError, %(Encountered unexpected node in epub3 package converter: #{name})
+        end
+      end
+
+      # FIXME: we have to package in write because we don't have access to target before this point
+      def write packager, target
+        packager.package validate: @validate, extract: @extract, compress: @compress, kindlegen_path: @kindlegen_path, epubcheck_path: @epubcheck_path, target: target
+        nil
+      end
+    end
+
+    # Public: The converter for the epub3 backend that converts the individual
+    # content documents in an EPUB3 publication.
+    class ContentConverter
+      include ::Asciidoctor::Converter
+      include ::Asciidoctor::Logging
+
+      register_for 'epub3-xhtml5'
+
+      LF = ?\n
+      NoBreakSpace = ' '
+      ThinNoBreakSpace = ' '
+      RightAngleQuote = '›'
+      CalloutStartNum = %(\u2460)
+
+      CharEntityRx = /&#(\d{2,6});/
+      XmlElementRx = /<\/?.+?>/
+      TrailingPunctRx = /[[:punct:]]$/
+
+      FromHtmlSpecialCharsMap = {
+        '&lt;' => '<',
+        '&gt;' => '>',
+        '&amp;' => '&',
+      }
+
+      FromHtmlSpecialCharsRx = /(?:#{FromHtmlSpecialCharsMap.keys * '|'})/
+
+      ToHtmlSpecialCharsMap = {
+        '&' => '&amp;',
+        '<' => '&lt;',
+        '>' => '&gt;',
+      }
+
+      ToHtmlSpecialCharsRx = /[#{ToHtmlSpecialCharsMap.keys.join}]/
+
+      def initialize backend, opts
+        super
+        basebackend 'html'
+        outfilesuffix '.xhtml'
+        htmlsyntax 'xml'
+        @xrefs_seen = ::Set.new
+        @icon_names = []
+      end
+
+      def convert node, name = nil, _opts = {}
+        method_name = %(convert_#{name ||= node.node_name})
+        if respond_to? method_name
+          send method_name, node
+        else
+          logger.warn %(conversion missing in backend #{@backend} for #{name})
+        end
+      end
+
+      def convert_document node
+        docid = node.id
+        pubtype = node.attr 'publication-type', 'book'
+
+        if (doctitle = node.doctitle partition: true, use_fallback: true).subtitle?
+          title = %(#{doctitle.main} )
+          subtitle = doctitle.subtitle
+        else
+          # HACK: until we get proper handling of title-only in CSS
+          title = ''
+          subtitle = doctitle.combined
+        end
+
+        doctitle_sanitized = (node.doctitle sanitize: true, use_fallback: true).to_s
+        subtitle_formatted = subtitle.split.map {|w| %(<b>#{w}</b>) } * ' '
+
+        if pubtype == 'book'
+          byline = ''
+        else
+          author = node.attr 'author'
+          username = node.attr 'username', 'default'
+          imagesdir = (node.references[:spine].attr 'imagesdir', '.').chomp '/'
+          imagesdir = imagesdir == '.' ? '' : %(#{imagesdir}/)
+          byline = %(<p class="byline"><img src="#{imagesdir}avatars/#{username}.jpg"/> <b class="author">#{author}</b></p>#{LF})
+        end
+
+        mark_last_paragraph node unless pubtype == 'book'
+        content = node.content
+
+        # NOTE must run after content is resolved
+        # TODO perhaps create dynamic CSS file?
+        if @icon_names.empty?
+          icon_css_head = ''
+        else
+          icon_defs = @icon_names.map {|name|
+            %(.i-#{name}::before { content: "#{FontIconMap[name.tr('-', '_').to_sym]}"; })
+          } * LF
+          icon_css_head = %(<style>
+#{icon_defs}
+</style>
+)
+        end
+
+        # NOTE kindlegen seems to mangle the <header> element, so we wrap its content in a div
+        lines = [%(<!DOCTYPE html>
+<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xml:lang="#{lang = node.attr 'lang', 'en'}" lang="#{lang}">
+<head>
+<meta charset="UTF-8"/>
+<title>#{doctitle_sanitized}</title>
+<link rel="stylesheet" type="text/css" href="styles/epub3.css"/>
+<link rel="stylesheet" type="text/css" href="styles/epub3-css3-only.css" media="(min-device-width: 0px)"/>
+#{icon_css_head}<script type="text/javascript"><![CDATA[
+document.addEventListener('DOMContentLoaded', function(event, reader) {
+  if (!(reader = navigator.epubReadingSystem)) {
+    if (navigator.userAgent.indexOf(' calibre/') >= 0) reader = { name: 'calibre-desktop' };
+    else if (window.parent == window || !(reader = window.parent.navigator.epubReadingSystem)) return;
+  }
+  document.body.setAttribute('class', reader.name.toLowerCase().replace(/ /g, '-'));
+});
+]]></script>
+</head>
+<body>
+<section class="chapter" title="#{doctitle_sanitized.gsub '"', '&quot;'}" epub:type="chapter" id="#{docid}">
+<header>
+<div class="chapter-header">
+#{byline}<h1 class="chapter-title">#{title}#{subtitle ? %(<small class="subtitle">#{subtitle_formatted}</small>) : ''}</h1>
+</div>
+</header>
+#{content})]
+
+        if node.footnotes?
+          # NOTE kindlegen seems to mangle the <footer> element, so we wrap its content in a div
+          lines << '<footer>
+<div class="chapter-footer">
+<div class="footnotes">'
+          node.footnotes.each do |footnote|
+            lines << %(<aside id="note-#{footnote.index}" epub:type="footnote">
+<p><sup class="noteref"><a href="#noteref-#{footnote.index}">#{footnote.index}</a></sup> #{footnote.text}</p>
+</aside>)
+          end
+          lines << '</div>
+</div>
+</footer>'
+        end
+
+        lines << '</section>
+</body>
+</html>'
+
+        lines * LF
+      end
+
+      # NOTE embedded is used for AsciiDoc table cell content
+      def convert_embedded node
+        node.content
+      end
+
+      def convert_section node
+        hlevel = node.level + 1
+        epub_type_attr = node.special ? %( epub:type="#{node.sectname}") : ''
+        div_classes = [%(sect#{node.level}), node.role].compact
+        title = node.title
+        title_sanitized = xml_sanitize title
+        if node.document.header? || node.level != 1 || node != node.document.first_section
+          %(<section class="#{div_classes * ' '}" title="#{title_sanitized}"#{epub_type_attr}>
+<h#{hlevel} id="#{node.id}">#{title}</h#{hlevel}>#{(content = node.content).empty? ? '' : %(
+          #{content})}
+</section>)
+        else
+          # document has no level-0 heading and this heading serves as the document title
+          node.content
+        end
+      end
+
+      # TODO: support use of quote block as abstract
+      def convert_preamble node
+        if (first_block = node.blocks[0]) && first_block.style == 'abstract'
+          convert_abstract first_block
+          # REVIEW: should we treat the preamble as an abstract in general?
+        elsif first_block && node.blocks.size == 1
+          convert_abstract first_block
+        else
+          node.content
+        end
+      end
+
+      def convert_open node
+        id_attr = node.id ? %( id="#{node.id}") : nil
+        class_attr = node.role ? %( class="#{node.role}") : nil
+        if id_attr || class_attr
+          %(<div#{id_attr}#{class_attr}>
+#{output_content node}
+</div>)
+        else
+          output_content node
+        end
+      end
+
+      def convert_abstract node
+        %(<div class="abstract" epub:type="preamble">
+#{output_content node}
+</div>)
+      end
+
+      def convert_paragraph node
+        role = node.role
+        # stack-head is the alternative to the default, inline-head (where inline means "run-in")
+        head_stop = node.attr 'head-stop', (role && (node.has_role? 'stack-head') ? nil : '.')
+        head = node.title? ? %(<strong class="head">#{title = node.title}#{head_stop && title !~ TrailingPunctRx ? head_stop : ''}</strong> ) : ''
+        if role
+          node.set_option 'hardbreaks' if node.has_role? 'signature'
+          %(<p class="#{role}">#{head}#{node.content}</p>)
+        else
+          %(<p>#{head}#{node.content}</p>)
+        end
+      end
+
+      def convert_pass node
+        content = node.content
+        if content == '<?hard-pagebreak?>'
+          '<hr epub:type="pagebreak" class="pagebreak"/>'
+        else
+          content
+        end
+      end
+
+      def convert_admonition node
+        id_attr = node.id ? %( id="#{node.id}") : ''
+        if node.title?
+          title = node.title
+          title_sanitized = xml_sanitize title
+          title_attr = %( title="#{node.caption}: #{title_sanitized}")
+          title_el = %(<h2>#{title}</h2>
+)
+        else
+          title_attr = %( title="#{node.caption}")
+          title_el = ''
+        end
+
+        type = node.attr 'name'
+        epub_type = case type
+                    when 'tip'
+                      'help'
+                    when 'note'
+                      'note'
+                    when 'important', 'warning', 'caution'
+                      'warning'
+                    end
+        %(<aside#{id_attr} class="admonition #{type}"#{title_attr} epub:type="#{epub_type}">
+#{title_el}<div class="content">
+#{output_content node}
+</div>
+</aside>)
+      end
+
+      def convert_example node
+        id_attr = node.id ? %( id="#{node.id}") : ''
+        title_div = node.title? ? %(<div class="example-title">#{node.title}</div>
+) : ''
+        %(<div#{id_attr} class="example">
+#{title_div}<div class="example-content">
+#{output_content node}
+</div>
+</div>)
+      end
+
+      def convert_floating_title node
+        tag_name = %(h#{node.level + 1})
+        id_attribute = node.id ? %( id="#{node.id}") : ''
+        %(<#{tag_name}#{id_attribute} class="#{['discrete', node.role].compact * ' '}">#{node.title}</#{tag_name}>)
+      end
+
+      def convert_listing node
+        figure_classes = ['listing']
+        figure_classes << 'coalesce' if node.option? 'unbreakable'
+        pre_classes = node.style == 'source' ? ['source', %(language-#{node.attr 'language'})] : ['screen']
+        title_div = node.title? ? %(<figcaption>#{node.captioned_title}</figcaption>
+) : ''
+        # patches conums to fix extra or missing leading space
+        # TODO remove patch once upgrading to Asciidoctor 1.5.6
+        %(<figure class="#{figure_classes * ' '}">
+#{title_div}<pre class="#{pre_classes * ' '}"><code>#{(node.content || '').gsub(/(?<! )<i class="conum"| +<i class="conum"/, ' <i class="conum"')}</code></pre>
+</figure>)
+      end
+
+      # QUESTION should we wrap the <pre> in either <div> or <figure>?
+      def convert_literal node
+        %(<pre class="screen">#{node.content}</pre>)
+      end
+
+      def convert_page_break _node
+        '<hr epub:type="pagebreak" class="pagebreak"/>'
+      end
+
+      def convert_thematic_break _node
+        '<hr class="thematicbreak"/>'
+      end
+
+      def convert_quote node
+        id_attr = %( id="#{node.id}") if node.id
+        class_attr = (role = node.role) ? %( class="blockquote #{role}") : ' class="blockquote"'
+
+        footer_content = []
+        if (attribution = node.attr 'attribution')
+          footer_content << attribution
+        end
+
+        if (citetitle = node.attr 'citetitle')
+          citetitle_sanitized = xml_sanitize citetitle
+          footer_content << %(<cite title="#{citetitle_sanitized}">#{citetitle}</cite>)
+        end
+
+        footer_content << %(<span class="context">#{node.title}</span>) if node.title?
+
+        footer_tag = footer_content.empty? ? '' : %(
+<footer>~ #{footer_content * ' '}</footer>)
+        content = (output_content node).strip
+        %(<div#{id_attr}#{class_attr}>
+<blockquote>
+#{content}#{footer_tag}
+</blockquote>
+</div>)
+      end
+
+      def convert_verse node
+        id_attr = %( id="#{node.id}") if node.id
+        class_attr = (role = node.role) ? %( class="verse #{role}") : ' class="verse"'
+
+        footer_content = []
+        if (attribution = node.attr 'attribution')
+          footer_content << attribution
+        end
+
+        if (citetitle = node.attr 'citetitle')
+          citetitle_sanitized = xml_sanitize citetitle
+          footer_content << %(<cite title="#{citetitle_sanitized}">#{citetitle}</cite>)
+        end
+
+        footer_tag = !footer_content.empty? ? %(
+<span class="attribution">~ #{footer_content * ', '}</span>) : ''
+        %(<div#{id_attr}#{class_attr}>
+<pre>#{node.content}#{footer_tag}</pre>
+</div>)
+      end
+
+      def convert_sidebar node
+        classes = ['sidebar']
+        if node.title?
+          classes << 'titled'
+          title = node.title
+          title_sanitized = xml_sanitize title
+          title_attr = %( title="#{title_sanitized}")
+          title_el = %(<h2>#{title}</h2>
+)
+        else
+          title_attr = title_el = ''
+        end
+
+        %(<aside class="#{classes * ' '}"#{title_attr} epub:type="sidebar">
+#{title_el}<div class="content">
+#{output_content node}
+</div>
+</aside>)
+      end
+
+      def convert_table node
+        lines = [%(<div class="table">)]
+        lines << %(<div class="content">)
+        table_id_attr = node.id ? %( id="#{node.id}") : ''
+        frame_class = {
+          'all' => 'table-framed',
+          'topbot' => 'table-framed-topbot',
+          'sides' => 'table-framed-sides',
+          'none' => '',
+        }
+        grid_class = {
+          'all' => 'table-grid',
+          'rows' => 'table-grid-rows',
+          'cols' => 'table-grid-cols',
+          'none' => '',
+        }
+        table_classes = %W[table #{frame_class[node.attr 'frame'] || frame_class['topbot']} #{grid_class[node.attr 'grid'] || grid_class['rows']}]
+        if (role = node.role)
+          table_classes << role
+        end
+        table_class_attr = %( class="#{table_classes * ' '}")
+        table_styles = []
+        table_styles << %(width: #{node.attr 'tablepcwidth'}%) unless (node.option? 'autowidth') && !(node.attr? 'width', nil, false)
+        table_style_attr = !table_styles.empty? ? %( style="#{table_styles * '; '}") : ''
+
+        lines << %(<table#{table_id_attr}#{table_class_attr}#{table_style_attr}>)
+        lines << %(<caption>#{node.captioned_title}</caption>) if node.title?
+        if (node.attr 'rowcount') > 0
+          lines << '<colgroup>'
+          #if node.option? 'autowidth'
+          tag = %(<col/>)
+          node.columns.size.times do
+            lines << tag
+          end
+          #else
+          #  node.columns.each do |col|
+          #    lines << %(<col style="width: #{col.attr 'colpcwidth'}%"/>)
+          #  end
+          #end
+          lines << '</colgroup>'
+          [:head, :foot, :body].reject {|tsec| node.rows[tsec].empty? }.each do |tsec|
+            lines << %(<t#{tsec}>)
+            node.rows[tsec].each do |row|
+              lines << '<tr>'
+              row.each do |cell|
+                if tsec == :head
+                  cell_content = cell.text
+                else
+                  case cell.style
+                  when :asciidoc
+                    cell_content = %(<div class="embed">#{cell.content}</div>)
+                  when :verse
+                    cell_content = %(<div class="verse">#{cell.text}</div>)
+                  when :literal
+                    cell_content = %(<div class="literal"><pre>#{cell.text}</pre></div>)
+                  else
+                    cell_content = ''
+                    cell.content.each do |text|
+                      cell_content = %(#{cell_content}<p>#{text}</p>)
+                    end
+                  end
+                end
+
+                cell_tag_name = tsec == :head || cell.style == :header ? 'th' : 'td'
+                cell_classes = []
+                if (halign = cell.attr 'halign') && halign != 'left'
+                  cell_classes << 'halign-left'
+                end
+                if (halign = cell.attr 'valign') && halign != 'top'
+                  cell_classes << 'valign-top'
+                end
+                cell_class_attr = !cell_classes.empty? ? %( class="#{cell_classes * ' '}") : ''
+                cell_colspan_attr = cell.colspan ? %( colspan="#{cell.colspan}") : ''
+                cell_rowspan_attr = cell.rowspan ? %( rowspan="#{cell.rowspan}") : ''
+                cell_style_attr = (node.document.attr? 'cellbgcolor') ? %( style="background-color: #{node.document.attr 'cellbgcolor'}") : ''
+                lines << %(<#{cell_tag_name}#{cell_class_attr}#{cell_colspan_attr}#{cell_rowspan_attr}#{cell_style_attr}>#{cell_content}</#{cell_tag_name}>)
+              end
+              lines << '</tr>'
+            end
+            lines << %(</t#{tsec}>)
+          end
+        end
+        lines << '</table>
+</div>
+</div>'
+        lines * LF
+      end
+
+      def convert_colist node
+        lines = ['<div class="callout-list">
+<ol>']
+        num = CalloutStartNum
+        node.items.each_with_index do |item, i|
+          lines << %(<li><i class="conum" data-value="#{i + 1}">#{num}</i> #{item.text}</li>)
+          num = num.next
+        end
+        lines << '</ol>
+</div>'
+      end
+
+      # TODO: add complex class if list has nested blocks
+      def convert_dlist node
+        lines = []
+        case (style = node.style)
+        when 'itemized', 'ordered'
+          list_tag_name = style == 'itemized' ? 'ul' : 'ol'
+          role = node.role
+          subject_stop = node.attr 'subject-stop', (role && (node.has_role? 'stack') ? nil : ':')
+          # QUESTION should we just use itemized-list and ordered-list as the class here? or just list?
+          div_classes = [%(#{style}-list), role].compact
+          list_class_attr = (node.option? 'brief') ? ' class="brief"' : ''
+          lines << %(<div class="#{div_classes * ' '}">
+<#{list_tag_name}#{list_class_attr}#{list_tag_name == 'ol' && (node.option? 'reversed') ? ' reversed="reversed"' : ''}>)
+          node.items.each do |subjects, dd|
+            # consists of one term (a subject) and supporting content
+            subject = [*subjects].first.text
+            subject_plain = xml_sanitize subject, :plain
+            subject_element = %(<strong class="subject">#{subject}#{subject_stop && subject_plain !~ TrailingPunctRx ? subject_stop : ''}</strong>)
+            lines << '<li>'
+            if dd
+              # NOTE: must wrap remaining text in a span to help webkit justify the text properly
+              lines << %(<span class="principal">#{subject_element}#{dd.text? ? %( <span class="supporting">#{dd.text}</span>) : ''}</span>)
+              lines << dd.content if dd.blocks?
+            else
+              lines << %(<span class="principal">#{subject_element}</span>)
+            end
+            lines << '</li>'
+          end
+          lines << %(</#{list_tag_name}>
+</div>)
+        else
+          lines << '<div class="description-list">
+<dl>'
+          node.items.each do |terms, dd|
+            [*terms].each do |dt|
+              lines << %(<dt>
+<span class="term">#{dt.text}</span>
+</dt>)
+            end
+            next unless dd
+            lines << '<dd>'
+            if dd.blocks?
+              lines << %(<span class="principal">#{dd.text}</span>) if dd.text?
+              lines << dd.content
+            else
+              lines << %(<span class="principal">#{dd.text}</span>)
+            end
+            lines << '</dd>'
+          end
+          lines << '</dl>
+</div>'
+        end
+        lines * LF
+      end
+
+      def convert_olist node
+        complex = false
+        div_classes = ['ordered-list', node.style, node.role].compact
+        ol_classes = [node.style, ((node.option? 'brief') ? 'brief' : nil)].compact
+        ol_class_attr = ol_classes.empty? ? '' : %( class="#{ol_classes * ' '}")
+        ol_start_attr = (node.attr? 'start') ? %( start="#{node.attr 'start'}") : ''
+        id_attribute = node.id ? %( id="#{node.id}") : ''
+        lines = [%(<div#{id_attribute} class="#{div_classes * ' '}">)]
+        lines << %(<h3 class="list-heading">#{node.title}</h3>) if node.title?
+        lines << %(<ol#{ol_class_attr}#{ol_start_attr}#{(node.option? 'reversed') ? ' reversed="reversed"' : ''}>)
+        node.items.each do |item|
+          lines << %(<li>
+<span class="principal">#{item.text}</span>)
+          if item.blocks?
+            lines << item.content
+            complex = true unless item.blocks.size == 1 && ::Asciidoctor::List === item.blocks[0]
+          end
+          lines << '</li>'
+        end
+        if complex
+          div_classes << 'complex'
+          lines[0] = %(<div class="#{div_classes * ' '}">)
+        end
+        lines << '</ol>
+</div>'
+        lines * LF
+      end
+
+      def convert_ulist node
+        complex = false
+        div_classes = ['itemized-list', node.style, node.role].compact
+        ul_classes = [node.style, ((node.option? 'brief') ? 'brief' : nil)].compact
+        ul_class_attr = ul_classes.empty? ? '' : %( class="#{ul_classes * ' '}")
+        id_attribute = node.id ? %( id="#{node.id}") : ''
+        lines = [%(<div#{id_attribute} class="#{div_classes * ' '}">)]
+        lines << %(<h3 class="list-heading">#{node.title}</h3>) if node.title?
+        lines << %(<ul#{ul_class_attr}>)
+        node.items.each do |item|
+          lines << %(<li>
+<span class="principal">#{item.text}</span>)
+          if item.blocks?
+            lines << item.content
+            complex = true unless item.blocks.size == 1 && ::Asciidoctor::List === item.blocks[0]
+          end
+          lines << '</li>'
+        end
+        if complex
+          div_classes << 'complex'
+          lines[0] = %(<div class="#{div_classes * ' '}">)
+        end
+        lines << '</ul>
+</div>'
+        lines * LF
+      end
+
+      def convert_image node
+        target = node.attr 'target'
+        type = (::File.extname target)[1..-1]
+        id_attr = node.id ? %( id="#{node.id}") : ''
+        img_attrs = [%(alt="#{node.attr 'alt'}")]
+        case type
+        when 'svg'
+          img_attrs << %(style="width: #{node.attr 'scaledwidth', '100%'}")
+          # TODO: make this a convenience method on document
+          epub_properties = (node.document.attributes['epub-properties'] ||= [])
+          epub_properties << 'svg' unless epub_properties.include? 'svg'
+        else
+          img_attrs << %(style="width: #{node.attr 'scaledwidth'}") if node.attr? 'scaledwidth'
+        end
+=begin
+    # NOTE to set actual width and height, use CSS width and height
+    if type == 'svg'
+      if node.attr? 'scaledwidth'
+        img_attrs << %(width="#{node.attr 'scaledwidth'}")
+      # Kindle
+      #elsif node.attr? 'scaledheight'
+      #  img_attrs << %(width="#{node.attr 'scaledheight'}" height="#{node.attr 'scaledheight'}")
+      # ePub3
+      elsif node.attr? 'scaledheight'
+        img_attrs << %(height="#{node.attr 'scaledheight'}" style="max-height: #{node.attr 'scaledheight'} !important")
+      else
+        # Aldiko doesn't not scale width to 100% by default
+        img_attrs << %(width="100%")
+      end
+    end
+=end
+        %(<figure#{id_attr} class="image#{prepend_space node.role}">
+<div class="content">
+<img src="#{node.image_uri node.attr('target')}" #{img_attrs * ' '}/>
+</div>#{node.title? ? %(
+<figcaption>#{node.captioned_title}</figcaption>) : ''}
+</figure>)
+      end
+
+      def convert_inline_anchor node
+        target = node.target
+        case node.type
+        when :xref # TODO: would be helpful to know what type the target is (e.g., bibref)
+          doc, refid, text, path = node.document, ((node.attr 'refid') || target), node.text, (node.attr 'path')
+          # NOTE if path is non-nil, we have an inter-document xref
+          # QUESTION should we drop the id attribute for an inter-document xref?
+          if path
+            # ex. chapter-id#section-id
+            if node.attr 'fragment'
+              refdoc_id, refdoc_refid = refid.split '#', 2
+              if refdoc_id == refdoc_refid
+                target = target[0...(target.index '#')]
+                id_attr = %( id="xref--#{refdoc_id}")
+              else
+                id_attr = %( id="xref--#{refdoc_id}--#{refdoc_refid}")
+              end
+              # ex. chapter-id#
+            else
+              refdoc_id = refdoc_refid = refid
+              # inflate key to spine item root (e.g., transform chapter-id to chapter-id#chapter-id)
+              refid = %(#{refid}##{refid})
+              id_attr = %( id="xref--#{refdoc_id}")
+            end
+            id_attr = '' unless @xrefs_seen.add? refid
+            refdoc = doc.references[:spine_items].find {|it| refdoc_id == (it.id || (it.attr 'docname')) }
+            if refdoc
+              if (refs = refdoc.references[:refs]) && ::Asciidoctor::AbstractNode === (ref = refs[refdoc_refid])
+                text ||= ::Asciidoctor::Document === ref ? ((ref.attr 'docreftext') || ref.doctitle) : ref.xreftext((@xrefstyle ||= (doc.attr 'xrefstyle')))
+              elsif (xreftext = refdoc.references[:ids][refdoc_refid])
+                text ||= xreftext
+              else
+                logger.warn %(#{::File.basename doc.attr('docfile')}: invalid reference to unknown anchor in #{refdoc_id} chapter: #{refdoc_refid})
+              end
+            else
+              logger.warn %(#{::File.basename doc.attr('docfile')}: invalid reference to anchor in unknown chapter: #{refdoc_id})
+            end
+          else
+            id_attr = (@xrefs_seen.add? refid) ? %( id="xref-#{refid}") : ''
+            if (refs = doc.references[:refs])
+              if ::Asciidoctor::AbstractNode === (ref = refs[refid])
+                xreftext = text || ref.xreftext((@xrefstyle ||= (doc.attr 'xrefstyle')))
+              end
+            else
+              xreftext = doc.references[:ids][refid]
+            end
+
+            if xreftext
+              text ||= xreftext
+            else
+              # FIXME: we get false negatives for reference to bibref when using Asciidoctor < 1.5.6
+              logger.warn %(#{::File.basename doc.attr('docfile')}: invalid reference to unknown local anchor (or valid bibref): #{refid})
+            end
+          end
+          %(<a#{id_attr} href="#{target}" class="xref">#{text || "[#{refid}]"}</a>)
+        when :ref
+          %(<a id="#{target}"></a>)
+        when :link
+          %(<a href="#{target}" class="link">#{node.text}</a>)
+        when :bibref
+          if @xrefs_seen.include? target
+            %(<a id="#{target}" href="#xref-#{target}">[#{target}]</a>)
+          else
+            %(<a id="#{target}"></a>[#{target}])
+          end
+        end
+      end
+
+      def convert_inline_break node
+        %(#{node.text}<br/>)
+      end
+
+      def convert_inline_button node
+        %(<b class="button">[<span class="label">#{node.text}</span>]</b>)
+      end
+
+      def convert_inline_callout node
+        num = CalloutStartNum
+        int_num = node.text.to_i
+        (int_num - 1).times { num = num.next }
+        %(<i class="conum" data-value="#{int_num}">#{num}</i>)
+      end
+
+      def convert_inline_footnote node
+        if (index = node.attr 'index')
+          %(<sup class="noteref">[<a id="noteref-#{index}" href="#note-#{index}" epub:type="noteref">#{index}</a>]</sup>)
+        elsif node.type == :xref
+          %(<mark class="noteref" title="Unresolved note reference">#{node.text}</mark>)
+        end
+      end
+
+      def convert_inline_image node
+        if node.type == 'icon'
+          @icon_names << (icon_name = node.target)
+          i_classes = ['icon', %(i-#{icon_name})]
+          i_classes << %(icon-#{node.attr 'size'}) if node.attr? 'size'
+          i_classes << %(icon-flip-#{(node.attr 'flip')[0]}) if node.attr? 'flip'
+          i_classes << %(icon-rotate-#{node.attr 'rotate'}) if node.attr? 'rotate'
+          i_classes << node.role if node.role?
+          %(<i class="#{i_classes * ' '}"></i>)
+        else
+          target = node.image_uri node.target
+          img_attrs = [%(alt="#{node.attr 'alt'}"), %(class="inline#{node.role? ? " #{node.role}" : ''}")]
+          if target.end_with? '.svg'
+            img_attrs << %(style="width: #{node.attr 'scaledwidth', '100%'}")
+            # TODO: make this a convenience method on document
+            epub_properties = (node.document.attributes['epub-properties'] ||= [])
+            epub_properties << 'svg' unless epub_properties.include? 'svg'
+          elsif node.attr? 'scaledwidth'
+            img_attrs << %(style="width: #{node.attr 'scaledwidth'}")
+          end
+          %(<img src="#{target}" #{img_attrs * ' '}/>)
+        end
+      end
+
+      def convert_inline_indexterm node
+        node.type == :visible ? node.text : ''
+      end
+
+      def convert_inline_kbd node
+        if (keys = node.attr 'keys').size == 1
+          %(<kbd>#{keys[0]}</kbd>)
+        else
+          key_combo = keys.map {|key| %(<kbd>#{key}</kbd>) }.join '+'
+          %(<span class="keyseq">#{key_combo}</span>)
+        end
+      end
+
+      def convert_inline_menu node
+        menu = node.attr 'menu'
+        # NOTE we swap right angle quote with chevron right from FontAwesome using CSS
+        caret = %(#{NoBreakSpace}<span class="caret">#{RightAngleQuote}</span> )
+        if !(submenus = node.attr 'submenus').empty?
+          submenu_path = submenus.map {|submenu| %(<span class="submenu">#{submenu}</span>#{caret}) }.join.chop
+          %(<span class="menuseq"><span class="menu">#{menu}</span>#{caret}#{submenu_path} <span class="menuitem">#{node.attr 'menuitem'}</span></span>)
+        elsif (menuitem = node.attr 'menuitem')
+          %(<span class="menuseq"><span class="menu">#{menu}</span>#{caret}<span class="menuitem">#{menuitem}</span></span>)
+        else
+          %(<span class="menu">#{menu}</span>)
+        end
+      end
+
+      def convert_inline_quoted node
+        case node.type
+        when :strong
+          %(<strong>#{node.text}</strong>)
+        when :emphasis
+          %(<em>#{node.text}</em>)
+        when :monospaced
+          %(<code class="literal">#{node.text}</code>)
+        when :double
+          #%(&#x201c;#{node.text}&#x201d;)
+          %(“#{node.text}”)
+        when :single
+          #%(&#x2018;#{node.text}&#x2019;)
+          %(‘#{node.text}’)
+        when :superscript
+          %(<sup>#{node.text}</sup>)
+        when :subscript
+          %(<sub>#{node.text}</sub>)
+        else
+          node.text
+        end
+      end
+
+      def output_content node
+        node.content_model == :simple ? %(<p>#{node.content}</p>) : node.content
+      end
+
+      # FIXME: merge into with xml_sanitize helper
+      def xml_sanitize value, target = :attribute
+        sanitized = (value.include? '<') ? value.gsub(XmlElementRx, '').strip.tr_s(' ', ' ') : value
+        if target == :plain && (sanitized.include? ';')
+          sanitized = sanitized.gsub(CharEntityRx) { [$1.to_i].pack 'U*' } if sanitized.include? '&#'
+          sanitized = sanitized.gsub FromHtmlSpecialCharsRx, FromHtmlSpecialCharsMap
+        elsif target == :attribute
+          sanitized = sanitized.gsub '"', '&quot;' if sanitized.include? '"'
+        end
+        sanitized
+      end
+
+      # TODO: make check for last content paragraph a feature of Asciidoctor
+      def mark_last_paragraph root
+        return unless (last_block = root.blocks[-1])
+        last_block = last_block.blocks[-1] while last_block.context == :section && last_block.blocks?
+        if last_block.context == :paragraph
+          last_block.attributes['role'] = last_block.role? ? %(#{last_block.role} last) : 'last'
+        end
+        nil
+      end
+
+      # Prepend a space to the value if it's non-nil, otherwise return empty string.
+      def prepend_space value
+        value ? %( #{value}) : ''
+      end
+    end
+
+    class DocumentIdGenerator
+      ReservedIds = %w(cover nav ncx)
+      CharRefRx = /&(?:([a-zA-Z][a-zA-Z]+\d{0,2})|#(\d\d\d{0,4})|#x([\da-fA-F][\da-fA-F][\da-fA-F]{0,3}));/
+      if defined? __dir__
+        InvalidIdCharsRx = /[^\p{Word}]+/
+        LeadingDigitRx = /^\p{Nd}/
+      else
+        InvalidIdCharsRx = /[^[:word:]]+/
+        LeadingDigitRx = /^[[:digit:]]/
+      end
+      class << self
+        def generate_id doc, pre = nil, sep = nil
+          synthetic = false
+          unless (id = doc.id)
+            # NOTE we assume pre is a valid ID prefix and that pre and sep only contain valid ID chars
+            pre ||= '_'
+            sep = sep ? sep.chr : '_'
+            if doc.header?
+              id = doc.doctitle sanitize: true
+              id = id.gsub CharRefRx do
+                $1 ? ($1 == 'amp' ? 'and' : sep) : ((d = $2 ? $2.to_i : $3.hex) == 8217 ? '' : ([d].pack 'U*'))
+              end if id.include? '&'
+              id = id.downcase.gsub InvalidIdCharsRx, sep
+              if id.empty?
+                id, synthetic = nil, true
+              else
+                unless sep.empty?
+                  if (id = id.tr_s sep, sep).end_with? sep
+                    if id == sep
+                      id, synthetic = nil, true
+                    else
+                      id = (id.start_with? sep) ? id[1..-2] : id.chop
+                    end
+                  elsif id.start_with? sep
+                    id = id[1..-1]
+                  end
+                end
+                unless synthetic
+                  if pre.empty?
+                    id = %(_#{id}) if LeadingDigitRx =~ id
+                  elsif !(id.start_with? pre)
+                    id = %(#{pre}#{id})
+                  end
+                end
+              end
+            elsif (first_section = doc.first_section)
+              id = first_section.id
+            else
+              synthetic = true
+            end
+            id = %(#{pre}document#{sep}#{doc.object_id}) if synthetic
+          end
+          logger.error %(chapter uses a reserved ID: #{id}) if !synthetic && (ReservedIds.include? id)
+          id
+        end
+      end
+    end
+
+    require_relative 'packager'
+
+    Extensions.register do
+      if (document = @document).backend == 'epub3'
+        document.attributes['spine'] = ''
+        document.set_attribute 'listing-caption', 'Listing'
+        # pygments.rb hangs on JRuby for Windows, see https://github.com/asciidoctor/asciidoctor-epub3/issues/253
+        if !(::RUBY_ENGINE == 'jruby' && Gem.win_platform?) && (Gem.try_activate 'pygments.rb')
+          if document.set_attribute 'source-highlighter', 'pygments'
+            document.set_attribute 'pygments-css', 'style'
+            document.set_attribute 'pygments-style', 'bw'
+          end
+        end
+        case (ebook_format = document.attributes['ebook-format'])
+        when 'epub3', 'kf8'
+          # all good
+        when 'mobi'
+          ebook_format = document.attributes['ebook-format'] = 'kf8'
+        else
+          # QUESTION should we display a warning?
+          ebook_format = document.attributes['ebook-format'] = 'epub3'
+        end
+        document.attributes[%(ebook-format-#{ebook_format})] = ''
+        # Only fire SpineItemProcessor for top-level include directives
+        include_processor SpineItemProcessor.new(document)
+        treeprocessor do
+          process do |doc|
+            doc.id = DocumentIdGenerator.generate_id doc, (doc.attr 'idprefix'), (doc.attr 'idseparator')
+            nil
+          end
+        end
+      end
+    end
+  end
+end