zine_brewer 1.3.0 → 1.3.1

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/converter/kramdown.rb

@@ -1,448 +0,0 @@
-# -*- coding: utf-8; frozen_string_literal: true -*-
-#
-#--
-# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-require 'kramdown/converter'
-require 'kramdown/utils'
-
-module Kramdown
-
-  module Converter
-
-    # Converts an element tree to the kramdown format.
-    class Kramdown < Base
-
-      # :stopdoc:
-
-      include ::Kramdown::Utils::Html
-
-      def initialize(root, options)
-        super
-        @linkrefs = []
-        @footnotes = []
-        @abbrevs = []
-        @stack = []
-      end
-
-      def convert(el, opts = {indent: 0})
-        res = send("convert_#{el.type}", el, opts)
-        res = res.dup if res.frozen?
-        if ![:html_element, :li, :dt, :dd, :td].include?(el.type) && (ial = ial_for_element(el))
-          res << ial
-          res << "\n\n" if el.block?
-        elsif [:ul, :dl, :ol, :codeblock].include?(el.type) && opts[:next] &&
-            ([el.type, :codeblock].include?(opts[:next].type) ||
-             (opts[:next].type == :blank && opts[:nnext] &&
-              [el.type, :codeblock].include?(opts[:nnext].type)))
-          res << "^\n\n"
-        elsif el.block? &&
-            ![:li, :dd, :dt, :td, :th, :tr, :thead, :tbody, :tfoot, :blank].include?(el.type) &&
-            (el.type != :html_element || @stack.last.type != :html_element) &&
-            (el.type != :p || !el.options[:transparent])
-          res << "\n"
-        end
-        res
-      end
-
-      def inner(el, opts = {indent: 0})
-        @stack.push(el)
-        result = +''
-        el.children.each_with_index do |inner_el, index|
-          options = opts.dup
-          options[:index] = index
-          options[:prev] = (index == 0 ? nil : el.children[index - 1])
-          options[:pprev] = (index <= 1 ? nil : el.children[index - 2])
-          options[:next] = (index == el.children.length - 1 ? nil : el.children[index + 1])
-          options[:nnext] = (index >= el.children.length - 2 ? nil : el.children[index + 2])
-          result << convert(inner_el, options)
-        end
-        @stack.pop
-        result
-      end
-
-      def convert_blank(_el, _opts)
-        ""
-      end
-
-      ESCAPED_CHAR_RE = /(\$\$|[\\*_`\[\]\{"'|])|^[ ]{0,3}(:)/
-
-      def convert_text(el, opts)
-        if opts[:raw_text]
-          el.value
-        else
-          el.value.gsub(/\A\n/) do
-            opts[:prev] && opts[:prev].type == :br ? '' : "\n"
-          end.gsub(/\s+/, ' ').gsub(ESCAPED_CHAR_RE) { "\\#{$1 || $2}" }
-        end
-      end
-
-      def convert_p(el, opts)
-        w = @options[:line_width] - opts[:indent].to_s.to_i
-        first, second, *rest = inner(el, opts).strip.gsub(/(.{1,#{w}})( +|$\n?)/, "\\1\n").split(/\n/)
-        first&.gsub!(/^(?:(#|>)|(\d+)\.|([+-]\s))/) { $1 || $3 ? "\\#{$1 || $3}" : "#{$2}\\." }
-        second&.gsub!(/^([=-]+\s*?)$/, "\\\1")
-        res = [first, second, *rest].compact.join("\n") + "\n"
-        if el.children.length == 1 && el.children.first.type == :math
-          res = "\\#{res}"
-        elsif res.start_with?('\$$') && res.end_with?("\\$$\n")
-          res.sub!(/^\\\$\$/, '\$\$')
-        end
-        res
-      end
-
-      def convert_codeblock(el, _opts)
-        el.value.split(/\n/).map {|l| l.empty? ? "    " : "    #{l}" }.join("\n") + "\n"
-      end
-
-      def convert_blockquote(el, opts)
-        opts[:indent] += 2
-        inner(el, opts).chomp.split(/\n/).map {|l| "> #{l}" }.join("\n") << "\n"
-      end
-
-      def convert_header(el, opts)
-        res = +''
-        res << "#{'#' * output_header_level(el.options[:level])} #{inner(el, opts)}"
-        res[-1, 1] = "\\#" if res[-1] == '#'
-        res << "   {##{el.attr['id']}}" if el.attr['id'] && !el.attr['id'].strip.empty?
-        res << "\n"
-      end
-
-      def convert_hr(_el, _opts)
-        "* * *\n"
-      end
-
-      def convert_ul(el, opts)
-        inner(el, opts).sub(/\n+\Z/, "\n")
-      end
-      alias convert_ol convert_ul
-      alias convert_dl convert_ul
-
-      def convert_li(el, opts)
-        sym, width = if @stack.last.type == :ul
-                       [+'* ', el.children.first && el.children.first.type == :codeblock ? 4 : 2]
-                     else
-                       ["#{opts[:index] + 1}.".ljust(4), 4]
-                     end
-        if (ial = ial_for_element(el))
-          sym << ial << " "
-        end
-
-        opts[:indent] += width
-        text = inner(el, opts)
-        newlines = text.scan(/\n*\Z/).first
-        first, *last = text.split(/\n/)
-        last = last.map {|l| " " * width + l }.join("\n")
-        text = (first.nil? ? "\n" : first + (last.empty? ? "" : "\n") + last + newlines)
-        if el.children.first && el.children.first.type == :p && !el.children.first.options[:transparent]
-          res = +"#{sym}#{text}"
-          res << "^\n" if el.children.size == 1 && @stack.last.children.last == el &&
-            (@stack.last.children.any? {|c| c.children.first.type != :p } || @stack.last.children.size == 1)
-          res
-        elsif el.children.first && el.children.first.type == :codeblock
-          "#{sym}\n    #{text}"
-        else
-          "#{sym}#{text}"
-        end
-      end
-
-      def convert_dd(el, opts)
-        sym, width = +": ", (el.children.first && el.children.first.type == :codeblock ? 4 : 2)
-        if (ial = ial_for_element(el))
-          sym << ial << " "
-        end
-
-        opts[:indent] += width
-        text = inner(el, opts)
-        newlines = text.scan(/\n*\Z/).first
-        first, *last = text.split(/\n/)
-        last = last.map {|l| " " * width + l }.join("\n")
-        text = first.to_s + (last.empty? ? "" : "\n") + last + newlines
-        text.chomp! if text =~ /\n\n\Z/ && opts[:next] && opts[:next].type == :dd
-        text << "\n" if text !~ /\n\n\Z/ && opts[:next] && opts[:next].type == :dt
-        text << "\n" if el.children.empty?
-        if el.children.first && el.children.first.type == :p && !el.children.first.options[:transparent]
-          "\n#{sym}#{text}"
-        elsif el.children.first && el.children.first.type == :codeblock
-          "#{sym}\n    #{text}"
-        else
-          "#{sym}#{text}"
-        end
-      end
-
-      def convert_dt(el, opts)
-        result = +''
-        if (ial = ial_for_element(el))
-          result << ial << " "
-        end
-        result << inner(el, opts) << "\n"
-      end
-
-      HTML_TAGS_WITH_BODY = ['div', 'script', 'iframe', 'textarea']
-
-      HTML_ELEMENT_TYPES = [:entity, :text, :html_element].freeze
-      private_constant :HTML_ELEMENT_TYPES
-
-      def convert_html_element(el, opts)
-        markdown_attr = el.options[:category] == :block && el.children.any? do |c|
-          c.type != :html_element &&
-            (c.type != :p || !c.options[:transparent] ||
-             c.children.any? {|t| !HTML_ELEMENT_TYPES.member?(t.type) }) &&
-            c.block?
-        end
-        opts[:force_raw_text] = true if %w[script pre code].include?(el.value)
-        opts[:raw_text] = opts[:force_raw_text] || opts[:block_raw_text] || \
-          (el.options[:category] != :span && !markdown_attr)
-        opts[:block_raw_text] = true if el.options[:category] == :block && opts[:raw_text]
-        res = inner(el, opts)
-        if el.options[:category] == :span
-          "<#{el.value}#{html_attributes(el.attr)}" + \
-            (!res.empty? || HTML_TAGS_WITH_BODY.include?(el.value) ? ">#{res}</#{el.value}>" : " />")
-        else
-          output = +''
-          attr = el.attr.dup
-          attr['markdown'] = '1' if markdown_attr
-          output << "<#{el.value}#{html_attributes(attr)}"
-          if !res.empty? && el.options[:content_model] != :block
-            output << ">#{res}</#{el.value}>"
-          elsif !res.empty?
-            output << ">\n#{res}" << "</#{el.value}>"
-          elsif HTML_TAGS_WITH_BODY.include?(el.value)
-            output << "></#{el.value}>"
-          else
-            output << " />"
-          end
-          output << "\n" if @stack.last.type != :html_element || @stack.last.options[:content_model] != :raw
-          output
-        end
-      end
-
-      def convert_xml_comment(el, _opts)
-        if el.options[:category] == :block &&
-            (@stack.last.type != :html_element || @stack.last.options[:content_model] != :raw)
-          el.value + "\n"
-        else
-          el.value.dup
-        end
-      end
-      alias convert_xml_pi convert_xml_comment
-
-      def convert_table(el, opts)
-        opts[:alignment] = el.options[:alignment]
-        inner(el, opts)
-      end
-
-      def convert_thead(el, opts)
-        rows = inner(el, opts)
-        if opts[:alignment].all? {|a| a == :default }
-          "#{rows}|#{'-' * 10}\n"
-        else
-          "#{rows}| " + opts[:alignment].map do |a|
-            case a
-            when :left then ":-"
-            when :right then "-:"
-            when :center then ":-:"
-            when :default then "-"
-            end
-          end.join(' ') << "\n"
-        end
-      end
-
-      def convert_tbody(el, opts)
-        res = +''
-        res << inner(el, opts)
-        res << '|' << '-' * 10 << "\n" if opts[:next] && opts[:next].type == :tbody
-        res
-      end
-
-      def convert_tfoot(el, opts)
-        "|#{'=' * 10}\n#{inner(el, opts)}"
-      end
-
-      def convert_tr(el, opts)
-        "| #{el.children.map {|c| convert(c, opts) }.join(' | ')} |\n"
-      end
-
-      def convert_td(el, opts)
-        inner(el, opts)
-      end
-
-      def convert_comment(el, _opts)
-        if el.options[:category] == :block
-          "{::comment}\n#{el.value}\n{:/}\n"
-        else
-          "{::comment}#{el.value}{:/}"
-        end
-      end
-
-      def convert_br(_el, _opts)
-        "  \n"
-      end
-
-      def convert_a(el, opts)
-        if el.attr['href'].empty?
-          "[#{inner(el, opts)}]()"
-        elsif el.attr['href'] =~ /^(?:http|ftp)/ || el.attr['href'].count("()") > 0
-          index = if (link_el = @linkrefs.find {|c| c.attr['href'] == el.attr['href'] })
-                    @linkrefs.index(link_el) + 1
-                  else
-                    @linkrefs << el
-                    @linkrefs.size
-                  end
-          "[#{inner(el, opts)}][#{index}]"
-        else
-          title = parse_title(el.attr['title'])
-          "[#{inner(el, opts)}](#{el.attr['href']}#{title})"
-        end
-      end
-
-      def convert_img(el, _opts)
-        alt_text = el.attr['alt'].to_s.gsub(ESCAPED_CHAR_RE) { $1 ? "\\#{$1}" : $2 }
-        src = el.attr['src'].to_s
-        if src.empty?
-          "![#{alt_text}]()"
-        else
-          title = parse_title(el.attr['title'])
-          link = if src.count("()") > 0
-                   "<#{src}>"
-                 else
-                   src
-                 end
-          "![#{alt_text}](#{link}#{title})"
-        end
-      end
-
-      def convert_codespan(el, _opts)
-        delim = (el.value.scan(/`+/).max || '') + '`'
-        "#{delim}#{' ' if delim.size > 1}#{el.value}#{' ' if delim.size > 1}#{delim}"
-      end
-
-      def convert_footnote(el, _opts)
-        @footnotes << [el.options[:name], el.value]
-        "[^#{el.options[:name]}]"
-      end
-
-      def convert_raw(el, _opts)
-        attr = (el.options[:type] || []).join(' ')
-        attr = " type=\"#{attr}\"" unless attr.empty?
-        if @stack.last.type == :html_element
-          el.value
-        elsif el.options[:category] == :block
-          "{::nomarkdown#{attr}}\n#{el.value}\n{:/}\n"
-        else
-          "{::nomarkdown#{attr}}#{el.value}{:/}"
-        end
-      end
-
-      def convert_em(el, opts)
-        "*#{inner(el, opts)}*" +
-          (opts[:next] && [:em, :strong].include?(opts[:next].type) && !ial_for_element(el) ? '{::}' : '')
-      end
-
-      def convert_strong(el, opts)
-        "**#{inner(el, opts)}**" +
-          (opts[:next] && [:em, :strong].include?(opts[:next].type) && !ial_for_element(el) ? '{::}' : '')
-      end
-
-      def convert_entity(el, _opts)
-        entity_to_str(el.value, el.options[:original])
-      end
-
-      TYPOGRAPHIC_SYMS = {
-        mdash: '---', ndash: '--', hellip: '...',
-        laquo_space: '<< ', raquo_space: ' >>',
-        laquo: '<<', raquo: '>>'
-      }
-      def convert_typographic_sym(el, _opts)
-        TYPOGRAPHIC_SYMS[el.value]
-      end
-
-      def convert_smart_quote(el, _opts)
-        el.value.to_s =~ /[rl]dquo/ ? "\"" : "'"
-      end
-
-      def convert_math(el, _opts)
-        "$$#{el.value}$$" + (el.options[:category] == :block ? "\n" : '')
-      end
-
-      def convert_abbreviation(el, _opts)
-        el.value
-      end
-
-      def convert_root(el, opts)
-        res = inner(el, opts)
-        res << create_link_defs
-        res << create_footnote_defs
-        res << create_abbrev_defs
-        res
-      end
-
-      def create_link_defs
-        res = +''
-        res << "\n\n" unless @linkrefs.empty?
-        @linkrefs.each_with_index do |el, i|
-          title = parse_title(el.attr['title'])
-          res << "[#{i + 1}]: #{el.attr['href']}#{title}\n"
-        end
-        res
-      end
-
-      def create_footnote_defs
-        res = +''
-        @footnotes.each do |name, data|
-          res << "[^#{name}]:\n"
-          res << inner(data).chomp.split(/\n/).map {|l| "    #{l}" }.join("\n") + "\n\n"
-        end
-        res
-      end
-
-      def create_abbrev_defs
-        return '' unless @root.options[:abbrev_defs]
-        res = +''
-        @root.options[:abbrev_defs].each do |name, text|
-          res << "*[#{name}]: #{text}\n"
-          res << ial_for_element(Element.new(:unused, nil, @root.options[:abbrev_attr][name])).to_s << "\n\n"
-        end
-        res
-      end
-
-      # Return the IAL containing the attributes of the element +el+.
-      def ial_for_element(el)
-        res = el.attr.map do |k, v|
-          next if [:img, :a].include?(el.type) && ['href', 'src', 'alt', 'title'].include?(k)
-          next if el.type == :header && k == 'id' && !v.strip.empty?
-          if v.nil?
-            ''
-          elsif k == 'class' && !v.empty? && !v.index(/[\.#]/)
-            " " + v.split(/\s+/).map {|w| ".#{w}" }.join(" ")
-          elsif k == 'id' && !v.strip.empty?
-            " ##{v}"
-          else
-            " #{k}=\"#{v}\""
-          end
-        end.compact.join('')
-        res = "toc" + (res.strip.empty? ? '' : " #{res}") if (el.type == :ul || el.type == :ol) &&
-          el.options.dig(:ial, :refs)&.include?('toc')
-        res = "footnotes" + (res.strip.empty? ? '' : " #{res}") if (el.type == :ul || el.type == :ol) &&
-          el.options.dig(:ial, :refs)&.include?('footnotes')
-        if el.type == :dl && el.options[:ial] && el.options[:ial][:refs]
-          auto_ids = el.options[:ial][:refs].select {|ref| ref.start_with?('auto_ids') }.join(" ")
-          res = auto_ids << (res.strip.empty? ? '' : " #{res}") unless auto_ids.empty?
-        end
-        res.strip.empty? ? nil : "{:#{res}}"
-      end
-
-      def parse_title(attr)
-        attr.to_s.empty? ? '' : ' "' + attr.gsub(/"/, '&quot;') + '"'
-      end
-
-      # :startdoc:
-
-    end
-
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/converter/latex.rb

@@ -1,625 +0,0 @@
-# -*- coding: utf-8; frozen_string_literal: true -*-
-#
-#--
-# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-require 'set'
-require 'kramdown/converter'
-
-module Kramdown
-
-  module Converter
-
-    # Converts an element tree to LaTeX.
-    #
-    # This converter uses ideas from other Markdown-to-LaTeX converters like Pandoc and Maruku.
-    #
-    # You can customize this converter by sub-classing it and overriding the +convert_NAME+ methods.
-    # Each such method takes the following parameters:
-    #
-    # [+el+] The element of type +NAME+ to be converted.
-    #
-    # [+opts+] A hash containing processing options that are passed down from parent elements. The
-    #          key :parent is always set and contains the parent element as value.
-    #
-    # The return value of such a method has to be a string containing the element +el+ formatted
-    # correctly as LaTeX markup.
-    class Latex < Base
-
-      # Initialize the LaTeX converter with the +root+ element and the conversion +options+.
-      def initialize(root, options)
-        super
-        @data[:packages] = Set.new
-      end
-
-      # Dispatch the conversion of the element +el+ to a +convert_TYPE+ method using the +type+ of
-      # the element.
-      def convert(el, opts = {})
-        send("convert_#{el.type}", el, opts)
-      end
-
-      # Return the converted content of the children of +el+ as a string.
-      def inner(el, opts)
-        result = +''
-        options = opts.dup.merge(parent: el)
-        el.children.each_with_index do |inner_el, index|
-          options[:index] = index
-          options[:result] = result
-          result << send("convert_#{inner_el.type}", inner_el, options)
-        end
-        result
-      end
-
-      def convert_root(el, opts)
-        inner(el, opts)
-      end
-
-      def convert_blank(_el, opts)
-        opts[:result] =~ /\n\n\Z|\A\Z/ ? "" : "\n"
-      end
-
-      def convert_text(el, _opts)
-        escape(el.value)
-      end
-
-      def convert_p(el, opts)
-        if el.children.size == 1 && el.children.first.type == :img &&
-            !(img = convert_img(el.children.first, opts)).empty?
-          convert_standalone_image(el, opts, img)
-        else
-          "#{latex_link_target(el)}#{inner(el, opts)}\n\n"
-        end
-      end
-
-      # Helper method used by +convert_p+ to convert a paragraph that only contains a single :img
-      # element.
-      def convert_standalone_image(el, _opts, img)
-        attrs = attribute_list(el)
-        "\\begin{figure}#{attrs}\n\\begin{center}\n#{img}\n\\end{center}\n" \
-          "\\caption{#{escape(el.children.first.attr['alt'])}}\n" \
-          "#{latex_link_target(el, true)}\n\\end{figure}#{attrs}\n"
-      end
-
-      def convert_codeblock(el, _opts)
-        show_whitespace = el.attr['class'].to_s =~ /\bshow-whitespaces\b/
-        lang = extract_code_language(el.attr)
-
-        if @options[:syntax_highlighter] == :minted &&
-            (highlighted_code = highlight_code(el.value, lang, :block))
-          @data[:packages] << 'minted'
-          "#{latex_link_target(el)}#{highlighted_code}\n"
-        elsif show_whitespace || lang
-          options = []
-          options << (show_whitespace ? "showspaces=true,showtabs=true" : "showspaces=false,showtabs=false")
-          options << "language=#{lang}" if lang
-          options << "basicstyle=\\ttfamily\\footnotesize,columns=fixed,frame=tlbr"
-          id = el.attr['id']
-          options << "label=#{id}" if id
-          attrs = attribute_list(el)
-          "#{latex_link_target(el)}\\begin{lstlisting}[#{options.join(',')}]\n" \
-            "#{el.value}\n\\end{lstlisting}#{attrs}\n"
-        else
-          "#{latex_link_target(el)}\\begin{verbatim}#{el.value}\\end{verbatim}\n"
-        end
-      end
-
-      def convert_blockquote(el, opts)
-        latex_environment(el.children.size > 1 ? 'quotation' : 'quote', el, inner(el, opts))
-      end
-
-      def convert_header(el, opts)
-        type = @options[:latex_headers][output_header_level(el.options[:level]) - 1]
-        if ((id = el.attr['id']) ||
-            (@options[:auto_ids] && (id = generate_id(el.options[:raw_text])))) && in_toc?(el)
-          "\\#{type}{#{inner(el, opts)}}\\hypertarget{#{id}}{}\\label{#{id}}\n\n"
-        else
-          "\\#{type}*{#{inner(el, opts)}}\n\n"
-        end
-      end
-
-      def convert_hr(el, _opts)
-        attrs = attribute_list(el)
-        "#{latex_link_target(el)}\\begin{center}#{attrs}\n\\rule{3in}{0.4pt}\n\\end{center}#{attrs}\n"
-      end
-
-      def convert_ul(el, opts)
-        if !@data[:has_toc] && el.options.dig(:ial, :refs)&.include?('toc')
-          @data[:has_toc] = true
-          '\tableofcontents'
-        else
-          latex_environment(el.type == :ul ? 'itemize' : 'enumerate', el, inner(el, opts))
-        end
-      end
-      alias convert_ol convert_ul
-
-      def convert_dl(el, opts)
-        latex_environment('description', el, inner(el, opts))
-      end
-
-      def convert_li(el, opts)
-        "\\item{} #{latex_link_target(el, true)}#{inner(el, opts).sub(/\n+\Z/, '')}\n"
-      end
-
-      def convert_dt(el, opts)
-        "\\item[#{inner(el, opts)}] "
-      end
-
-      def convert_dd(el, opts)
-        "#{latex_link_target(el)}#{inner(el, opts)}\n\n"
-      end
-
-      def convert_html_element(el, opts)
-        if el.value == 'i' || el.value == 'em'
-          "\\emph{#{inner(el, opts)}}"
-        elsif el.value == 'b' || el.value == 'strong'
-          "\\textbf{#{inner(el, opts)}}"
-        else
-          warning("Can't convert HTML element")
-          ''
-        end
-      end
-
-      def convert_xml_comment(el, _opts)
-        el.value.split(/\n/).map {|l| "% #{l}" }.join("\n") + "\n"
-      end
-
-      def convert_xml_pi(_el, _opts)
-        warning("Can't convert XML PI")
-        ''
-      end
-
-      TABLE_ALIGNMENT_CHAR = {default: 'l', left: 'l', center: 'c', right: 'r'} # :nodoc:
-
-      def convert_table(el, opts)
-        @data[:packages] << 'longtable'
-        align = el.options[:alignment].map {|a| TABLE_ALIGNMENT_CHAR[a] }.join('|')
-        attrs = attribute_list(el)
-        "#{latex_link_target(el)}\\begin{longtable}{|#{align}|}#{attrs}\n" \
-          "\\hline\n#{inner(el, opts)}\\hline\n\\end{longtable}#{attrs}\n\n"
-      end
-
-      def convert_thead(el, opts)
-        "#{inner(el, opts)}\\hline\n"
-      end
-
-      def convert_tbody(el, opts)
-        inner(el, opts)
-      end
-
-      def convert_tfoot(el, opts)
-        "\\hline \\hline \n#{inner(el, opts)}"
-      end
-
-      def convert_tr(el, opts)
-        el.children.map {|c| send("convert_#{c.type}", c, opts) }.join(' & ') << "\\\\\n"
-      end
-
-      def convert_td(el, opts)
-        inner(el, opts)
-      end
-
-      def convert_comment(el, _opts)
-        el.value.split(/\n/).map {|l| "% #{l}" }.join("\n") << "\n"
-      end
-
-      def convert_br(_el, opts)
-        res = +"\\newline"
-        res << "\n" if (c = opts[:parent].children[opts[:index] + 1]) &&
-          (c.type != :text || c.value !~ /^\s*\n/)
-        res
-      end
-
-      def convert_a(el, opts)
-        url = el.attr['href']
-        if url.start_with?('#')
-          "\\hyperlink{#{url[1..-1].gsub('%', '\\%')}}{#{inner(el, opts)}}"
-        else
-          "\\href{#{url.gsub('%', '\\%')}}{#{inner(el, opts)}}"
-        end
-      end
-
-      def convert_img(el, _opts)
-        line = el.options[:location]
-        if el.attr['src'] =~ /^(https?|ftps?):\/\//
-          warning("Cannot include non-local image#{line ? " (line #{line})" : ''}")
-          ''
-        elsif !el.attr['src'].empty?
-          @data[:packages] << 'graphicx'
-          "#{latex_link_target(el)}\\includegraphics{#{el.attr['src']}}"
-        else
-          warning("Cannot include image with empty path#{line ? " (line #{line})" : ''}")
-          ''
-        end
-      end
-
-      def convert_codespan(el, _opts)
-        lang = extract_code_language(el.attr)
-        if @options[:syntax_highlighter] == :minted &&
-            (highlighted_code = highlight_code(el.value, lang, :span))
-          @data[:packages] << 'minted'
-          "#{latex_link_target(el)}#{highlighted_code}"
-        else
-          "\\texttt{#{latex_link_target(el)}#{escape(el.value)}}"
-        end
-      end
-
-      def convert_footnote(el, opts)
-        @data[:packages] << 'fancyvrb'
-        "\\footnote{#{inner(el.value, opts).rstrip}}"
-      end
-
-      def convert_raw(el, _opts)
-        if !el.options[:type] || el.options[:type].empty? || el.options[:type].include?('latex')
-          el.value + (el.options[:category] == :block ? "\n" : '')
-        else
-          ''
-        end
-      end
-
-      def convert_em(el, opts)
-        "\\emph{#{latex_link_target(el)}#{inner(el, opts)}}"
-      end
-
-      def convert_strong(el, opts)
-        "\\textbf{#{latex_link_target(el)}#{inner(el, opts)}}"
-      end
-
-      # Inspired by Maruku: entity conversion table based on the one from htmltolatex
-      # (http://sourceforge.net/projects/htmltolatex/), with some small adjustments/additions
-      ENTITY_CONV_TABLE = {
-        913 => ['$A$'],
-        914 => ['$B$'],
-        915 => ['$\Gamma$'],
-        916 => ['$\Delta$'],
-        917 => ['$E$'],
-        918 => ['$Z$'],
-        919 => ['$H$'],
-        920 => ['$\Theta$'],
-        921 => ['$I$'],
-        922 => ['$K$'],
-        923 => ['$\Lambda$'],
-        924 => ['$M$'],
-        925 => ['$N$'],
-        926 => ['$\Xi$'],
-        927 => ['$O$'],
-        928 => ['$\Pi$'],
-        929 => ['$P$'],
-        931 => ['$\Sigma$'],
-        932 => ['$T$'],
-        933 => ['$Y$'],
-        934 => ['$\Phi$'],
-        935 => ['$X$'],
-        936 => ['$\Psi$'],
-        937 => ['$\Omega$'],
-        945 => ['$\alpha$'],
-        946 => ['$\beta$'],
-        947 => ['$\gamma$'],
-        948 => ['$\delta$'],
-        949 => ['$\epsilon$'],
-        950 => ['$\zeta$'],
-        951 => ['$\eta$'],
-        952 => ['$\theta$'],
-        953 => ['$\iota$'],
-        954 => ['$\kappa$'],
-        955 => ['$\lambda$'],
-        956 => ['$\mu$'],
-        957 => ['$\nu$'],
-        958 => ['$\xi$'],
-        959 => ['$o$'],
-        960 => ['$\pi$'],
-        961 => ['$\rho$'],
-        963 => ['$\sigma$'],
-        964 => ['$\tau$'],
-        965 => ['$\upsilon$'],
-        966 => ['$\phi$'],
-        967 => ['$\chi$'],
-        968 => ['$\psi$'],
-        969 => ['$\omega$'],
-        962 => ['$\varsigma$'],
-        977 => ['$\vartheta$'],
-        982 => ['$\varpi$'],
-        8230 => ['\ldots'],
-        8242 => ['$\prime$'],
-        8254 => ['-'],
-        8260 => ['/'],
-        8472 => ['$\wp$'],
-        8465 => ['$\Im$'],
-        8476 => ['$\Re$'],
-        8501 => ['$\aleph$'],
-        8226 => ['$\bullet$'],
-        8482 => ['$^{\rm TM}$'],
-        8592 => ['$\leftarrow$'],
-        8594 => ['$\rightarrow$'],
-        8593 => ['$\uparrow$'],
-        8595 => ['$\downarrow$'],
-        8596 => ['$\leftrightarrow$'],
-        8629 => ['$\hookleftarrow$'],
-        8657 => ['$\Uparrow$'],
-        8659 => ['$\Downarrow$'],
-        8656 => ['$\Leftarrow$'],
-        8658 => ['$\Rightarrow$'],
-        8660 => ['$\Leftrightarrow$'],
-        8704 => ['$\forall$'],
-        8706 => ['$\partial$'],
-        8707 => ['$\exists$'],
-        8709 => ['$\emptyset$'],
-        8711 => ['$\nabla$'],
-        8712 => ['$\in$'],
-        8715 => ['$\ni$'],
-        8713 => ['$\notin$'],
-        8721 => ['$\sum$'],
-        8719 => ['$\prod$'],
-        8722 => ['$-$'],
-        8727 => ['$\ast$'],
-        8730 => ['$\surd$'],
-        8733 => ['$\propto$'],
-        8734 => ['$\infty$'],
-        8736 => ['$\angle$'],
-        8743 => ['$\wedge$'],
-        8744 => ['$\vee$'],
-        8745 => ['$\cap$'],
-        8746 => ['$\cup$'],
-        8747 => ['$\int$'],
-        8756 => ['$\therefore$', 'amssymb'],
-        8764 => ['$\sim$'],
-        8776 => ['$\approx$'],
-        8773 => ['$\cong$'],
-        8800 => ['$\neq$'],
-        8801 => ['$\equiv$'],
-        8804 => ['$\leq$'],
-        8805 => ['$\geq$'],
-        8834 => ['$\subset$'],
-        8835 => ['$\supset$'],
-        8838 => ['$\subseteq$'],
-        8839 => ['$\supseteq$'],
-        8836 => ['$\nsubset$', 'amssymb'],
-        8853 => ['$\oplus$'],
-        8855 => ['$\otimes$'],
-        8869 => ['$\perp$'],
-        8901 => ['$\cdot$'],
-        8968 => ['$\rceil$'],
-        8969 => ['$\lceil$'],
-        8970 => ['$\lfloor$'],
-        8971 => ['$\rfloor$'],
-        9001 => ['$\rangle$'],
-        9002 => ['$\langle$'],
-        9674 => ['$\lozenge$', 'amssymb'],
-        9824 => ['$\spadesuit$'],
-        9827 => ['$\clubsuit$'],
-        9829 => ['$\heartsuit$'],
-        9830 => ['$\diamondsuit$'],
-        38 => ['\&'],
-        34 => ['"'],
-        39 => ['\''],
-        169 => ['\copyright'],
-        60 => ['\textless'],
-        62 => ['\textgreater'],
-        338 => ['\OE'],
-        339 => ['\oe'],
-        352 => ['\v{S}'],
-        353 => ['\v{s}'],
-        376 => ['\"Y'],
-        710 => ['\textasciicircum'],
-        732 => ['\textasciitilde'],
-        8211 => ['--'],
-        8212 => ['---'],
-        8216 => ['`'],
-        8217 => ['\''],
-        8220 => ['``'],
-        8221 => ['\'\''],
-        8224 => ['\dag'],
-        8225 => ['\ddag'],
-        8240 => ['\permil', 'wasysym'],
-        8364 => ['\euro', 'eurosym'],
-        8249 => ['\guilsinglleft'],
-        8250 => ['\guilsinglright'],
-        8218 => ['\quotesinglbase', 'mathcomp'],
-        8222 => ['\quotedblbase', 'mathcomp'],
-        402 => ['\textflorin', 'mathcomp'],
-        381 => ['\v{Z}'],
-        382 => ['\v{z}'],
-        160 => ['~'],
-        161 => ['\textexclamdown'],
-        163 => ['\pounds'],
-        164 => ['\currency', 'wasysym'],
-        165 => ['\textyen', 'textcomp'],
-        166 => ['\brokenvert', 'wasysym'],
-        167 => ['\S'],
-        171 => ['\guillemotleft'],
-        187 => ['\guillemotright'],
-        174 => ['\textregistered'],
-        170 => ['\textordfeminine'],
-        172 => ['$\neg$'],
-        173 => ['\-'],
-        176 => ['$\degree$', 'mathabx'],
-        177 => ['$\pm$'],
-        180 => ['\''],
-        181 => ['$\mu$'],
-        182 => ['\P'],
-        183 => ['$\cdot$'],
-        186 => ['\textordmasculine'],
-        162 => ['\cent', 'wasysym'],
-        185 => ['$^1$'],
-        178 => ['$^2$'],
-        179 => ['$^3$'],
-        189 => ['$\frac{1}{2}$'],
-        188 => ['$\frac{1}{4}$'],
-        190 => ['$\frac{3}{4}'],
-        192 => ['\`A'],
-        193 => ['\\\'A'],
-        194 => ['\^A'],
-        195 => ['\~A'],
-        196 => ['\"A'],
-        197 => ['\AA'],
-        198 => ['\AE'],
-        199 => ['\cC'],
-        200 => ['\`E'],
-        201 => ['\\\'E'],
-        202 => ['\^E'],
-        203 => ['\"E'],
-        204 => ['\`I'],
-        205 => ['\\\'I'],
-        206 => ['\^I'],
-        207 => ['\"I'],
-        208 => ['$\eth$', 'amssymb'],
-        209 => ['\~N'],
-        210 => ['\`O'],
-        211 => ['\\\'O'],
-        212 => ['\^O'],
-        213 => ['\~O'],
-        214 => ['\"O'],
-        215 => ['$\times$'],
-        216 => ['\O'],
-        217 => ['\`U'],
-        218 => ['\\\'U'],
-        219 => ['\^U'],
-        220 => ['\"U'],
-        221 => ['\\\'Y'],
-        222 => ['\Thorn', 'wasysym'],
-        223 => ['\ss'],
-        224 => ['\`a'],
-        225 => ['\\\'a'],
-        226 => ['\^a'],
-        227 => ['\~a'],
-        228 => ['\"a'],
-        229 => ['\aa'],
-        230 => ['\ae'],
-        231 => ['\cc'],
-        232 => ['\`e'],
-        233 => ['\\\'e'],
-        234 => ['\^e'],
-        235 => ['\"e'],
-        236 => ['\`i'],
-        237 => ['\\\'i'],
-        238 => ['\^i'],
-        239 => ['\"i'],
-        240 => ['$\eth$'],
-        241 => ['\~n'],
-        242 => ['\`o'],
-        243 => ['\\\'o'],
-        244 => ['\^o'],
-        245 => ['\~o'],
-        246 => ['\"o'],
-        247 => ['$\divide$'],
-        248 => ['\o'],
-        249 => ['\`u'],
-        250 => ['\\\'u'],
-        251 => ['\^u'],
-        252 => ['\"u'],
-        253 => ['\\\'y'],
-        254 => ['\thorn', 'wasysym'],
-        255 => ['\"y'],
-        8201 => ['\thinspace'],
-        8194 => ['\hskip .5em\relax'],
-        8195 => ['\quad'],
-      } # :nodoc:
-      ENTITY_CONV_TABLE.each_value {|v| v[0] = "{}#{v[0]}" }
-
-      def entity_to_latex(entity)
-        text, package = ENTITY_CONV_TABLE[entity.code_point]
-        if text
-          @data[:packages] << package if package
-          text
-        else
-          warning("Couldn't find entity with code #{entity.code_point} in substitution table!")
-          ''
-        end
-      end
-
-      def convert_entity(el, _opts)
-        entity_to_latex(el.value)
-      end
-
-      TYPOGRAPHIC_SYMS = {
-        mdash: '---', ndash: '--', hellip: '\ldots{}',
-        laquo_space: '\guillemotleft{}~', raquo_space: '~\guillemotright{}',
-        laquo: '\guillemotleft{}', raquo: '\guillemotright{}'
-      } # :nodoc:
-      def convert_typographic_sym(el, _opts)
-        if (result = @options[:typographic_symbols][el.value])
-          escape(result)
-        else
-          TYPOGRAPHIC_SYMS[el.value]
-        end
-      end
-
-      def convert_smart_quote(el, opts)
-        res = entity_to_latex(smart_quote_entity(el)).chomp('{}')
-        res << "{}" if ((nel = opts[:parent].children[opts[:index] + 1]) && nel.type == :smart_quote) || res =~ /\w$/
-        res
-      end
-
-      def convert_math(el, _opts)
-        @data[:packages] += %w[amssymb amsmath amsthm amsfonts]
-        if el.options[:category] == :block
-          if el.value =~ /\A\s*\\begin\{/
-            el.value
-          else
-            latex_environment('displaymath', el, el.value)
-          end
-        else
-          "$#{el.value}$"
-        end
-      end
-
-      def convert_abbreviation(el, _opts)
-        @data[:packages] += %w[acronym]
-        "\\ac{#{normalize_abbreviation_key(el.value)}}"
-      end
-
-      # Normalize the abbreviation key so that it only contains allowed ASCII character
-      def normalize_abbreviation_key(key)
-        key.gsub(/\W/) {|m| m.unpack('H*').first }
-      end
-
-      # Wrap the +text+ inside a LaTeX environment of type +type+. The element +el+ is passed on to
-      # the method #attribute_list -- the resulting string is appended to both the \\begin and the
-      # \\end lines of the LaTeX environment for easier post-processing of LaTeX environments.
-      def latex_environment(type, el, text)
-        attrs = attribute_list(el)
-        "\\begin{#{type}}#{latex_link_target(el)}#{attrs}\n#{text.rstrip}\n\\end{#{type}}#{attrs}\n"
-      end
-
-      # Return a string containing a valid \hypertarget command if the element has an ID defined, or
-      # +nil+ otherwise. If the parameter +add_label+ is +true+, a \label command will also be used
-      # additionally to the \hypertarget command.
-      def latex_link_target(el, add_label = false)
-        if (id = el.attr['id'])
-          "\\hypertarget{#{id}}{}#{add_label ? "\\label{#{id}}" : ''}"
-        else
-          nil
-        end
-      end
-
-      # Return a LaTeX comment containing all attributes as 'key="value"' pairs.
-      def attribute_list(el)
-        attrs = el.attr.map {|k, v| v.nil? ? '' : " #{k}=\"#{v}\"" }.compact.sort.join('')
-        attrs = "   % #{attrs}" unless attrs.empty?
-        attrs
-      end
-
-      ESCAPE_MAP = {
-        "^"  => "\\^{}",
-        "\\" => "\\textbackslash{}",
-        "~"  => "\\ensuremath{\\sim}",
-        "|"  => "\\textbar{}",
-        "<"  => "\\textless{}",
-        ">"  => "\\textgreater{}",
-        "["  => "{[}",
-        "]"  => "{]}",
-      }.merge(Hash[*("{}$%&_#".each_char.map {|c| [c, "\\#{c}"] }.flatten)]) # :nodoc:
-      ESCAPE_RE = Regexp.union(*ESCAPE_MAP.collect {|k, _v| k }) # :nodoc:
-
-      # Escape the special LaTeX characters in the string +str+.
-      def escape(str)
-        str.gsub(ESCAPE_RE) {|m| ESCAPE_MAP[m] }
-      end
-
-    end
-
-  end
-end