asciidoctor 1.5.5 → 1.5.6

data/lib/asciidoctor/section.rb

@@ -24,10 +24,6 @@ class Section < AbstractBlock
   # Public: Get/Set the 0-based index order of this section within the parent block
   attr_accessor :index
 
-  # Public: Get/Set the number of this section within the parent block
-  # Only relevant if the attribute numbered is true
-  attr_accessor :number
-
   # Public: Get/Set the section name of this section
   attr_accessor :sectname
 
@@ -37,16 +33,15 @@ class Section < AbstractBlock
   # Public: Get the state of the numbered attribute at this section (need to preserve for creating TOC)
   attr_accessor :numbered
 
+  # Public: Get the caption for this section (only relevant for appendices)
+  attr_reader :caption
+
   # Public: Initialize an Asciidoctor::Section object.
   #
   # parent - The parent Asciidoc Object.
   def initialize parent = nil, level = nil, numbered = true, opts = {}
     super parent, :section, opts
-    if level
-      @level = level
-    else
-      @level = parent ? (parent.level + 1) : 1
-    end
+    @level = level ? level : (parent ? (parent.level + 1) : 1)
     @numbered = numbered && @level > 0
     @special = parent && parent.context == :section && parent.special
     @index = 0
@@ -54,54 +49,13 @@ class Section < AbstractBlock
   end
 
   # Public: The name of this section, an alias of the section title
-  alias :name :title
+  alias name title
 
-  # Public: Generate a String id for this section.
-  #
-  # The generated id is prefixed with value of the 'idprefix' attribute, which
-  # is an underscore by default.
-  #
-  # Section id synthesis can be disabled by undefining the 'sectids' attribute.
+  # Public: Generate a String ID from the title of this section.
   #
-  # If the generated id is already in use in the document, a count is appended
-  # until a unique id is found.
-  #
-  # Examples
-  #
-  #   section = Section.new(parent)
-  #   section.title = "Foo"
-  #   section.generate_id
-  #   => "_foo"
-  #
-  #   another_section = Section.new(parent)
-  #   another_section.title = "Foo"
-  #   another_section.generate_id
-  #   => "_foo_1"
-  #
-  #   yet_another_section = Section.new(parent)
-  #   yet_another_section.title = "Ben & Jerry"
-  #   yet_another_section.generate_id
-  #   => "_ben_jerry"
+  # See Section.generate_id for details.
   def generate_id
-    if @document.attributes.has_key? 'sectids'
-      sep = @document.attributes['idseparator'] || '_'
-      pre = @document.attributes['idprefix'] || '_'
-      base_id = %(#{pre}#{title.downcase.gsub(InvalidSectionIdCharsRx, sep).tr_s(sep, sep).chomp(sep)})
-      # ensure id doesn't begin with idseparator if idprefix is empty and idseparator is not empty
-      if pre.empty? && !sep.empty? && base_id.start_with?(sep)
-        base_id = base_id[1..-1]
-        base_id = base_id[1..-1] while base_id.start_with?(sep)
-      end
-      gen_id = base_id
-      cnt = Compliance.unique_id_start_index
-      while @document.references[:ids].has_key? gen_id
-        gen_id = %(#{base_id}#{sep}#{cnt})
-        cnt += 1
-      end
-      gen_id
-    else
-      nil
-    end
+    Section.generate_id title, @document
   end
 
   # Public: Get the section number for the current Section
@@ -156,6 +110,41 @@ class Section < AbstractBlock
     end
   end
 
+  # (see AbstractBlock#xreftext)
+  def xreftext xrefstyle = nil
+    if (val = reftext) && !val.empty?
+      val
+    elsif xrefstyle
+      if @numbered
+        case xrefstyle
+        when 'full'
+          if (type = @sectname) == 'chapter' || type == 'appendix'
+            quoted_title = sprintf sub_quotes('_%s_'), title
+          else
+            quoted_title = sprintf sub_quotes(@document.compat_mode ? %q(``%s'') : '"`%s`"'), title
+          end
+          if (signifier = @document.attributes[%(#{type}-refsig)])
+            %(#{signifier} #{sectnum '.', ','} #{quoted_title})
+          else
+            %(#{sectnum '.', ','} #{quoted_title})
+          end
+        when 'short'
+          if (signifier = @document.attributes[%(#{@sectname}-refsig)])
+            %(#{signifier} #{sectnum '.', ''})
+          else
+            sectnum '.', ''
+          end
+        else # 'basic'
+          (type = @sectname) == 'chapter' || type == 'appendix' ? (sprintf sub_quotes('_%s_'), title) : title
+        end
+      else # apply basic styling
+        (type = @sectname) == 'chapter' || type == 'appendix' ? (sprintf sub_quotes('_%s_'), title) : title
+      end
+    else
+      title
+    end
+  end
+
   # Public: Append a content block to this block's list of blocks.
   #
   # If the child block is a Section, assign an index to it.
@@ -164,17 +153,56 @@ class Section < AbstractBlock
   #
   # Returns The parent Block
   def << block
-    assign_index block if block.context == :section
+    enumerate_section block if block.context == :section
     super
   end
 
   def to_s
-    if @title != nil
-      qualified_title = @numbered ? %(#{sectnum} #{@title}) : @title
-      %(#<#{self.class}@#{object_id} {level: #{@level}, title: #{qualified_title.inspect}, blocks: #{@blocks.size}}>)
+    if @title
+      formal_title = @numbered ? %(#{sectnum} #{@title}) : @title
+      %(#<#{self.class}@#{object_id} {level: #{@level}, title: #{formal_title.inspect}, blocks: #{@blocks.size}}>)
     else
       super
     end
   end
+
+  # Public: Generate a String ID from the given section title.
+  #
+  # The generated ID is prefixed with value of the 'idprefix' attribute, which
+  # is an underscore by default. Invalid characters are replaced with the
+  # value of the 'idseparator' attribute, which is an underscore by default.
+  #
+  # If the generated ID is already in use in the document, a count is appended
+  # until a unique id is found.
+  #
+  # Section ID generation can be disabled by undefining the 'sectids' attribute.
+  #
+  # Examples
+  #
+  #   Section.generate_id 'Foo', document
+  #   => "_foo"
+  #
+  def self.generate_id title, document
+    attrs = document.attributes
+    sep = attrs['idseparator'] || '_'
+    pre = attrs['idprefix'] || '_'
+    gen_id = %(#{pre}#{title.downcase.gsub InvalidSectionIdCharsRx, sep})
+    unless sep.empty?
+      # remove repeat and trailing separator characters
+      gen_id = gen_id.tr_s sep, sep
+      gen_id = gen_id.chop if gen_id.end_with? sep
+      # ensure id doesn't begin with idseparator if idprefix is empty and idseparator is not empty
+      if pre.empty?
+        gen_id = gen_id.slice 1, gen_id.length while gen_id.start_with? sep
+      end
+    end
+    if document.catalog[:ids].key? gen_id
+      ids, cnt = document.catalog[:ids], Compliance.unique_id_start_index
+      cnt += 1 while ids.key?(candidate_id = %(#{gen_id}#{sep}#{cnt}))
+      candidate_id
+    else
+      gen_id
+    end
+  end
 end
 end

data/lib/asciidoctor/stylesheets.rb

@@ -32,8 +32,8 @@ class Stylesheets
 </style>)
   end
 
-  def write_primary_stylesheet target_dir
-    ::File.open(::File.join(target_dir, primary_stylesheet_name), 'w') {|f| f.write primary_stylesheet_data }
+  def write_primary_stylesheet target_dir = '.'
+    ::IO.write(::File.join(target_dir, primary_stylesheet_name), primary_stylesheet_data)
   end
 
   def coderay_stylesheet_name
@@ -57,8 +57,8 @@ class Stylesheets
 </style>)
   end
 
-  def write_coderay_stylesheet target_dir
-    ::File.open(::File.join(target_dir, coderay_stylesheet_name), 'w') {|f| f.write coderay_stylesheet_data }
+  def write_coderay_stylesheet target_dir = '.'
+    ::IO.write(::File.join(target_dir, coderay_stylesheet_name), coderay_stylesheet_data)
   end
 
   def pygments_stylesheet_name style = nil
@@ -84,8 +84,8 @@ class Stylesheets
 </style>)
   end
 
-  def write_pygments_stylesheet target_dir, style = nil
-    ::File.open(::File.join(target_dir, pygments_stylesheet_name(style)), 'w') {|f| f.write pygments_stylesheet_data(style) }
+  def write_pygments_stylesheet target_dir = '.', style = nil
+    ::IO.write(::File.join(target_dir, pygments_stylesheet_name(style)), pygments_stylesheet_data(style))
   end
 
   #def load_coderay

data/lib/asciidoctor/substitutors.rb

@@ -4,34 +4,28 @@ module Asciidoctor
 # is intented to be mixed-in to Section and Block to provide operations for performing
 # the necessary substitutions.
 module Substitutors
-
-  SPECIAL_CHARS = {
-    '&' => '&',
-    '<' => '&lt;',
-    '>' => '&gt;'
-  }
-
-  SPECIAL_CHARS_PATTERN = /[#{SPECIAL_CHARS.keys.join}]/
-
-  SUBS = {
-    :basic    => [:specialcharacters],
-    :normal   => [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements],
-    :verbatim => [:specialcharacters, :callouts],
-    :title    => [:specialcharacters, :quotes, :replacements, :macros, :attributes, :post_replacements],
-    :header   => [:specialcharacters, :attributes],
-    # by default, AsciiDoc performs :attributes and :macros on a pass block
-    # TODO make this a compliance setting
-    :pass     => []
+  SpecialCharsRx = /[<&>]/
+  SpecialCharsTr = { '>' => '&gt;', '<' => '&lt;', '&' => '&amp;' }
+
+  # Detects if text is a possible candidate for the quotes substitution.
+  QuotedTextSniffRx = { false => /[*_`#^~]/, true => /[*'_+#^~]/ }
+
+  (BASIC_SUBS = [:specialcharacters]).freeze
+  (HEADER_SUBS = [:specialcharacters, :attributes]).freeze
+  (NORMAL_SUBS = [:specialcharacters, :quotes, :attributes, :replacements, :macros, :post_replacements]).freeze
+  (NONE_SUBS = []).freeze
+  (TITLE_SUBS = [:specialcharacters, :quotes, :replacements, :macros, :attributes, :post_replacements]).freeze
+  (REFTEXT_SUBS = [:specialcharacters, :quotes, :replacements]).freeze
+  (VERBATIM_SUBS = [:specialcharacters, :callouts]).freeze
+
+  SUB_GROUPS = {
+    :none => NONE_SUBS,
+    :normal => NORMAL_SUBS,
+    :verbatim => VERBATIM_SUBS,
+    :specialchars => BASIC_SUBS
   }
 
-  COMPOSITE_SUBS = {
-    :none => [],
-    :normal => SUBS[:normal],
-    :verbatim => SUBS[:verbatim],
-    :specialchars => [:specialcharacters]
-  }
-
-  SUB_SYMBOLS = {
+  SUB_HINTS = {
     :a => :attributes,
     :m => :macros,
     :n => :normal,
@@ -43,8 +37,8 @@ module Substitutors
   }
 
   SUB_OPTIONS = {
-    :block  => COMPOSITE_SUBS.keys + SUBS[:normal] + [:callouts],
-    :inline => COMPOSITE_SUBS.keys + SUBS[:normal]
+    :block  => SUB_GROUPS.keys + NORMAL_SUBS + [:callouts],
+    :inline => SUB_GROUPS.keys + NORMAL_SUBS
   }
 
   SUB_HIGHLIGHT = ['coderay', 'pygments']
@@ -53,52 +47,63 @@ module Substitutors
   # See http://www.aivosto.com/vbtips/control-characters.html#listabout for characters to use
 
   # SPA, start of guarded protected area (\u0096)
-  PASS_START = "\u0096"
+  PASS_START = %(\u0096)
 
   # EPA, end of guarded protected area (\u0097)
-  PASS_END = "\u0097"
+  PASS_END = %(\u0097)
+
+  # match passthrough slot
+  PassSlotRx = /#{PASS_START}(\d+)#{PASS_END}/
+
+  # fix passthrough slot after syntax highlighting
+  HighlightedPassSlotRx = %r(<span\b[^>]*>#{PASS_START}</span>[^\d]*(\d+)[^\d]*<span\b[^>]*>#{PASS_END}</span>)
 
-  # match placeholder record
-  PASS_MATCH = /\u0096(\d+)\u0097/
+  RS = '\\'
 
-  # fix placeholder record after syntax highlighting
-  PASS_MATCH_HI = /<span[^>]*>\u0096<\/span>[^\d]*(\d+)[^\d]*<span[^>]*>\u0097<\/span>/
+  R_SB = ']'
+
+  ESC_R_SB = '\]'
+
+  PLUS = '+'
+
+  PygmentsWrapperDivRx = %r(<div class="pyhl">(.*)</div>)m
+  # NOTE handles all permutations of <pre> wrapper
+  # NOTE trailing whitespace appears when pygments-linenums-mode=table; <pre> has style attribute when pygments-css=inline
+  PygmentsWrapperPreRx = %r(<pre\b[^>]*?>(.*?)</pre>\s*)m
 
   # Internal: A String Array of passthough (unprocessed) text captured from this block
   attr_reader :passthroughs
 
-  # Public: Apply the specified substitutions to the lines of text
+  # Public: Apply the specified substitutions to the source.
   #
-  # source  - The String or String Array of text to process
-  # subs    - The substitutions to perform. Can be a Symbol or a Symbol Array (default: :normal)
-  # expand -  A Boolean to control whether sub aliases are expanded (default: true)
+  # source  - The String or String Array of text to process; must not be nil.
+  # subs    - The substitutions to perform; can be a Symbol or Symbol Array; must not be nil (default: :normal).
+  # expand  - A Boolean to control whether substitution aliases are expanded (default: false).
   #
-  # returns Either a String or String Array, whichever matches the type of the first argument
-  def apply_subs source, subs = :normal, expand = false
-    if !subs
+  # Returns a String or String Array with substitutions applied, matching the type of source argument.
+  def apply_subs source, subs = NORMAL_SUBS, expand = false
+    if source.empty? || subs.empty?
       return source
-    elsif subs == :normal
-      subs = SUBS[:normal]
     elsif expand
       if ::Symbol === subs
-        subs = COMPOSITE_SUBS[subs] || [subs]
+        subs = SUB_GROUPS[subs] || [subs]
       else
         effective_subs = []
         subs.each do |key|
-          if COMPOSITE_SUBS.has_key? key
-            effective_subs += COMPOSITE_SUBS[key]
+          if (sub_group = SUB_GROUPS[key])
+            effective_subs += sub_group unless sub_group.empty?
           else
             effective_subs << key
           end
         end
 
-        subs = effective_subs
+        if (subs = effective_subs).empty?
+          return source
+        end
       end
     end
 
-    return source if subs.empty?
-
-    text = (multiline = ::Array === source) ? source * EOL : source
+    text = (multiline = ::Array === source) ? source * LF : source
 
     if (has_passthroughs = subs.include? :macros)
       text = extract_passthroughs text
@@ -112,7 +117,7 @@ module Substitutors
       when :quotes
         text = sub_quotes text
       when :attributes
-        text = sub_attributes(text.split EOL) * EOL
+        text = sub_attributes(text.split LF, -1) * LF if text.include? '{'
       when :replacements
         text = sub_replacements text
       when :macros
@@ -129,16 +134,18 @@ module Substitutors
     end
     text = restore_passthroughs text if has_passthroughs
 
-    multiline ? (text.split EOL) : text
+    multiline ? (text.split LF, -1) : text
   end
 
   # Public: Apply normal substitutions.
   #
-  # lines  - The lines of text to process. Can be a String or a String Array
+  # An alias for apply_subs with default remaining arguments.
+  #
+  # text  - The String text to which to apply normal substitutions
   #
-  # returns - A String with normal substitutions performed
-  def apply_normal_subs(lines)
-    apply_subs(::Array === lines ? lines * EOL : lines)
+  # Returns the String with normal substitutions applied.
+  def apply_normal_subs text
+    apply_subs text
   end
 
   # Public: Apply substitutions for titles.
@@ -147,7 +154,16 @@ module Substitutors
   #
   # returns - A String with title substitutions performed
   def apply_title_subs(title)
-    apply_subs title, SUBS[:title]
+    apply_subs title, TITLE_SUBS
+  end
+
+  # Public: Apply substitutions for reftext.
+  #
+  # text - The String to process
+  #
+  # Returns a String with all substitutions from the reftext substitution group applied
+  def apply_reftext_subs text
+    apply_subs text, REFTEXT_SUBS
   end
 
   # Public: Apply substitutions for header metadata and attribute assignments
@@ -156,7 +172,7 @@ module Substitutors
   #
   # returns - A String with header substitutions performed
   def apply_header_subs(text)
-    apply_subs text, SUBS[:header]
+    apply_subs text, HEADER_SUBS
   end
 
   # Internal: Extract the passthrough text from the document for reinsertion after processing.
@@ -166,19 +182,12 @@ module Substitutors
   # returns - The text with the passthrough region substituted with placeholders
   def extract_passthroughs(text)
     compat_mode = @document.compat_mode
-    text = text.gsub(PassInlineMacroRx) {
+    text = text.gsub(InlinePassMacroRx) {
       # alias match for Ruby 1.8.7 compat
       m = $~
       preceding = nil
 
-      if (boundary = m[4]).nil_or_empty? # pass:[]
-        if m[6] == '\\'
-          # NOTE we don't look for nested pass:[] macros
-          next m[0][1..-1]
-        end
-
-        @passthroughs[pass_key = @passthroughs.size] = {:text => (unescape_brackets m[8]), :subs => (m[7].nil_or_empty? ? [] : (resolve_pass_subs m[7]))}
-      else # $$, ++ or +++
+      if (boundary = m[4]) # $$, ++, or +++
         # skip ++ in compat mode, handled as normal quoted text
         if compat_mode && boundary == '++'
           next m[2].nil_or_empty? ?
@@ -187,22 +196,15 @@ module Substitutors
         end
 
         attributes = m[2]
-
-        # fix non-matching group results in Opal under Firefox
-        if ::RUBY_ENGINE_OPAL
-          attributes = nil if attributes == ''
-        end
-
-        escape_count = m[3].size
+        escape_count = m[3].length
         content = m[5]
         old_behavior = false
 
         if attributes
           if escape_count > 0
             # NOTE we don't look for nested unconstrained pass macros
-            # must enclose string following next in " for Opal
-            next "#{m[1]}[#{attributes}]#{'\\' * (escape_count - 1)}#{boundary}#{m[5]}#{boundary})"
-          elsif m[1] == '\\'
+            next %(#{m[1]}[#{attributes}]#{RS * (escape_count - 1)}#{boundary}#{m[5]}#{boundary})
+          elsif m[1] == RS
             preceding = %([#{attributes}])
             attributes = nil
           else
@@ -214,21 +216,27 @@ module Substitutors
           end
         elsif escape_count > 0
           # NOTE we don't look for nested unconstrained pass macros
-          # must enclose string following next in " for Opal
-          next "#{m[1]}[#{attributes}]#{'\\' * (escape_count - 1)}#{boundary}#{m[5]}#{boundary}"
+          next %(#{RS * (escape_count - 1)}#{boundary}#{m[5]}#{boundary})
         end
-        subs = (boundary == '+++' ? [] : [:specialcharacters])
+        subs = (boundary == '+++' ? [] : BASIC_SUBS)
 
         pass_key = @passthroughs.size
         if attributes
           if old_behavior
-            @passthroughs[pass_key] = {:text => content, :subs => SUBS[:normal], :type => :monospaced, :attributes => attributes}
+            @passthroughs[pass_key] = {:text => content, :subs => NORMAL_SUBS, :type => :monospaced, :attributes => attributes}
           else
             @passthroughs[pass_key] = {:text => content, :subs => subs, :type => :unquoted, :attributes => attributes}
           end
         else
           @passthroughs[pass_key] = {:text => content, :subs => subs}
         end
+      else # pass:[]
+        if m[6] == RS
+          # NOTE we don't look for nested pass:[] macros
+          next m[0][1..-1]
+        end
+
+        @passthroughs[pass_key = @passthroughs.size] = {:text => (unescape_brackets m[8]), :subs => (m[7] ? (resolve_pass_subs m[7]) : [])}
       end
 
       %(#{preceding}#{PASS_START}#{pass_key}#{PASS_END})
@@ -240,15 +248,10 @@ module Substitutors
       m = $~
       preceding = m[1]
       attributes = m[2]
-      escape_mark = (m[3].start_with? '\\') ? '\\' : nil
+      escape_mark = RS if m[3].start_with? RS
       format_mark = m[4]
       content = m[5]
 
-      # fix non-matching group results in Opal under Firefox
-      if ::RUBY_ENGINE_OPAL
-        attributes = nil if attributes == ''
-      end
-
       if compat_mode
         old_behavior = true
       else
@@ -259,14 +262,13 @@ module Substitutors
 
       if attributes
         if format_mark == '`' && !old_behavior
-          # must enclose string following next in " for Opal
-          next "#{preceding}[#{attributes}]#{escape_mark}`#{extract_passthroughs content}`"
+          next %(#{preceding}[#{attributes}]#{escape_mark}`#{extract_passthroughs content}`)
         end
 
         if escape_mark
-          # honor the escape of the formatting mark (must enclose string following next in " for Opal)
-          next "#{preceding}[#{attributes}]#{m[3][1..-1]}"
-        elsif preceding == '\\'
+          # honor the escape of the formatting mark
+          next %(#{preceding}[#{attributes}]#{m[3][1..-1]})
+        elsif preceding == RS
           # honor the escape of the attributes
           preceding = %([#{attributes}])
           attributes = nil
@@ -274,49 +276,43 @@ module Substitutors
           attributes = parse_attributes attributes
         end
       elsif format_mark == '`' && !old_behavior
-        # must enclose string following next in " for Opal
-        next "#{preceding}#{escape_mark}`#{extract_passthroughs content}`"
+        next %(#{preceding}#{escape_mark}`#{extract_passthroughs content}`)
       elsif escape_mark
-        # honor the escape of the formatting mark (must enclose string following next in " for Opal)
-        next "#{preceding}#{m[3][1..-1]}"
+        # honor the escape of the formatting mark
+        next %(#{preceding}#{m[3][1..-1]})
       end
 
       pass_key = @passthroughs.size
       if compat_mode
-        @passthroughs[pass_key] = {:text => content, :subs => [:specialcharacters], :attributes => attributes, :type => :monospaced}
+        @passthroughs[pass_key] = {:text => content, :subs => BASIC_SUBS, :attributes => attributes, :type => :monospaced}
       elsif attributes
         if old_behavior
-          subs = (format_mark == '`' ? [:specialcharacters] : SUBS[:normal])
+          subs = (format_mark == '`' ? BASIC_SUBS : NORMAL_SUBS)
           @passthroughs[pass_key] = {:text => content, :subs => subs, :attributes => attributes, :type => :monospaced}
         else
-          @passthroughs[pass_key] = {:text => content, :subs => [:specialcharacters], :attributes => attributes, :type => :unquoted}
+          @passthroughs[pass_key] = {:text => content, :subs => BASIC_SUBS, :attributes => attributes, :type => :unquoted}
         end
       else
-        @passthroughs[pass_key] = {:text => content, :subs => [:specialcharacters]}
+        @passthroughs[pass_key] = {:text => content, :subs => BASIC_SUBS}
       end
 
       %(#{preceding}#{PASS_START}#{pass_key}#{PASS_END})
     } if (text.include? pass_inline_char1) || (pass_inline_char2 && (text.include? pass_inline_char2))
 
     # NOTE we need to do the stem in a subsequent step to allow it to be escaped by the former
-    text = text.gsub(StemInlineMacroRx) {
+    text = text.gsub(InlineStemMacroRx) {
       # alias match for Ruby 1.8.7 compat
       m = $~
       # honor the escape
-      if m[0].start_with? '\\'
+      if m[0].start_with? RS
         next m[0][1..-1]
       end
 
       if (type = m[1].to_sym) == :stem
-        type = ((default_stem_type = document.attributes['stem']).nil_or_empty? ? 'asciimath' : default_stem_type).to_sym
+        type = ((default_stem_type = @document.attributes['stem']).nil_or_empty? ? 'asciimath' : default_stem_type).to_sym
       end
       content = unescape_brackets m[3]
-      if m[2].nil_or_empty?
-        subs = (@document.basebackend? 'html') ? [:specialcharacters] : []
-      else
-        subs = resolve_pass_subs m[2]
-      end
-
+      subs = m[2] ? (resolve_pass_subs m[2]) : ((@document.basebackend? 'html') ? BASIC_SUBS : [])
       @passthroughs[pass_key = @passthroughs.size] = {:text => content, :subs => subs, :type => type}
       %(#{PASS_START}#{pass_key}#{PASS_END})
     } if (text.include? ':') && ((text.include? 'stem:') || (text.include? 'math:'))
@@ -335,10 +331,10 @@ module Substitutors
       return text
     end
 
-    text.gsub(PASS_MATCH) {
+    text.gsub(PassSlotRx) {
       # NOTE we can't remove entry from map because placeholder may have been duplicated by other substitutions
-      pass = @passthroughs[$~[1].to_i]
-      subbed_text = (subs = pass[:subs]) ? apply_subs(pass[:text], subs) : pass[:text]
+      pass = @passthroughs[$1.to_i]
+      subbed_text = apply_subs(pass[:text], pass[:subs])
       if (type = pass[:type])
         subbed_text = Inline.new(self, :quoted, subbed_text, :type => type, :attributes => pass[:attributes]).convert
       end
@@ -349,34 +345,29 @@ module Substitutors
     @passthroughs.clear if outer
   end
 
-  # Public: Substitute special characters (i.e., encode XML)
-  #
-  # Special characters are defined in the Asciidoctor::SPECIAL_CHARS Array constant
-  #
-  # text - The String text to process
-  #
-  # returns The String text with special characters replaced
-  def sub_specialchars(text)
-    SUPPORTS_GSUB_RESULT_HASH ?
-      text.gsub(SPECIAL_CHARS_PATTERN, SPECIAL_CHARS) :
-      text.gsub(SPECIAL_CHARS_PATTERN) { SPECIAL_CHARS[$&] }
-  end
-  alias :sub_specialcharacters :sub_specialchars
 
   if RUBY_ENGINE == 'opal'
     def sub_quotes text
-      QUOTE_SUBS[@document.compat_mode].each do |type, scope, pattern|
-        text = text.gsub(pattern) { convert_quoted_text $~, type, scope }
+      if QuotedTextSniffRx[compat = @document.compat_mode].match? text
+        QUOTE_SUBS[compat].each do |type, scope, pattern|
+          text = text.gsub(pattern) { convert_quoted_text $~, type, scope }
+        end
       end
       text
     end
 
     def sub_replacements text
-      REPLACEMENTS.each do |pattern, replacement, restore|
-        text = text.gsub(pattern) { do_replacement $~, replacement, restore }
+      if ReplaceableTextRx.match? text
+        REPLACEMENTS.each do |pattern, replacement, restore|
+          text = text.gsub(pattern) { do_replacement $~, replacement, restore }
+        end
       end
       text
     end
+
+    def sub_specialchars text
+      (text.include? '<') || (text.include? '&') || (text.include? '>') ? (text.gsub SpecialCharsRx, SpecialCharsTr) : text
+    end
   else
     # Public: Substitute quoted text (includes emphasis, strong, monospaced, etc)
     #
@@ -384,11 +375,13 @@ module Substitutors
     #
     # returns The converted String text
     def sub_quotes text
-      # NOTE interpolation is faster than String#dup
-      text = %(#{text})
-      # NOTE using gsub! here as an MRI Ruby optimization
-      QUOTE_SUBS[@document.compat_mode].each do |type, scope, pattern|
-        text.gsub!(pattern) { convert_quoted_text $~, type, scope }
+      if QuotedTextSniffRx[compat = @document.compat_mode].match? text
+        # NOTE interpolation is faster than String#dup
+        text = %(#{text})
+        QUOTE_SUBS[compat].each do |type, scope, pattern|
+          # NOTE using gsub! here as an MRI Ruby optimization
+          text.gsub!(pattern) { convert_quoted_text $~, type, scope }
+        end
       end
       text
     end
@@ -399,30 +392,52 @@ module Substitutors
     #
     # returns The String text with the replacement characters substituted
     def sub_replacements text
-      # NOTE interpolation is faster than String#dup
-      text = %(#{text})
-      # NOTE Using gsub! as optimization
-      REPLACEMENTS.each do |pattern, replacement, restore|
-        text.gsub!(pattern) { do_replacement $~, replacement, restore }
+      if ReplaceableTextRx.match? text
+        # NOTE interpolation is faster than String#dup
+        text = %(#{text})
+        REPLACEMENTS.each do |pattern, replacement, restore|
+          # NOTE Using gsub! as optimization
+          text.gsub!(pattern) { do_replacement $~, replacement, restore }
+        end
       end
       text
     end
+
+    # Public: Substitute special characters (i.e., encode XML)
+    #
+    # The special characters are <, &, and >, which get replaced with &lt;,
+    # &amp;, and &gt;, respectively.
+    #
+    # text - The String text to process
+    #
+    # returns The String text with special characters replaced
+    if ::RUBY_MIN_VERSION_1_9
+      def sub_specialchars text
+        (text.include? '<') || (text.include? '&') || (text.include? '>') ? (text.gsub! SpecialCharsRx, SpecialCharsTr) : text
+      end
+    else
+      def sub_specialchars text
+        (text.include? '<') || (text.include? '&') || (text.include? '>') ? (text.gsub!(SpecialCharsRx) { SpecialCharsTr[$&] }) : text
+      end
+    end
   end
+  alias sub_specialcharacters sub_specialchars
 
   # Internal: Substitute replacement text for matched location
   #
   # returns The String text with the replacement characters substituted
   def do_replacement m, replacement, restore
-    if (matched = m[0]).include? '\\'
-      matched.tr '\\', ''
+    if (captured = m[0]).include? RS
+      # we have to use sub since we aren't sure it's the first char
+      captured.sub RS, ''
     else
       case restore
       when :none
         replacement
-      when :leading
-        %(#{m[1]}#{replacement})
       when :bounding
         %(#{m[1]}#{replacement}#{m[2]})
+      else # :leading
+        %(#{m[1]}#{replacement})
       end
     end
   end
@@ -441,74 +456,52 @@ module Substitutors
   # so that a missing key doesn't wipe out the whole block of data
   # when attribute-undefined and/or attribute-missing is drop-line
   def sub_attributes data, opts = {}
-    return data if data.nil_or_empty?
-
     # normalizes data type to an array (string becomes single-element array)
-    if (string_data = ::String === data)
-      data = [data]
-    end
-
-    doc_attrs = @document.attributes
-    attribute_missing = nil
-    result = []
+    data = [data] if (input_is_string = ::String === data)
+    doc_attrs, result = @document.attributes, []
     data.each do |line|
-      reject = false
-      reject_if_empty = false
+      reject = reject_if_empty = false
       line = line.gsub(AttributeReferenceRx) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
         # escaped attribute, return unescaped
-        if m[1] == '\\' || m[4] == '\\'
-          %({#{m[2]}})
-        elsif !m[3].nil_or_empty?
-          offset = (directive = m[3]).length + 1
-          expr = m[2][offset..-1]
-          case directive
+        if $1 == RS || $4 == RS
+          %({#{$2}})
+        elsif $3
+          case (args = $2.split ':', 3).shift
           when 'set'
-            args = expr.split(':')
-            _, value = Parser.store_attribute(args[0], args[1] || '', @document)
-            unless value
-              # since this is an assignment, only drop-line applies here (skip and drop imply the same result)
-              if doc_attrs.fetch('attribute-undefined', Compliance.attribute_undefined) == 'drop-line'
-                reject = true
-                break ''
-              end
-            end
+            _, value = Parser.store_attribute args[0], args[1] || '', @document
+            # since this is an assignment, only drop-line applies here (skip and drop imply the same result)
+            if (doc_attrs.fetch 'attribute-undefined', Compliance.attribute_undefined) == 'drop-line'
+              reject = true
+              break ''
+            end unless value
             reject_if_empty = true
             ''
-          when 'counter', 'counter2'
-            args = expr.split(':')
-            val = @document.counter(args[0], args[1])
-            if directive == 'counter2'
-              reject_if_empty = true
-              ''
-            else
-              val
-            end
-          else
-            # if we get here, our AttributeReference regex is too loose
-            warn %(asciidoctor: WARNING: illegal attribute directive: #{m[3]})
-            m[0]
+          when 'counter2'
+            @document.counter(*args)
+            reject_if_empty = true
+            ''
+          else # 'counter'
+            @document.counter(*args)
           end
-        elsif doc_attrs.key?(key = m[2].downcase)
+        elsif doc_attrs.key?(key = $2.downcase)
           doc_attrs[key]
         elsif INTRINSIC_ATTRIBUTES.key? key
           INTRINSIC_ATTRIBUTES[key]
         else
-          case (attribute_missing ||= (opts[:attribute_missing] || doc_attrs.fetch('attribute-missing', Compliance.attribute_missing)))
-          when 'skip'
-            m[0]
+          case (attribute_missing ||= opts[:attribute_missing] || (doc_attrs.fetch 'attribute-missing', Compliance.attribute_missing))
+          when 'drop'
+            # QUESTION should we warn in this case?
+            reject_if_empty = true
+            ''
           when 'drop-line'
             warn %(asciidoctor: WARNING: dropping line containing reference to missing attribute: #{key})
             reject = true
             break ''
           when 'warn'
             warn %(asciidoctor: WARNING: skipping reference to missing attribute: #{key})
-            m[0]
-          else # 'drop'
-            # QUESTION should we warn in this case?
-            reject_if_empty = true
-            ''
+            $&
+          else # 'skip'
+            $&
           end
         end
       } if line.include? '{'
@@ -516,7 +509,7 @@ module Substitutors
       result << line unless reject || (reject_if_empty && line.empty?)
     end
 
-    string_data ? result * EOL : result
+    input_is_string ? result * LF : result
   end
 
   # Public: Substitute inline macros (e.g., links, images, etc)
@@ -527,91 +520,80 @@ module Substitutors
   #
   # returns The converted String text
   def sub_macros(source)
-    return source if source.nil_or_empty?
-
+    #return source if source.nil_or_empty?
     # some look ahead assertions to cut unnecessary regex calls
     found = {}
-    found[:square_bracket] = source.include?('[')
-    found[:round_bracket] = source.include?('(')
-    found[:colon] = found_colon = source.include?(':')
-    found[:macroish] = (found[:square_bracket] && found_colon)
-    found[:macroish_short_form] = (found[:square_bracket] && found_colon && source.include?(':['))
-    use_link_attrs = @document.attributes.has_key?('linkattrs')
-    experimental = @document.attributes.has_key?('experimental')
-
-    # NOTE interpolation is faster than String#dup
-    result = %(#{source})
-
-    if experimental
-      if found[:macroish_short_form] && (result.include?('kbd:') || result.include?('btn:'))
-        result = result.gsub(KbdBtnInlineMacroRx) {
-          # alias match for Ruby 1.8.7 compat
-          m = $~
-          # honor the escape
-          if (captured = m[0]).start_with? '\\'
-            next captured[1..-1]
-          end
-
-          if captured.start_with?('kbd')
-            keys = unescape_bracketed_text m[1]
+    found_square_bracket = found[:square_bracket] = (source.include? '[')
+    found_colon = source.include? ':'
+    found_macroish = found[:macroish] = found_square_bracket && found_colon
+    found_macroish_short = found_macroish && (source.include? ':[')
+    doc_attrs = @document.attributes
+    use_link_attrs = doc_attrs.key? 'linkattrs'
+    result = source
 
-            if keys == '+'
-              keys = ['+']
+    if doc_attrs.key? 'experimental'
+      if found_macroish_short && ((result.include? 'kbd:') || (result.include? 'btn:'))
+        result = result.gsub(InlineKbdBtnMacroRx) {
+          # honor the escape
+          if $1
+            $&.slice 1, $&.length
+          elsif $2 == 'kbd'
+            if (keys = $3.strip).include? R_SB
+              keys = keys.gsub ESC_R_SB, R_SB
+            end
+            if keys.length > 1 && (delim_idx = (delim_idx = keys.index ',', 1) ?
+                [delim_idx, (keys.index '+', 1)].compact.min : (keys.index '+', 1))
+              delim = keys.slice delim_idx, 1
+              # NOTE handle special case where keys ends with delimiter (e.g., Ctrl++ or Ctrl,,)
+              if keys.end_with? delim
+                keys = (keys.chop.split delim, -1).map {|key| key.strip }
+                keys[-1] = %(#{keys[-1]}#{delim})
+              else
+                keys = keys.split(delim).map {|key| key.strip }
+              end
             else
-              # need to use closure to work around lack of negative lookbehind
-              keys = keys.split(KbdDelimiterRx).inject([]) {|c, key|
-                if key.end_with?('++')
-                  c << key[0..-3].strip
-                  c << '+'
-                else
-                  c << key.strip
-                end
-                c
-              }
+              keys = [keys]
             end
-            Inline.new(self, :kbd, nil, :attributes => {'keys' => keys}).convert
-          elsif captured.start_with?('btn')
-            label = unescape_bracketed_text m[1]
-            Inline.new(self, :button, label).convert
+            (Inline.new self, :kbd, nil, :attributes => { 'keys' => keys }).convert
+          else # $2 == 'btn'
+            (Inline.new self, :button, (unescape_bracketed_text $3)).convert
           end
         }
       end
 
-      if found[:macroish] && result.include?('menu:')
-        result = result.gsub(MenuInlineMacroRx) {
+      if found_macroish && (result.include? 'menu:')
+        result = result.gsub(InlineMenuMacroRx) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if (captured = m[0]).start_with? '\\'
+          if (captured = m[0]).start_with? RS
             next captured[1..-1]
           end
 
-          menu = m[1]
-          items = m[2]
+          menu, items = m[1], m[2]
 
-          if !items
-            submenus = []
-            menuitem = nil
-          else
+          if items
+            items = items.gsub ESC_R_SB, R_SB if items.include? R_SB
             if (delim = items.include?('&gt;') ? '&gt;' : (items.include?(',') ? ',' : nil))
               submenus = items.split(delim).map {|it| it.strip }
               menuitem = submenus.pop
             else
-              submenus = []
-              menuitem = items.rstrip
+              submenus, menuitem = [], items.rstrip
             end
+          else
+            submenus, menuitem = [], nil
           end
 
           Inline.new(self, :menu, nil, :attributes => {'menu' => menu, 'submenus' => submenus, 'menuitem' => menuitem}).convert
         }
       end
 
-      if result.include?('"') && result.include?('&gt;')
+      if (result.include? '"') && (result.include? '&gt;')
         result = result.gsub(MenuInlineRx) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if (captured = m[0]).start_with? '\\'
+          if (captured = m[0]).start_with? RS
             next captured[1..-1]
           end
 
@@ -626,114 +608,117 @@ module Substitutors
 
     # FIXME this location is somewhat arbitrary, probably need to be able to control ordering
     # TODO this handling needs some cleanup
-    if (extensions = @document.extensions) && extensions.inline_macros? # && found[:macroish]
+    if (extensions = @document.extensions) && extensions.inline_macros? # && found_macroish
       extensions.inline_macros.each do |extension|
         result = result.gsub(extension.instance.regexp) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if m[0].start_with? '\\'
+          if m[0].start_with? RS
             next m[0][1..-1]
           end
 
-          target = m[1]
-          attributes = if extension.config[:format] == :short
-            # TODO if content_model is :attributes, set target to nil and parse attributes
-            # maybe if content_model is :text, we should put content into text attribute
-            {}
+          if (m.names rescue []).empty?
+            target, content, extconf = m[1], m[2], extension.config
+          else
+            target, content, extconf = (m[:target] rescue nil), (m[:content] rescue nil), extension.config
+          end
+          attributes = (attributes = extconf[:default_attrs]) ? attributes.dup : {}
+          if content.nil_or_empty?
+            attributes['text'] = content if content && extconf[:content_model] != :attributes
           else
-            if extension.config[:content_model] == :attributes
-              parse_attributes m[2], (extension.config[:pos_attrs] || []), :sub_input => true, :unescape_input => true
+            content = unescape_bracketed_text content
+            if extconf[:content_model] == :attributes
+              # QUESTION should we store the text in the _text key?
+              # QUESTION why is the sub_result option false? why isn't the unescape_input option true?
+              parse_attributes content, extconf[:pos_attrs] || [], :sub_result => false, :into => attributes
             else
-              { 'text' => (unescape_bracketed_text m[2]) }
+              attributes['text'] = content
             end
           end
-          extension.process_method[self, target, attributes]
+          # NOTE use content if target is not set (short form only); deprecated - remove in 1.6.0
+          replacement = extension.process_method[self, target || content, attributes]
+          Inline === replacement ? replacement.convert : replacement
         }
       end
     end
 
-    if found[:macroish] && (result.include?('image:') || result.include?('icon:'))
+    if found_macroish && ((result.include? 'image:') || (result.include? 'icon:'))
       # image:filename.png[Alt Text]
-      result = result.gsub(ImageInlineMacroRx) {
+      result = result.gsub(InlineImageMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
+        if (captured = m[0]).start_with? RS
+          next captured[1..-1]
         end
 
-        raw_attrs = unescape_bracketed_text m[2]
-        if m[0].start_with? 'icon:'
-          type = 'icon'
-          posattrs = ['size']
+        if captured.start_with? 'icon:'
+          type, posattrs = 'icon', ['size']
         else
-          type = 'image'
-          posattrs = ['alt', 'width', 'height']
+          type, posattrs = 'image', ['alt', 'width', 'height']
         end
-        target = sub_attributes(m[1])
-        unless type == 'icon'
-          @document.register(:images, target)
-        end
-        attrs = parse_attributes(raw_attrs, posattrs)
-        attrs['alt'] ||= Helpers.basename(target, true).tr('_-', ' ')
+        target = m[1]
+        @document.register(:images, target) unless type == 'icon'
+        attrs = parse_attributes(m[2], posattrs, :unescape_input => true)
+        attrs['alt'] ||= (attrs['default-alt'] = Helpers.basename(target, true).tr('_-', ' '))
         Inline.new(self, :image, nil, :type => type, :target => target, :attributes => attrs).convert
       }
     end
 
-    if found[:macroish_short_form] || found[:round_bracket]
-      # indexterm:[Tigers,Big cats]
+    if ((result.include? '((') && (result.include? '))')) ||
+        (found_macroish_short && (result.include? 'indexterm'))
       # (((Tigers,Big cats)))
-      # indexterm2:[Tigers]
+      # indexterm:[Tigers,Big cats]
       # ((Tigers))
-      result = result.gsub(IndextermInlineMacroRx) {
+      # indexterm2:[Tigers]
+      result = result.gsub(InlineIndextermMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
 
         # honor the escape
-        if m[0].start_with? '\\'
+        if m[0].start_with? RS
           next m[0][1..-1]
         end
 
-        # fix non-matching group results in Opal under Firefox
-        if ::RUBY_ENGINE_OPAL
-          m[1] = nil if m[1] == ''
-        end
-
-        num_brackets = 0
-        text_in_brackets = nil
-        unless (macro_name = m[1])
-          text_in_brackets = m[3]
-          if (text_in_brackets.start_with? '(') && (text_in_brackets.end_with? ')')
-            text_in_brackets = text_in_brackets[1...-1]
-            num_brackets = 3
-          else
-            num_brackets = 2
-          end
-        end
-
-        # non-visible
-        if macro_name == 'indexterm' || num_brackets == 3
-          if !macro_name
-            # (((Tigers,Big cats)))
-            terms = split_simple_csv normalize_string(text_in_brackets)
-          else
-            # indexterm:[Tigers,Big cats]
-            terms = split_simple_csv normalize_string(m[2], true)
-          end
-          @document.register(:indexterms, [*terms])
-          Inline.new(self, :indexterm, nil, :attributes => {'terms' => terms}).convert
-        # visible
+        case m[1]
+        when 'indexterm'
+          # indexterm:[Tigers,Big cats]
+          terms = split_simple_csv(normalize_string m[2], true)
+          @document.register :indexterms, terms
+          (Inline.new self, :indexterm, nil, :attributes => { 'terms' => terms }).convert
+        when 'indexterm2'
+          # indexterm2:[Tigers]
+          term = normalize_string m[2], true
+          @document.register :indexterms, [term]
+          (Inline.new self, :indexterm, term, :type => :visible).convert
         else
-          if !macro_name
+          text, visible, before, after = m[3], true, nil, nil
+          if text.start_with? '('
+            if text.end_with? ')'
+              text, visible = (text.slice 1, text.length - 2), false
+            else
+              text, before, after = (text.slice 1, text.length - 1), '(', ''
+            end
+          elsif text.end_with? ')'
+            if text.start_with? '('
+              text, visible = (text.slice 1, text.length - 2), false
+            else
+              text, before, after = (text.slice 0, text.length - 1), '', ')'
+            end
+          end
+          if visible
             # ((Tigers))
-            text = normalize_string text_in_brackets
+            term = normalize_string text
+            @document.register :indexterms, [term]
+            result = (Inline.new self, :indexterm, term, :type => :visible).convert
           else
-            # indexterm2:[Tigers]
-            text = normalize_string m[2], true
+            # (((Tigers,Big cats)))
+            terms = split_simple_csv(normalize_string text)
+            @document.register :indexterms, terms
+            result = (Inline.new self, :indexterm, nil, :attributes => { 'terms' => terms }).convert
           end
-          @document.register(:indexterms, [text])
-          Inline.new(self, :indexterm, text, :type => :visible).convert
+          before ? %(#{before}#{result}#{after}) : result
         end
       }
     end
@@ -744,71 +729,65 @@ module Substitutors
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[2].start_with? '\\'
-          # must enclose string following next in " for Opal
-          next "#{m[1]}#{m[2][1..-1]}#{m[3]}"
+        if m[2].start_with? RS
+          next %(#{m[1]}#{m[2][1..-1]}#{m[3]})
         end
-        # fix non-matching group results in Opal under Firefox
-        if ::RUBY_ENGINE_OPAL
-          m[3] = nil if m[3] == ''
-        end
-        # not a valid macro syntax w/o trailing square brackets
-        # we probably shouldn't even get here...our regex is doing too much
-        if m[1] == 'link:' && !m[3]
-          next m[0]
+        # NOTE if text is non-nil, then we've matched a formal macro (i.e., trailing square brackets)
+        prefix, target, text, suffix = m[1], m[2], (macro = m[3]) || '', ''
+        if prefix == 'link:'
+          if macro
+            prefix = ''
+          else
+            # invalid macro syntax (link: prefix w/o trailing square brackets)
+            # we probably shouldn't even get here...our regex is doing too much
+            next m[0]
+          end
         end
-        prefix = (m[1] != 'link:' ? m[1] : '')
-        target = m[2]
-        suffix = ''
-        unless m[3] || target !~ UriTerminator
-          case $~[0]
+        unless macro || UriTerminatorRx !~ target
+          case $&
           when ')'
-            # strip the trailing )
-            target = target[0..-2]
+            # strip trailing )
+            target = target.chop
             suffix = ')'
           when ';'
-            # strip the <> around the link
+            # strip <> around URI
             if prefix.start_with?('&lt;') && target.end_with?('&gt;')
               prefix = prefix[4..-1]
-              target = target[0..-5]
-            # strip the ); from the end of the link
-            elsif target.end_with?(');')
-              target = target[0..-3]
-              suffix = ');'
+              target = target[0...-4]
             else
-              target = target[0..-2]
-              suffix = ';'
+              # strip trailing ;
+              # check for trailing );
+              if (target = target.chop).end_with?(')')
+                target = target.chop
+                suffix = ');'
+              else
+                suffix = ';'
+              end
             end
           when ':'
-            # strip the ): from the end of the link
-            if target.end_with?('):')
-              target = target[0..-3]
+            # strip trailing :
+            # check for trailing ):
+            if (target = target.chop).end_with?(')')
+              target = target.chop
               suffix = '):'
             else
-              target = target[0..-2]
               suffix = ':'
             end
           end
         end
-        @document.register(:links, target)
 
-        link_opts = { :type => :link, :target => target }
-        attrs = nil
-        #text = m[3] ? sub_attributes(m[3].gsub('\]', ']')) : ''
-        if m[3].nil_or_empty?
-          text = ''
-        else
-          if use_link_attrs && (m[3].start_with?('"') || (m[3].include?(',') && m[3].include?('=')))
-            attrs = parse_attributes(sub_attributes(m[3].gsub('\]', ']')), [])
-            link_opts[:id] = (attrs.delete 'id') if attrs.has_key? 'id'
+        attrs, link_opts = nil, { :type => :link }
+        unless text.empty?
+          text = text.gsub ESC_R_SB, R_SB if text.include? R_SB
+          if use_link_attrs && ((text.start_with? '"') || ((text.include? ',') && (text.include? '=')))
+            attrs = parse_attributes text, []
+            link_opts[:id] = attrs.delete 'id' if attrs.key? 'id'
             text = attrs[1] || ''
-          else
-            text = sub_attributes(m[3].gsub('\]', ']'))
           end
 
-          # TODO enable in Asciidoctor 1.5.1
+          # TODO enable in Asciidoctor 1.6.x
           # support pipe-separated text and title
-          #unless attrs && (attrs.has_key? 'title')
+          #unless attrs && (attrs.key? 'title')
           #  if text.include? '|'
           #    attrs ||= {}
           #    text, attrs['title'] = text.split '|', 2
@@ -820,120 +799,99 @@ module Substitutors
             if attrs
               attrs['window'] ||= '_blank'
             else
-              attrs = {'window' => '_blank'}
+              attrs = { 'window' => '_blank' }
             end
           end
         end
 
         if text.empty?
-          if @document.attr? 'hide-uri-scheme'
-            text = target.sub UriSniffRx, ''
-          else
-            text = target
-          end
-
+          text = (doc_attrs.key? 'hide-uri-scheme') ? (target.sub UriSniffRx, '') : target
           if attrs
-            attrs['role'] = %(bare #{attrs['role']}).chomp ' '
+            attrs['role'] = (attrs.key? 'role') ? %(bare #{attrs['role']}) : 'bare'
           else
-            attrs = {'role' => 'bare'}
+            attrs = { 'role' => 'bare' }
           end
         end
 
+        @document.register :links, (link_opts[:target] = target)
         link_opts[:attributes] = attrs if attrs
         %(#{prefix}#{Inline.new(self, :anchor, text, link_opts).convert}#{suffix})
       }
     end
 
-    if found[:macroish] && (result.include? 'link:') || (result.include? 'mailto:')
+    if found_macroish && ((result.include? 'link:') || (result.include? 'mailto:'))
       # inline link macros, link:target[text]
-      result = result.gsub(LinkInlineMacroRx) {
+      result = result.gsub(InlineLinkMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? '\\'
+        if m[0].start_with? RS
           next m[0][1..-1]
         end
-        raw_target = m[1]
-        mailto = m[0].start_with?('mailto:')
-        target = mailto ? %(mailto:#{raw_target}) : raw_target
-
-        link_opts = { :type => :link, :target => target }
-        attrs = nil
-        #text = sub_attributes(m[2].gsub('\]', ']'))
-        text = if use_link_attrs && (m[2].start_with?('"') || m[2].include?(','))
-          attrs = parse_attributes(sub_attributes(m[2].gsub('\]', ']')), [])
-          link_opts[:id] = (attrs.delete 'id') if attrs.key? 'id'
-          if mailto
-            if attrs.key? 2
-              target = link_opts[:target] = "#{target}?subject=#{Helpers.encode_uri(attrs[2])}"
-
-              if attrs.key? 3
-                target = link_opts[:target] = "#{target}&amp;body=#{Helpers.encode_uri(attrs[3])}"
+        target = (mailto = m[1]) ? %(mailto:#{m[2]}) : m[2]
+        attrs, link_opts = nil, { :type => :link }
+        unless (text = m[3]).empty?
+          text = text.gsub ESC_R_SB, R_SB if text.include? R_SB
+          if use_link_attrs && ((text.start_with? '"') || ((text.include? ',') && (mailto || (text.include? '='))))
+            attrs = parse_attributes text, []
+            link_opts[:id] = attrs.delete 'id' if attrs.key? 'id'
+            if mailto
+              if attrs.key? 2
+                if attrs.key? 3
+                  target = %(#{target}?subject=#{Helpers.uri_encode attrs[2]}&amp;body=#{Helpers.uri_encode attrs[3]})
+                else
+                  target = %(#{target}?subject=#{Helpers.uri_encode attrs[2]})
+                end
               end
             end
+            text = attrs[1] || ''
           end
-          attrs[1]
-        else
-          sub_attributes(m[2].gsub('\]', ']'))
-        end
 
-        # QUESTION should a mailto be registered as an e-mail address?
-        @document.register(:links, target)
+          # TODO enable in Asciidoctor 1.6.x
+          # support pipe-separated text and title
+          #unless attrs && (attrs.key? 'title')
+          #  if text.include? '|'
+          #    attrs ||= {}
+          #    text, attrs['title'] = text.split '|', 2
+          #  end
+          #end
 
-        # TODO enable in Asciidoctor 1.5.1
-        # support pipe-separated text and title
-        #unless attrs && (attrs.key? 'title')
-        #  if text.include? '|'
-        #    attrs ||= {}
-        #    text, attrs['title'] = text.split '|', 2
-        #  end
-        #end
-
-        if text.end_with? '^'
-          text = text.chop
-          if attrs
-            attrs['window'] ||= '_blank'
-          else
-            attrs = {'window' => '_blank'}
+          if text.end_with? '^'
+            text = text.chop
+            if attrs
+              attrs['window'] ||= '_blank'
+            else
+              attrs = { 'window' => '_blank' }
+            end
           end
         end
 
         if text.empty?
           # mailto is a special case, already processed
           if mailto
-            text = raw_target
+            text = m[2]
           else
-            if @document.attr? 'hide-uri-scheme'
-              text = raw_target.sub UriSniffRx, ''
-            else
-              text = raw_target
-            end
-
+            text = (doc_attrs.key? 'hide-uri-scheme') ? (target.sub UriSniffRx, '') : target
             if attrs
-              attrs['role'] = %(bare #{attrs['role']}).chomp ' '
+              attrs['role'] = (attrs.key? 'role') ? %(bare #{attrs['role']}) : 'bare'
             else
-              attrs = {'role' => 'bare'}
+              attrs = { 'role' => 'bare' }
             end
           end
         end
 
+        # QUESTION should a mailto be registered as an e-mail address?
+        @document.register :links, (link_opts[:target] = target)
         link_opts[:attributes] = attrs if attrs
         Inline.new(self, :anchor, text, link_opts).convert
       }
     end
 
     if result.include? '@'
-      result = result.gsub(EmailInlineMacroRx) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        address = m[0]
-        if (lead = m[1])
-          case lead
-          when '\\'
-            next address[1..-1]
-          else
-            next address
-          end
+      result = result.gsub(EmailInlineRx) {
+        address, tip = $&, $1
+        if tip
+          next (tip == RS ? address[1..-1] : address)
         end
 
         target = %(mailto:#{address})
@@ -944,12 +902,12 @@ module Substitutors
       }
     end
 
-    if found[:macroish_short_form] && result.include?('footnote')
-      result = result.gsub(FootnoteInlineMacroRx) {
+    if found_macroish_short && (result.include? 'footnote')
+      result = result.gsub(InlineFootnoteMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? '\\'
+        if m[0].start_with? RS
           next m[0][1..-1]
         end
         if m[1] == 'footnote'
@@ -963,9 +921,15 @@ module Substitutors
         else
           id, text = m[2].split(',', 2)
           id = id.strip
-          # NOTE In Opal, text is set to empty string if comma is missing
-          if text.nil_or_empty?
-            if (footnote = @document.references[:footnotes].find {|fn| fn.id == id })
+          if text
+            # REVIEW it's a dirty job, but somebody's gotta do it
+            text = restore_passthroughs(sub_inline_xrefs(sub_inline_anchors(normalize_string text, true)), false)
+            index = @document.counter('footnote-number')
+            @document.register(:footnotes, Document::Footnote.new(index, id, text))
+            type = :ref
+            target = nil
+          else
+            if (footnote = @document.footnotes.find {|fn| fn.id == id })
               index = footnote.index
               text = footnote.text
             else
@@ -975,13 +939,6 @@ module Substitutors
             target = id
             id = nil
             type = :xref
-          else
-            # REVIEW it's a dirty job, but somebody's gotta do it
-            text = restore_passthroughs(sub_inline_xrefs(sub_inline_anchors(normalize_string text, true)), false)
-            index = @document.counter('footnote-number')
-            @document.register(:footnotes, Document::Footnote.new(index, id, text))
-            type = :ref
-            target = nil
           end
         end
         Inline.new(self, :footnote, text, :attributes => {'index' => index}, :id => id, :target => target, :type => type).convert
@@ -993,44 +950,29 @@ module Substitutors
 
   # Internal: Substitute normal and bibliographic anchors
   def sub_inline_anchors(text, found = nil)
-    if (!found || found[:square_bracket]) && text.include?('[[[')
-      text = text.gsub(InlineBiblioAnchorRx) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
-        # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        id = reftext = m[1]
-        Inline.new(self, :anchor, reftext, :type => :bibref, :target => id).convert
+    if @context == :list_item && @parent.style == 'bibliography'
+      text = text.sub(InlineBiblioAnchorRx) {
+        # NOTE target property on :bibref is deprecated
+        Inline.new(self, :anchor, %([#{$2 || $1}]), :type => :bibref, :id => $1, :target => $1).convert
       }
     end
 
     if ((!found || found[:square_bracket]) && text.include?('[[')) ||
-        ((!found || found[:macroish]) && text.include?('anchor:'))
+        ((!found || found[:macroish]) && text.include?('or:'))
       text = text.gsub(InlineAnchorRx) {
-        # alias match for Ruby 1.8.7 compat
-        m = $~
         # honor the escape
-        if m[0].start_with? '\\'
-          next m[0][1..-1]
-        end
-        # fix non-matching group results in Opal under Firefox
-        if ::RUBY_ENGINE_OPAL
-          m[1] = nil if m[1] == ''
-          m[2] = nil if m[2] == ''
-          m[4] = nil if m[4] == ''
+        next $&.slice 1, $&.length if $1
+        # NOTE reftext is only relevant for DocBook output; used as value of xreflabel attribute
+        if (id = $2)
+          reftext = $3
+        else
+          id = $4
+          if (reftext = $5) && (reftext.include? R_SB)
+            reftext = reftext.gsub ESC_R_SB, R_SB
+          end
         end
-        id = m[1] || m[3]
-        reftext = m[2] || m[4] || %([#{id}])
-        # enable if we want to allow double quoted values
-        #id = id.sub(DoubleQuotedRx, '\2')
-        #if reftext
-        #  reftext = reftext.sub(DoubleQuotedMultiRx, '\2')
-        #else
-        #  reftext = "[#{id}]"
-        #end
-        Inline.new(self, :anchor, reftext, :type => :ref, :target => id).convert
+        # NOTE target property on :ref is deprecated
+        Inline.new(self, :anchor, reftext, :type => :ref, :id => id, :target => id).convert
       }
     end
 
@@ -1039,65 +981,67 @@ module Substitutors
 
   # Internal: Substitute cross reference links
   def sub_inline_xrefs(text, found = nil)
-    if (!found || found[:macroish]) || text.include?('&lt;&lt;')
-      text = text.gsub(XrefInlineMacroRx) {
+    if ((found ? found[:macroish] : (text.include? '[')) && (text.include? 'xref:')) ||
+        ((text.include? '&') && (text.include? '&lt;&lt;'))
+      text = text.gsub(InlineXrefMacroRx) {
         # alias match for Ruby 1.8.7 compat
         m = $~
         # honor the escape
-        if m[0].start_with? '\\'
+        if m[0].start_with? RS
           next m[0][1..-1]
         end
-        # fix non-matching group results in Opal under Firefox
-        if ::RUBY_ENGINE_OPAL
-          m[1] = nil if m[1] == ''
-        end
-        if m[1]
-          id, reftext = m[1].split(',', 2).map {|it| it.strip }
-          id = id.sub(DoubleQuotedRx, '\2')
-          # NOTE In Opal, reftext is set to empty string if comma is missing
-          reftext = if reftext.nil_or_empty?
-            nil
-          else
-            reftext.sub(DoubleQuotedMultiRx, '\2')
-          end
+        if (id = m[1])
+          id, reftext = id.split ',', 2
+          reftext = reftext.lstrip if reftext
         else
           id = m[2]
-          reftext = m[3] unless m[3].nil_or_empty?
+          if (reftext = m[3]) && (reftext.include? R_SB)
+            reftext = reftext.gsub ESC_R_SB, R_SB
+          end
         end
 
-        if id.include? '#'
-          path, fragment = id.split('#')
-        # QUESTION perform this check and throw it back if it fails?
-        #elsif (start_chr = id.chr) == '.' || start_chr == '/'
-        #  next m[0][1..-1]
+        if (hash_idx = id.index '#')
+          if hash_idx > 0
+            if (fragment_len = id.length - hash_idx - 1) > 0
+              path, fragment = (id.slice 0, hash_idx), (id.slice hash_idx + 1, fragment_len)
+            else
+              path, fragment = (id.slice 0, hash_idx), nil
+            end
+          else
+            target, path, fragment = id, nil, (id.slice 1, id.length)
+          end
         else
-          path = nil
-          fragment = id
+          path, fragment = nil, id
         end
 
-        # handles forms: doc#, doc.adoc#, doc#id and doc.adoc#id
-        if path
-          path = Helpers.rootname(path)
+        # handles: #id
+        if target
+          refid = fragment
+        # handles: path#, path.adoc#, path#id, or path.adoc#id
+        elsif path
+          if (ext_idx = path.rindex '.') && ASCIIDOC_EXTENSIONS[path.slice ext_idx, path.length]
+            path = path.slice 0, ext_idx
+          end
           # the referenced path is this document, or its contents has been included in this document
-          if @document.attributes['docname'] == path || @document.references[:includes].include?(path)
-            refid = fragment
-            path = nil
-            target = %(##{fragment})
+          if @document.attributes['docname'] == path || @document.catalog[:includes].include?(path)
+            refid, path, target = fragment, nil, %(##{fragment})
           else
             refid = fragment ? %(#{path}##{fragment}) : path
-            path = "#{@document.attributes['relfileprefix']}#{path}#{@document.attributes.fetch 'outfilesuffix', '.html'}"
+            path = %(#{@document.attributes['relfileprefix']}#{path}#{@document.attributes.fetch 'outfilesuffix', '.html'})
             target = fragment ? %(#{path}##{fragment}) : path
           end
-        # handles form: id or Section Title
+        # handles: id or Section Title
         else
-          # resolve fragment as reftext if cannot be resolved as refid and looks like reftext
-          if !(@document.references[:ids].has_key? fragment) &&
-              ((fragment.include? ' ') || fragment.downcase != fragment) &&
-              (resolved_id = RUBY_MIN_VERSION_1_9 ? (@document.references[:ids].key fragment) : (@document.references[:ids].index fragment))
-            fragment = resolved_id
+          # resolve fragment as reftext if it's not a known ID and resembles reftext (includes space or has uppercase char)
+          unless @document.catalog[:ids].key? fragment
+            if ((fragment.include? ' ') || fragment.downcase != fragment) &&
+                (resolved_id = @document.catalog[:ids].key fragment)
+              fragment = resolved_id
+            elsif $VERBOSE
+              warn %(asciidoctor: WARNING: invalid reference: #{fragment})
+            end
           end
-          refid = fragment
-          target = %(##{fragment})
+          refid, target = fragment, %(##{fragment})
         end
         Inline.new(self, :anchor, reftext, :type => :xref, :target => target, :attributes => {'path' => path, 'fragment' => fragment, 'refid' => refid}).convert
       }
@@ -1115,14 +1059,11 @@ module Substitutors
     # FIXME cache this dynamic regex
     callout_rx = (attr? 'line-comment') ? /(?:#{::Regexp.escape(attr 'line-comment')} )?#{CalloutSourceRxt}/ : CalloutSourceRx
     text.gsub(callout_rx) {
-      # alias match for Ruby 1.8.7 compat
-      m = $~
-      # honor the escape
-      if m[1] == '\\'
-        # we have to do a sub since we aren't sure it's the first char
-        next m[0].sub('\\', '')
+      if $1
+        # we have to use sub since we aren't sure it's the first char
+        next $&.sub(RS, '')
       end
-      Inline.new(self, :callout, m[3], :id => @document.callouts.read_next_id).convert
+      Inline.new(self, :callout, $3, :id => @document.callouts.read_next_id).convert
     }
   end
 
@@ -1132,13 +1073,15 @@ module Substitutors
   #
   # Returns the converted String text
   def sub_post_replacements(text)
-    if (@document.attributes.has_key? 'hardbreaks') || (@attributes.has_key? 'hardbreaks-option')
-      lines = (text.split EOL)
-      return text if lines.size == 1
+    if (@document.attributes.key? 'hardbreaks') || (@attributes.key? 'hardbreaks-option')
+      lines = text.split LF, -1
+      return text if lines.size < 2
       last = lines.pop
-      lines.map {|line| Inline.new(self, :break, line.rstrip.chomp(LINE_BREAK), :type => :line).convert }.push(last) * EOL
-    elsif text.include? '+'
-      text.gsub(LineBreakRx) { Inline.new(self, :break, $~[1], :type => :line).convert }
+      (lines.map {|line|
+        Inline.new(self, :break, (line.end_with? HARD_LINE_BREAK) ? (line.slice 0, line.length - 2) : line, :type => :line).convert
+      } << last) * LF
+    elsif (text.include? PLUS) && (text.include? HARD_LINE_BREAK)
+      text.gsub(HardLineBreakRx) { Inline.new(self, :break, $1, :type => :line).convert }
     else
       text
     end
@@ -1152,8 +1095,7 @@ module Substitutors
   #
   # Returns The converted String text for the quoted text region
   def convert_quoted_text(match, type, scope)
-    unescaped_attrs = nil
-    if match[0].start_with? '\\'
+    if match[0].start_with? RS
       if scope == :constrained && !(attrs = match[2]).nil_or_empty?
         unescaped_attrs = %([#{attrs}])
       else
@@ -1165,44 +1107,39 @@ module Substitutors
       if unescaped_attrs
         %(#{unescaped_attrs}#{Inline.new(self, :quoted, match[3], :type => type).convert})
       else
-        if (attributes = parse_quoted_text_attributes(match[2]))
-          id = attributes.delete 'id'
+        if (attrlist = match[2])
+          id = (attributes = parse_quoted_text_attributes attrlist).delete 'id'
           type = :unquoted if type == :mark
-        else
-          id = nil
         end
         %(#{match[1]}#{Inline.new(self, :quoted, match[3], :type => type, :id => id, :attributes => attributes).convert})
       end
     else
-      if (attributes = parse_quoted_text_attributes(match[1]))
-        id = attributes.delete 'id'
+      if (attrlist = match[1])
+        id = (attributes = parse_quoted_text_attributes attrlist).delete 'id'
         type = :unquoted if type == :mark
-      else
-        id = nil
       end
       Inline.new(self, :quoted, match[2], :type => type, :id => id, :attributes => attributes).convert
     end
   end
 
-  # Internal: Parse the attributes that are defined on quoted text
+  # Internal: Parse the attributes that are defined on quoted (aka formatted) text
   #
-  # str       - A String of unprocessed attributes (space-separated roles or the id/role shorthand syntax)
+  # str - A non-nil String of unprocessed attributes;
+  #       space-separated roles (e.g., role1 role2) or the id/role shorthand syntax (e.g., #idname.role)
   #
-  # returns nil if str is nil, an empty Hash if str is empty, otherwise a Hash of attributes (role and id only)
-  def parse_quoted_text_attributes(str)
-    return unless str
-    return {} if str.empty?
-    str = sub_attributes(str) if str.include?('{')
-    str = str.strip
+  # Returns a Hash of attributes (role and id only)
+  def parse_quoted_text_attributes str
+    # NOTE attributes are typically resolved after quoted text, so substitute eagerly
+    str = sub_attributes str if str.include? '{'
     # for compliance, only consider first positional attribute
-    str, _ = str.split(',', 2) if str.include?(',')
+    str = str.slice 0, (str.index ',') if str.include? ','
 
-    if str.empty?
+    if (str = str.strip).empty?
       {}
-    elsif (str.start_with?('.') || str.start_with?('#')) && Compliance.shorthand_property_syntax
+    elsif (str.start_with? '.', '#') && Compliance.shorthand_property_syntax
       segments = str.split('#', 2)
 
-      if segments.length > 1
+      if segments.size > 1
         id, *more_roles = segments[1].split('.')
       else
         id = nil
@@ -1210,11 +1147,11 @@ module Substitutors
       end
 
       roles = segments[0].empty? ? [] : segments[0].split('.')
-      if roles.length > 1
+      if roles.size > 1
         roles.shift
       end
 
-      if more_roles.length > 0
+      if more_roles.size > 0
         roles.concat more_roles
       end
 
@@ -1236,14 +1173,10 @@ module Substitutors
   def parse_attributes(attrline, posattrs = ['role'], opts = {})
     return unless attrline
     return {} if attrline.empty?
-    attrline = @document.sub_attributes(attrline) if opts[:sub_input]
+    attrline = @document.sub_attributes(attrline) if opts[:sub_input] && (attrline.include? '{')
     attrline = unescape_bracketed_text(attrline) if opts[:unescape_input]
-    block = nil
-    if opts.fetch(:sub_result, true)
-      # substitutions are only performed on attribute values if block is not nil
-      block = self
-    end
-
+    # substitutions are only performed on attribute values if block is not nil
+    block = opts.fetch(:sub_result, true) ? self : nil
     if (into = opts[:into])
       AttributeList.new(attrline, block).parse_into(into, posattrs)
     else
@@ -1253,28 +1186,29 @@ module Substitutors
 
   # Internal: Strip bounding whitespace, fold endlines and unescaped closing
   # square brackets from text extracted from brackets
-  def unescape_bracketed_text(text)
-    return '' if text.empty?
-    # FIXME make \] a regex
-    text.strip.tr(EOL, ' ').gsub('\]', ']')
+  def unescape_bracketed_text text
+    if (text = text.strip.tr LF, ' ').include? R_SB
+      text = text.gsub ESC_R_SB, R_SB
+    end unless text.empty?
+    text
   end
 
   # Internal: Strip bounding whitespace and fold endlines
   def normalize_string str, unescape_brackets = false
-    if str.empty?
-      ''
-    elsif unescape_brackets
-      unescape_brackets str.strip.tr(EOL, ' ')
-    else
-      str.strip.tr(EOL, ' ')
+    unless str.empty?
+      str = str.strip.tr LF, ' '
+      str = str.gsub ESC_R_SB, R_SB if unescape_brackets && (str.include? R_SB)
     end
+    str
   end
 
   # Internal: Unescape closing square brackets.
   # Intended for text extracted from square brackets.
   def unescape_brackets str
-    # FIXME make \] a regex
-    str.empty? ? '' : str.gsub('\]', ']')
+    if str.include? RS
+      str = str.gsub ESC_R_SB, R_SB
+    end unless str.empty?
+    str
   end
 
   # Internal: Split text formatted as CSV with support
@@ -1290,7 +1224,7 @@ module Substitutors
         case c
         when ','
           if quote_open
-            current.push c
+            current << c
           else
             values << current.join.strip
             current = []
@@ -1298,7 +1232,7 @@ module Substitutors
         when '"'
           quote_open = !quote_open
         else
-          current.push c
+          current << c
         end
       end
 
@@ -1317,9 +1251,11 @@ module Substitutors
   # returns An Array of Symbols representing the substitution operation
   def resolve_subs subs, type = :block, defaults = nil, subject = nil
     return [] if subs.nil_or_empty?
+    # QUESTION should we store candidates as a Set instead of an Array?
     candidates = nil
-    modifiers_present = SubModifierSniffRx =~ subs
-    subs.tr(' ', '').split(',').each do |key|
+    subs = subs.delete ' ' if subs.include? ' '
+    modifiers_present = SubModifierSniffRx.match? subs
+    subs.split(',').each do |key|
       modifier_operation = nil
       if modifiers_present
         if (first = key.chr) == '+'
@@ -1336,12 +1272,12 @@ module Substitutors
       key = key.to_sym
       # special case to disable callouts for inline subs
       if type == :inline && (key == :verbatim || key == :v)
-        resolved_keys = [:specialcharacters]
-      elsif COMPOSITE_SUBS.key? key
-        resolved_keys = COMPOSITE_SUBS[key]
-      elsif type == :inline && key.length == 1 && (SUB_SYMBOLS.key? key)
-        resolved_key = SUB_SYMBOLS[key]
-        if (candidate = COMPOSITE_SUBS[resolved_key])
+        resolved_keys = BASIC_SUBS
+      elsif SUB_GROUPS.key? key
+        resolved_keys = SUB_GROUPS[key]
+      elsif type == :inline && key.length == 1 && (SUB_HINTS.key? key)
+        resolved_key = SUB_HINTS[key]
+        if (candidate = SUB_GROUPS[resolved_key])
           resolved_keys = candidate
         else
           resolved_keys = [resolved_key]
@@ -1365,8 +1301,8 @@ module Substitutors
         candidates += resolved_keys
       end
     end
-    # weed out invalid options and remove duplicates (first wins)
-    # TODO may be use a set instead?
+    return [] unless candidates
+    # weed out invalid options and remove duplicates (order is preserved; first occurence wins)
     resolved = candidates & SUB_OPTIONS[type]
     unless (candidates - resolved).empty?
       invalid = candidates - resolved
@@ -1401,7 +1337,7 @@ module Substitutors
       unless (highlighter_loaded = defined? ::CodeRay) || @document.attributes['coderay-unavailable']
         if (Helpers.require_library 'coderay', true, :warn).nil?
           # prevent further attempts to load CodeRay
-          @document.set_attr 'coderay-unavailable', ''
+          @document.set_attr 'coderay-unavailable'
         else
           highlighter_loaded = true
         end
@@ -1410,7 +1346,7 @@ module Substitutors
       unless (highlighter_loaded = defined? ::Pygments) || @document.attributes['pygments-unavailable']
         if (Helpers.require_library 'pygments', 'pygments.rb', :warn).nil?
           # prevent further attempts to load Pygments
-          @document.set_attr 'pygments-unavailable', ''
+          @document.set_attr 'pygments-unavailable'
         else
           highlighter_loaded = true
         end
@@ -1430,21 +1366,22 @@ module Substitutors
       # FIXME cache this dynamic regex
       callout_rx = (attr? 'line-comment') ? /(?:#{::Regexp.escape(attr 'line-comment')} )?#{CalloutExtractRxt}/ : CalloutExtractRx
       # extract callout marks, indexed by line number
-      source = source.split(EOL).map {|line|
+      source = source.split(LF, -1).map {|line|
         lineno = lineno + 1
         line.gsub(callout_rx) {
           # alias match for Ruby 1.8.7 compat
           m = $~
           # honor the escape
-          if m[1] == '\\'
-            m[0].sub('\\', '')
+          if m[1] == RS
+            # we have to use sub since we aren't sure it's the first char
+            m[0].sub RS, ''
           else
             (callout_marks[lineno] ||= []) << m[3]
             last = lineno
             nil
           end
         }
-      } * EOL
+      } * LF
       callout_on_last = (last == lineno)
       callout_marks = nil if callout_marks.empty?
     else
@@ -1456,7 +1393,7 @@ module Substitutors
 
     case highlighter
     when 'coderay'
-      if (linenums_mode = (attr? 'linenums') ? (@document.attributes['coderay-linenums-mode'] || :table).to_sym : nil)
+      if (linenums_mode = (attr? 'linenums', nil, false) ? (@document.attributes['coderay-linenums-mode'] || :table).to_sym : nil)
         if attr? 'highlight', nil, false
           highlight_lines = resolve_highlight_lines(attr 'highlight', nil, false)
         end
@@ -1468,8 +1405,9 @@ module Substitutors
           :highlight_lines => highlight_lines,
           :bold_every => false}].highlight source
     when 'pygments'
-      lexer = ::Pygments::Lexer[attr('language', nil, false)] || ::Pygments::Lexer['text']
-      opts = { :cssclass => 'pyhl', :classprefix => 'tok-', :nobackground => true }
+      lexer = ::Pygments::Lexer.find_by_alias(attr 'language', 'text', false) || ::Pygments::Lexer.find_by_mimetype('text/plain')
+      opts = { :cssclass => 'pyhl', :classprefix => 'tok-', :nobackground => true, :stripnl => false }
+      opts[:startinline] = !(option? 'mixed') if lexer.name == 'PHP'
       unless (@document.attributes['pygments-css'] || 'class') == 'class'
         opts[:noclasses] = true
         opts[:style] = (@document.attributes['pygments-style'] || Stylesheets::DEFAULT_PYGMENTS_STYLE)
@@ -1479,56 +1417,42 @@ module Substitutors
           opts[:hl_lines] = highlight_lines * ' '
         end
       end
-      if attr? 'linenums'
-        # TODO we could add the line numbers in ourselves instead of having to strip out the junk
-        # FIXME move these regular expressions into constants
-        if (opts[:linenos] = @document.attributes['pygments-linenums-mode'] || 'table') == 'table'
-          linenums_mode = :table
-          # NOTE these subs clean out HTML that messes up our styles
-          result = lexer.highlight(source, :options => opts).
-              sub(/<div class="pyhl">(.*)<\/div>/m, '\1').
-              gsub(/<pre[^>]*>(.*?)<\/pre>\s*/m, '\1')
-        else
-          result = lexer.highlight(source, :options => opts).
-              sub(/<div class="pyhl"><pre[^>]*>(.*?)<\/pre><\/div>/m, '\1')
-        end
+      # TODO we could add the line numbers in ourselves instead of having to strip out the junk
+      if (attr? 'linenums', nil, false) && (opts[:linenos] = @document.attributes['pygments-linenums-mode'] || 'table') == 'table'
+        linenums_mode = :table
+        result = lexer.highlight(source, :options => opts).sub(PygmentsWrapperDivRx, '\1').gsub(PygmentsWrapperPreRx, '\1')
       else
-        # nowrap gives us just the highlighted source; won't work when we need linenums though
-        opts[:nowrap] = true
-        result = lexer.highlight(source, :options => opts)
+        if PygmentsWrapperPreRx =~ (result = lexer.highlight(source, :options => opts))
+          result = $1
+        end
       end
     end
 
     # fix passthrough placeholders that got caught up in syntax highlighting
     unless @passthroughs.empty?
-      result = result.gsub PASS_MATCH_HI, %(#{PASS_START}\\1#{PASS_END})
+      result = result.gsub HighlightedPassSlotRx, %(#{PASS_START}\\1#{PASS_END})
     end
 
     if process_callouts && callout_marks
       lineno = 0
       reached_code = linenums_mode != :table
-      result.split(EOL).map {|line|
+      result.split(LF, -1).map {|line|
         unless reached_code
-          unless line.include?('<td class="code">')
-            next line
-          end
+          next line unless line.include?('<td class="code">')
           reached_code = true
         end
-        lineno = lineno + 1
+        lineno += 1
         if (conums = callout_marks.delete(lineno))
           tail = nil
-          if callout_on_last && callout_marks.empty?
-            # QUESTION when does this happen?
-            if (pos = line.index '</pre>')
-              tail = line[pos..-1]
-              line = %(#{line[0...pos].chomp ' '} )
-            else
-              # Give conum on final line breathing room if trailing space in source is dropped
-              line = %(#{line.chomp ' '} )
+          if callout_on_last && callout_marks.empty? && linenums_mode == :table
+            if highlighter == 'coderay' && (pos = line.index '</pre>')
+              line, tail = (line.slice 0, pos), (line.slice pos, line.length)
+            elsif highlighter == 'pygments' && (pos = line.start_with? '</td>')
+              line, tail = '', line
             end
           end
           if conums.size == 1
-            %(#{line}#{Inline.new(self, :callout, conums[0], :id => @document.callouts.read_next_id).convert }#{tail})
+            %(#{line}#{Inline.new(self, :callout, conums[0], :id => @document.callouts.read_next_id).convert}#{tail})
           else
             conums_markup = conums.map {|conum| Inline.new(self, :callout, conum, :id => @document.callouts.read_next_id).convert } * ' '
             %(#{line}#{conums_markup}#{tail})
@@ -1536,7 +1460,7 @@ module Substitutors
         else
           line
         end
-      } * EOL
+      } * LF
     else
       result
     end
@@ -1545,7 +1469,7 @@ module Substitutors
   # e.g., highlight="1-5, !2, 10" or highlight=1-5;!2,10
   def resolve_highlight_lines spec
     lines = []
-    spec.delete(' ').split(DataDelimiterRx).map do |entry|
+    ((spec.include? ' ') ? (spec.delete ' ') : spec).split(DataDelimiterRx).map do |entry|
       negate = false
       if entry.start_with? '!'
         entry = entry[1..-1]
@@ -1577,54 +1501,48 @@ module Substitutors
   #
   # returns the substituted source
   def sub_source source, process_callouts
-    return process_callouts ? sub_callouts(sub_specialchars(source)) : sub_specialchars(source)
+    process_callouts ? sub_callouts(sub_specialchars source) : (sub_specialchars source)
   end
 
   # Internal: Lock-in the substitutions for this block
   #
-  # Looks for an attribute named "subs". If present, resolves the
-  # substitutions and assigns it to the subs property on this block.
-  # Otherwise, assigns a set of default substitutions based on the
-  # content model of the block.
+  # Looks for an attribute named "subs". If present, resolves substitutions
+  # from the value of that attribute and assigns them to the subs property on
+  # this block. Otherwise, uses the substitutions assigned to the default_subs
+  # property, if specified, or selects a default set of substitutions based on
+  # the content model of the block.
   #
-  # Returns nothing
+  # Returns The Array of resolved substitutions now assigned to this block
   def lock_in_subs
-    if @default_subs
-      default_subs = @default_subs
-    else
+    unless (default_subs = @default_subs)
       case @content_model
       when :simple
-        default_subs = SUBS[:normal]
+        default_subs = NORMAL_SUBS
       when :verbatim
         if @context == :listing || (@context == :literal && !(option? 'listparagraph'))
-          default_subs = SUBS[:verbatim]
+          default_subs = VERBATIM_SUBS
         elsif @context == :verse
-          default_subs = SUBS[:normal]
+          default_subs = NORMAL_SUBS
         else
-          default_subs = SUBS[:basic]
+          default_subs = BASIC_SUBS
         end
       when :raw
-        if @context == :stem
-          default_subs = SUBS[:basic]
-        else
-          default_subs = SUBS[:pass]
-        end
+        # TODO make pass subs a compliance setting; AsciiDoc Python performs :attributes and :macros on a pass block
+        default_subs = @context == :stem ? BASIC_SUBS : NONE_SUBS
       else
-        return
+        return @subs
       end
     end
 
-    if (custom_subs = @attributes['subs'])
-      @subs = resolve_block_subs custom_subs, default_subs, @context
-    else
-      @subs = default_subs.dup
-    end
+    @subs = (custom_subs = @attributes['subs']) ? (resolve_block_subs custom_subs, default_subs, @context) : default_subs.dup
 
     # QUESION delegate this logic to a method?
-    if @context == :listing && @style == 'source' && @attributes['language'] &&
-        @document.basebackend?('html') && SUB_HIGHLIGHT.include?(@document.attributes['source-highlighter'])
-      @subs = @subs.map {|sub| sub == :specialcharacters ? :highlight : sub }
+    if @context == :listing && @style == 'source' && (@attributes.key? 'language') && (@document.basebackend? 'html') &&
+        (SUB_HIGHLIGHT.include? @document.attributes['source-highlighter']) && (idx = @subs.index :specialcharacters)
+      @subs[idx] = :highlight
     end
+
+    @subs
   end
 end
 end