kramdown 0.14.2 → 2.3.0

data/lib/kramdown/parser.rb

@@ -1,22 +1,9 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
-# This file is part of kramdown.
-#
-# kramdown is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# This file is part of kramdown which is licensed under the MIT.
 #++
 #
 

data/lib/kramdown/parser/base.rb

@@ -1,25 +1,15 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
-# This file is part of kramdown.
-#
-# kramdown is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
+require 'kramdown/utils'
+require 'kramdown/parser'
+
 module Kramdown
 
   module Parser
@@ -27,7 +17,7 @@ module Kramdown
     # == \Base class for parsers
     #
     # This class serves as base class for parsers. It provides common methods that can/should be
-    # used by all parsers, especially by those using StringScanner for parsing.
+    # used by all parsers, especially by those using StringScanner(Kramdown) for parsing.
     #
     # A parser object is used as a throw-away object, i.e. it is only used for storing the needed
     # state information during parsing. Therefore one can't instantiate a parser object directly but
@@ -62,7 +52,8 @@ module Kramdown
       def initialize(source, options)
         @source = source
         @options = Kramdown::Options.merge(options)
-        @root = Element.new(:root, nil, nil, :encoding => (source.encoding rescue nil))
+        @root = Element.new(:root, nil, nil, encoding: (source.encoding rescue nil), location: 1,
+                            options: {}, abbrev_defs: {}, abbrev_attr: {})
         @warnings = []
         @text_type = :text
       end
@@ -92,22 +83,30 @@ module Kramdown
       # Add the given warning +text+ to the warning array.
       def warning(text)
         @warnings << text
-        #TODO: add position information
+        # TODO: add position information
       end
 
       # Modify the string +source+ to be usable by the parser (unifies line ending characters to
       # +\n+ and makes sure +source+ ends with a new line character).
       def adapt_source(source)
-        source.gsub(/\r\n?/, "\n").chomp + "\n"
+        unless source.valid_encoding?
+          raise "The source text contains invalid characters for the used encoding #{source.encoding}"
+        end
+        source = source.encode('UTF-8')
+        source.gsub!(/\r\n?/, "\n")
+        source.chomp!
+        source << "\n"
       end
 
       # This helper method adds the given +text+ either to the last element in the +tree+ if it is a
       # +type+ element or creates a new text element with the given +type+.
       def add_text(text, tree = @tree, type = @text_type)
-        if tree.children.last && tree.children.last.type == type
-          tree.children.last.value << text
+        last = tree.children.last
+        if last && last.type == type
+          last.value << text
         elsif !text.empty?
-          tree.children << Element.new(type, text)
+          location = (last && last.options[:location] || tree.options[:location])
+          tree.children << Element.new(type, text, nil, location: location)
         end
       end
 
@@ -115,16 +114,12 @@ module Kramdown
       # method works correctly under Ruby 1.8 and Ruby 1.9.
       def extract_string(range, strscan)
         result = nil
-        if strscan.string.respond_to?(:encoding)
-          begin
-            enc = strscan.string.encoding
-            strscan.string.force_encoding('ASCII-8BIT')
-            result = strscan.string[range].force_encoding(enc)
-          ensure
-            strscan.string.force_encoding(enc)
-          end
-        else
-          result = strscan.string[range]
+        begin
+          enc = strscan.string.encoding
+          strscan.string.force_encoding('ASCII-8BIT')
+          result = strscan.string[range].force_encoding(enc)
+        ensure
+          strscan.string.force_encoding(enc)
         end
         result
       end

data/lib/kramdown/parser/html.rb

@@ -1,33 +1,22 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2012 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
-# This file is part of kramdown.
-#
-# kramdown is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# This file is part of kramdown which is licensed under the MIT.
 #++
 #
 
 require 'rexml/parsers/baseparser'
 require 'strscan'
+require 'kramdown/utils'
+require 'kramdown/parser'
 
 module Kramdown
 
   module Parser
 
-    # Used for parsing a HTML document.
+    # Used for parsing an HTML document.
     #
     # The parsing code is in the Parser module that can also be used by other parsers.
     class Html < Base
@@ -40,38 +29,47 @@ module Kramdown
         HTML_DOCTYPE_RE = /<!DOCTYPE.*?>/im
         HTML_COMMENT_RE = /<!--(.*?)-->/m
         HTML_INSTRUCTION_RE = /<\?(.*?)\?>/m
-        HTML_ATTRIBUTE_RE = /\s*(#{REXML::Parsers::BaseParser::UNAME_STR})(?:\s*=\s*(["'])(.*?)\2)?/m
-        HTML_TAG_RE = /<((?>#{REXML::Parsers::BaseParser::UNAME_STR}))\s*((?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}(?:\s*=\s*(["']).*?\3)?)*)\s*(\/)?>/m
+        HTML_ATTRIBUTE_RE = /\s*(#{REXML::Parsers::BaseParser::UNAME_STR})(?:\s*=\s*(?:(\p{Word}+)|("|')(.*?)\3))?/m
+        HTML_TAG_RE = /<((?>#{REXML::Parsers::BaseParser::UNAME_STR}))\s*((?>\s+#{REXML::Parsers::BaseParser::UNAME_STR}(?:\s*=\s*(?:\p{Word}+|("|').*?\3))?)*)\s*(\/)?>/m
         HTML_TAG_CLOSE_RE = /<\/(#{REXML::Parsers::BaseParser::UNAME_STR})\s*>/m
         HTML_ENTITY_RE = /&([\w:][\-\w\.:]*);|&#(\d+);|&\#x([0-9a-fA-F]+);/
 
-        HTML_CONTENT_MODEL_BLOCK = %w{address applet article aside button blockquote body
-             dd div dl fieldset figure figcaption footer form header hgroup iframe li map menu nav
-              noscript object section td}
-        HTML_CONTENT_MODEL_SPAN  = %w{a abbr acronym b bdo big button cite caption del dfn dt em
-             h1 h2 h3 h4 h5 h6 i ins kbd label legend optgroup p q rb rbc
-             rp rt rtc ruby samp select small span strong sub sup summary th tt var}
-        HTML_CONTENT_MODEL_RAW   = %w{script style math option textarea pre code}
+        HTML_CONTENT_MODEL_BLOCK = %w[address applet article aside blockquote body
+                                      dd details div dl fieldset figure figcaption
+                                      footer form header hgroup iframe li main
+                                      map menu nav noscript object section summary td]
+        HTML_CONTENT_MODEL_SPAN  = %w[a abbr acronym b bdo big button cite caption del dfn dt em
+                                      h1 h2 h3 h4 h5 h6 i ins label legend optgroup p q rb rbc
+                                      rp rt rtc ruby select small span strong sub sup th tt]
+        HTML_CONTENT_MODEL_RAW   = %w[script style math option textarea pre code kbd samp var]
         # The following elements are also parsed as raw since they need child elements that cannot
         # be expressed using kramdown syntax: colgroup table tbody thead tfoot tr ul ol
 
-        HTML_CONTENT_MODEL = Hash.new {|h,k| h[k] = :raw}
-        HTML_CONTENT_MODEL_BLOCK.each {|i| HTML_CONTENT_MODEL[i] = :block}
-        HTML_CONTENT_MODEL_SPAN.each {|i| HTML_CONTENT_MODEL[i] = :span}
-        HTML_CONTENT_MODEL_RAW.each {|i| HTML_CONTENT_MODEL[i] = :raw}
+        HTML_CONTENT_MODEL = Hash.new {|h, k| h[k] = :raw }
+        HTML_CONTENT_MODEL_BLOCK.each {|i| HTML_CONTENT_MODEL[i] = :block }
+        HTML_CONTENT_MODEL_SPAN.each {|i| HTML_CONTENT_MODEL[i] = :span }
+        HTML_CONTENT_MODEL_RAW.each {|i| HTML_CONTENT_MODEL[i] = :raw }
 
         # Some HTML elements like script belong to both categories (i.e. are valid in block and
         # span HTML) and don't appear therefore!
-        HTML_SPAN_ELEMENTS = %w{a abbr acronym b big bdo br button cite code del dfn em i img input
-                              ins kbd label option q rb rbc rp rt rtc ruby samp select small span
-                              strong sub sup textarea tt var}
-        HTML_BLOCK_ELEMENTS = %w{address article aside applet body button blockquote caption col colgroup dd div dl dt fieldset
-                               figcaption footer form h1 h2 h3 h4 h5 h6 header hgroup hr html head iframe legend menu
-                               li map nav ol optgroup p pre section summary table tbody td th thead tfoot tr ul}
-        HTML_ELEMENTS_WITHOUT_BODY = %w{area base br col command embed hr img input keygen link meta param source track wbr}
+        # script, textarea
+        HTML_SPAN_ELEMENTS = %w[a abbr acronym b big bdo br button cite code del dfn em i img input
+                                ins kbd label mark option q rb rbc rp rt rtc ruby samp select small
+                                span strong sub sup tt u var]
+        HTML_BLOCK_ELEMENTS = %w[address article aside applet body blockquote caption col colgroup
+                                 dd div dl dt fieldset figcaption footer form h1 h2 h3 h4 h5 h6
+                                 header hgroup hr html head iframe legend menu li main map nav ol
+                                 optgroup p pre section summary table tbody td th thead tfoot tr ul]
+        HTML_ELEMENTS_WITHOUT_BODY = %w[area base br col command embed hr img input keygen link
+                                        meta param source track wbr]
+
+        HTML_ELEMENT = Hash.new(false)
+        (HTML_SPAN_ELEMENTS + HTML_BLOCK_ELEMENTS + HTML_ELEMENTS_WITHOUT_BODY +
+         HTML_CONTENT_MODEL.keys).each do |a|
+          HTML_ELEMENT[a] = true
+        end
       end
 
-
       # Contains the parsing methods. This module can be mixed into any parser to get HTML parsing
       # functionality. The only thing that must be provided by the class are instance variable
       # @stack for storing the needed state and @src (instance of StringScanner) for the actual
@@ -86,17 +84,17 @@ module Kramdown
         # (first parameter is the created element; the second parameter is +true+ if the HTML
         # element is already closed, ie. contains no body; the third parameter specifies whether the
         # body - and the end tag - need to be handled in case closed=false).
-        def handle_html_start_tag # :yields: el, closed, handle_body
-          name = @src[1].downcase
+        def handle_html_start_tag(line = nil) # :yields: el, closed, handle_body
+          name = @src[1]
+          name.downcase! if HTML_ELEMENT[name.downcase]
           closed = !@src[4].nil?
-          attrs = Utils::OrderedHash.new
-          @src[2].scan(HTML_ATTRIBUTE_RE).each {|attr,sep,val| attrs[attr.downcase] = val || ""}
+          attrs = parse_html_attributes(@src[2], line, HTML_ELEMENT[name])
 
-          el = Element.new(:html_element, name, attrs, :category => :block)
+          el = Element.new(:html_element, name, attrs, category: :block)
+          el.options[:location] = line if line
           @tree.children << el
 
           if !closed && HTML_ELEMENTS_WITHOUT_BODY.include?(el.value)
-            warning("The HTML tag '#{el.value}' cannot have any content - auto-closing it")
             closed = true
           end
           if name == 'script' || name == 'style'
@@ -107,6 +105,24 @@ module Kramdown
           end
         end
 
+        # Parses the given string for HTML attributes and returns the resulting hash.
+        #
+        # If the optional +line+ parameter is supplied, it is used in warning messages.
+        #
+        # If the optional +in_html_tag+ parameter is set to +false+, attributes are not modified to
+        # contain only lowercase letters.
+        def parse_html_attributes(str, line = nil, in_html_tag = true)
+          attrs = {}
+          str.scan(HTML_ATTRIBUTE_RE).each do |attr, val, _sep, quoted_val|
+            attr.downcase! if in_html_tag
+            if attrs.key?(attr)
+              warning("Duplicate HTML attribute '#{attr}' on line #{line || '?'} - overwriting previous one")
+            end
+            attrs[attr] = val || quoted_val || ""
+          end
+          attrs
+        end
+
         # Handle the raw HTML tag at the current position.
         def handle_raw_html_tag(name)
           curpos = @src.pos
@@ -137,19 +153,26 @@ module Kramdown
 
           done = false
           while !@src.eos? && !done
-            if result = @src.scan_until(HTML_RAW_START)
+            if (result = @src.scan_until(HTML_RAW_START))
               add_text(result, @tree, :text)
-              if result = @src.scan(HTML_COMMENT_RE)
-                @tree.children << Element.new(:xml_comment, result, nil, :category => :block)
-              elsif result = @src.scan(HTML_INSTRUCTION_RE)
-                @tree.children << Element.new(:xml_pi, result, nil, :category => :block)
+              line = @src.current_line_number
+              if (result = @src.scan(HTML_COMMENT_RE))
+                @tree.children << Element.new(:xml_comment, result, nil, category: :block, location: line)
+              elsif (result = @src.scan(HTML_INSTRUCTION_RE))
+                @tree.children << Element.new(:xml_pi, result, nil, category: :block, location: line)
               elsif @src.scan(HTML_TAG_RE)
-                handle_html_start_tag(&block)
+                if method(:handle_html_start_tag).arity.abs >= 1
+                  handle_html_start_tag(line, &block)
+                else
+                  handle_html_start_tag(&block) # DEPRECATED: method needs to accept line number in 2.0
+                end
               elsif @src.scan(HTML_TAG_CLOSE_RE)
-                if @tree.value == @src[1].downcase
+                if @tree.value == (HTML_ELEMENT[@tree.value] ? @src[1].downcase : @src[1])
                   done = true
                 else
-                  warning("Found invalidly used HTML closing tag for '#{@src[1].downcase}' - ignoring it")
+                  add_text(@src.matched, @tree, :text)
+                  warning("Found invalidly used HTML closing tag for '#{@src[1]}' on " \
+                          "line #{line} - ignoring it")
                 end
               else
                 add_text(@src.getch, @tree, :text)
@@ -157,7 +180,10 @@ module Kramdown
             else
               add_text(@src.rest, @tree, :text)
               @src.terminate
-              warning("Found no end tag for '#{@tree.value}' - auto-closing it") if @tree.type == :html_element
+              if @tree.type == :html_element
+                warning("Found no end tag for '#{@tree.value}' on line " \
+                        "#{@tree.options[:location]} - auto-closing it")
+              end
               done = true
             end
           end
@@ -167,7 +193,6 @@ module Kramdown
 
       end
 
-
       # Converts HTML elements to native elements if possible.
       class ElementConverter
 
@@ -176,14 +201,17 @@ module Kramdown
         include Constants
         include ::Kramdown::Utils::Entities
 
-        REMOVE_TEXT_CHILDREN =  %w{html head hgroup ol ul dl table colgroup tbody thead tfoot tr select optgroup}
-        WRAP_TEXT_CHILDREN = %w{body section nav article aside header footer address div li dd blockquote figure
-                                figcaption fieldset form}
-        REMOVE_WHITESPACE_CHILDREN = %w{body section nav article aside header footer address
-                                        div li dd blockquote figure figcaption td th fieldset form}
-        STRIP_WHITESPACE = %w{address article aside blockquote body caption dd div dl dt fieldset figcaption form footer
-                              header h1 h2 h3 h4 h5 h6 legend li nav p section td th}
-        SIMPLE_ELEMENTS = %w{em strong blockquote hr br img p thead tbody tfoot tr td th ul ol dl li dl dt dd}
+        REMOVE_TEXT_CHILDREN = %w[html head hgroup ol ul dl table colgroup tbody thead tfoot tr
+                                  select optgroup]
+        WRAP_TEXT_CHILDREN = %w[body section nav article aside header footer address div li dd
+                                blockquote figure figcaption fieldset form]
+        REMOVE_WHITESPACE_CHILDREN = %w[body section nav article aside header footer address
+                                        div li dd blockquote figure figcaption td th fieldset form]
+        STRIP_WHITESPACE = %w[address article aside blockquote body caption dd div dl dt fieldset
+                              figcaption form footer header h1 h2 h3 h4 h5 h6 legend li nav p
+                              section td th]
+        SIMPLE_ELEMENTS = %w[em strong blockquote hr br img p thead tbody tfoot tr td th ul ol dl
+                             li dl dt dd]
 
         def initialize(root)
           @root = root
@@ -208,11 +236,11 @@ module Kramdown
                       else parent.type.to_s
                       end
                     end
-            el.options.replace({:category => (HTML_CONTENT_MODEL[ptype] == :span ? :span : :block)})
+            el.options.replace(category: (HTML_CONTENT_MODEL[ptype] == :span ? :span : :block))
             return
           when :html_element
           when :root
-            el.children.each {|c| process(c)}
+            el.children.each {|c| process(c) }
             remove_whitespace_children(el)
             return
           else return
@@ -255,20 +283,20 @@ module Kramdown
         # entities in entity elements.
         def process_text(raw, preserve = false)
           raw.gsub!(/\s+/, ' ') unless preserve
-          src = StringScanner.new(raw)
+          src = Kramdown::Utils::StringScanner.new(raw)
           result = []
-          while !src.eos?
-            if tmp = src.scan_until(/(?=#{HTML_ENTITY_RE})/)
+          until src.eos?
+            if (tmp = src.scan_until(/(?=#{HTML_ENTITY_RE})/o))
               result << Element.new(:text, tmp)
               src.scan(HTML_ENTITY_RE)
-              val = src[1] || (src[2] && src[2].to_i) || src[3].hex
-              result << if %w{lsquo rsquo ldquo rdquo}.include?(val)
+              val = src[1] || (src[2]&.to_i) || src[3].hex
+              result << if %w[lsquo rsquo ldquo rdquo].include?(val)
                           Element.new(:smart_quote, val.intern)
-                        elsif %w{mdash ndash hellip laquo raquo}.include?(val)
+                        elsif %w[mdash ndash hellip laquo raquo].include?(val)
                           Element.new(:typographic_sym, val.intern)
                         else
                           begin
-                            Element.new(:entity, entity(val), nil, :original => src.matched)
+                            Element.new(:entity, entity(val), nil, original: src.matched)
                           rescue ::Kramdown::Error
                             src.pos -= src.matched_size - 1
                             Element.new(:entity, ::Kramdown::Utils::Entities.entity('amp'))
@@ -283,22 +311,22 @@ module Kramdown
         end
 
         def process_html_element(el, do_conversion = true, preserve_text = false)
-          el.options.replace(:category => HTML_SPAN_ELEMENTS.include?(el.value) ? :span : :block,
-                             :content_model => (do_conversion ? HTML_CONTENT_MODEL[el.value] : :raw))
+          el.options.replace(category: HTML_SPAN_ELEMENTS.include?(el.value) ? :span : :block,
+                             content_model: (do_conversion ? HTML_CONTENT_MODEL[el.value] : :raw))
           process_children(el, do_conversion, preserve_text)
         end
 
         def remove_text_children(el)
-          el.children.delete_if {|c| c.type == :text}
+          el.children.delete_if {|c| c.type == :text }
         end
 
         def wrap_text_children(el)
           tmp = []
           last_is_p = false
           el.children.each do |c|
-            if Element.category(c) != :block || c.type == :text
-              if !last_is_p
-                tmp << Element.new(:p, nil, nil, :transparent => true)
+            if !c.block? || c.type == :text
+              unless last_is_p
+                tmp << Element.new(:p, nil, nil, transparent: true)
                 last_is_p = true
               end
               tmp.last.children << c
@@ -326,8 +354,8 @@ module Kramdown
           el.children = el.children.reject do |c|
             i += 1
             c.type == :text && c.value.strip.empty? &&
-              (i == 0 || i == el.children.length - 1 || (Element.category(el.children[i-1]) == :block &&
-                                                         Element.category(el.children[i+1]) == :block))
+              (i == 0 || i == el.children.length - 1 || ((el.children[i - 1]).block? &&
+                                                         (el.children[i + 1]).block?))
           end
         end
 
@@ -339,7 +367,11 @@ module Kramdown
 
         def extract_text(el, raw)
           raw << el.value.to_s if el.type == :text
-          el.children.each {|c| extract_text(c, raw)}
+          el.children.each {|c| extract_text(c, raw) }
+        end
+
+        def convert_textarea(el)
+          process_html_element(el, true, true)
         end
 
         def convert_a(el)
@@ -353,7 +385,7 @@ module Kramdown
 
         EMPHASIS_TYPE_MAP = {'em' => :em, 'i' => :em, 'strong' => :strong, 'b' => :strong}
         def convert_em(el)
-          text = ''
+          text = +''
           extract_text(el, text)
           if text =~ /\A\s/ || text =~ /\s\z/
             process_html_element(el, false)
@@ -362,53 +394,53 @@ module Kramdown
             process_children(el)
           end
         end
-        %w{b strong i}.each do |i|
+        %w[b strong i].each do |i|
           alias_method("convert_#{i}".to_sym, :convert_em)
         end
 
         def convert_h1(el)
-          set_basics(el, :header, :level => el.value[1..1].to_i)
-          extract_text(el, el.options[:raw_text] = '')
+          set_basics(el, :header, level: el.value[1..1].to_i)
+          extract_text(el, el.options[:raw_text] = +'')
           process_children(el)
         end
-        %w{h2 h3 h4 h5 h6}.each do |i|
+        %w[h2 h3 h4 h5 h6].each do |i|
           alias_method("convert_#{i}".to_sym, :convert_h1)
         end
 
         def convert_code(el)
-          raw = ''
+          raw = +''
           extract_text(el, raw)
           result = process_text(raw, true)
           begin
-            str = result.inject('') do |mem, c|
+            str = result.inject(+'') do |mem, c|
               if c.type == :text
                 mem << c.value
               elsif c.type == :entity
-                value_char = c.value.char
-                if value_char.respond_to?(:encode)
-                  mem << value_char.encode(@root.options[:encoding])
-                elsif [60, 62, 34, 38].include?(c.value.code_point)
-                  mem << c.value.code_point.chr
-                end
+                mem << if [60, 62, 34, 38].include?(c.value.code_point)
+                         c.value.code_point.chr
+                       else
+                         c.value.char
+                       end
               elsif c.type == :smart_quote || c.type == :typographic_sym
-                mem << entity(c.value.to_s).char.encode(@root.options[:encoding])
+                mem << entity(c.value.to_s).char
               else
                 raise "Bug - please report"
               end
             end
             result.clear
             result << Element.new(:text, str)
-          rescue
+          rescue StandardError
           end
           if result.length > 1 || result.first.type != :text
             process_html_element(el, false, true)
           else
             if el.value == 'code'
               set_basics(el, :codespan)
+              el.attr['class']&.gsub!(/\s+\bhighlighter-\w+\b|\bhighlighter-\w+\b\s*/, '')
             else
               set_basics(el, :codeblock)
               if el.children.size == 1 && el.children.first.value == 'code'
-                value = (el.children.first.attr['class'] || '').scan(/\blanguage-\w+\b/).first
+                value = (el.children.first.attr['class'] || '').scan(/\blanguage-\S+/).first
                 el.attr['class'] = "#{value} #{el.attr['class']}".rstrip if value
               end
             end
@@ -416,10 +448,10 @@ module Kramdown
             el.children.clear
           end
         end
-        alias :convert_pre :convert_code
+        alias convert_pre convert_code
 
         def convert_table(el)
-          if !is_simple_table?(el)
+          unless is_simple_table?(el)
             process_html_element(el, false)
             return
           end
@@ -433,23 +465,23 @@ module Kramdown
                 if td.attr['style']
                   td.attr['style'].slice!(/(?:;\s*)?text-align:\s+(center|left|right)/)
                   td.attr.delete('style') if td.attr['style'].strip.empty?
-                  $1.to_sym
+                  $1 ? $1.to_sym : :default
                 else
                   :default
                 end
               end
             else
-              c.children.each {|cc| calc_alignment.call(cc)}
+              c.children.each {|cc| calc_alignment.call(cc) }
             end
           end
           calc_alignment.call(el)
-          el.children.delete_if {|c| c.type == :html_element}
+          el.children.delete_if {|c| c.type == :html_element }
 
           change_th_type = lambda do |c|
             if c.type == :th
               c.type = :td
             else
-              c.children.each {|cc| change_th_type.call(cc)}
+              c.children.each {|cc| change_th_type.call(cc) }
             end
           end
           change_th_type.call(el)
@@ -467,11 +499,11 @@ module Kramdown
               (cc.type == :text || !HTML_BLOCK_ELEMENTS.include?(cc.value)) && only_phrasing_content.call(cc)
             end
           end
-          check_cells = Proc.new do |c|
+          check_cells = proc do |c|
             if c.value == 'th' || c.value == 'td'
-              return false if !only_phrasing_content.call(c)
+              return false unless only_phrasing_content.call(c)
             else
-              c.children.each {|cc| check_cells.call(cc)}
+              c.children.each {|cc| check_cells.call(cc) }
             end
           end
           check_cells.call(el)
@@ -479,7 +511,7 @@ module Kramdown
           nr_cells = 0
           check_nr_cells = lambda do |t|
             if t.value == 'tr'
-              count = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.length
+              count = t.children.select {|cc| cc.value == 'th' || cc.value == 'td' }.length
               if count != nr_cells
                 if nr_cells == 0
                   nr_cells = count
@@ -489,16 +521,16 @@ module Kramdown
                 end
               end
             else
-              t.children.each {|cc| check_nr_cells.call(cc)}
+              t.children.each {|cc| check_nr_cells.call(cc) }
             end
           end
           check_nr_cells.call(el)
           return false if nr_cells == -1
 
           alignment = nil
-          check_alignment = Proc.new do |t|
+          check_alignment = proc do |t|
             if t.value == 'tr'
-              cur_alignment = t.children.select {|cc| cc.value == 'th' || cc.value == 'td'}.map do |cell|
+              cur_alignment = t.children.select {|cc| cc.value == 'th' || cc.value == 'td' }.map do |cell|
                 md = /text-align:\s+(center|left|right|justify|inherit)/.match(cell.attr['style'].to_s)
                 return false if md && (md[1] == 'justify' || md[1] == 'inherit')
                 md.nil? ? :default : md[1]
@@ -506,19 +538,19 @@ module Kramdown
               alignment = cur_alignment if alignment.nil?
               return false if alignment != cur_alignment
             else
-              t.children.each {|cc| check_alignment.call(cc)}
+              t.children.each {|cc| check_alignment.call(cc) }
             end
           end
           check_alignment.call(el)
 
           check_rows = lambda do |t, type|
-            t.children.all? {|r| (r.value == 'tr' || r.type == :text) && r.children.all? {|c| c.value == type || c.type == :text}}
+            t.children.all? {|r| (r.value == 'tr' || r.type == :text) && r.children.all? {|c| c.value == type || c.type == :text }}
           end
           check_rows.call(el, 'td') ||
             (el.children.all? do |t|
                t.type == :text || (t.value == 'thead' && check_rows.call(t, 'th')) ||
                  ((t.value == 'tfoot' || t.value == 'tbody') && check_rows.call(t, 'td'))
-             end && el.children.any? {|t| t.value == 'tbody'})
+             end && el.children.any? {|t| t.value == 'tbody' })
         end
 
         def convert_script(el)
@@ -534,7 +566,7 @@ module Kramdown
         end
 
         def handle_math_tag(el)
-          set_basics(el, :math, :category => (el.attr['type'] =~ /mode=display/ ? :block : :span))
+          set_basics(el, :math, category: (el.attr['type'] =~ /mode=display/ ? :block : :span))
           el.value = el.children.shift.value.sub(/\A(?:%\s*)?<!\[CDATA\[\n?(.*?)(?:\s%)?\]\]>\z/m, '\1')
           el.attr.delete('type')
         end
@@ -546,15 +578,15 @@ module Kramdown
       # Parse the source string provided on initialization as HTML document.
       def parse
         @stack, @tree = [], @root
-        @src = StringScanner.new(adapt_source(source))
+        @src = Kramdown::Utils::StringScanner.new(adapt_source(source))
 
         while true
-          if result = @src.scan(/\s*#{HTML_INSTRUCTION_RE}/)
-            @tree.children << Element.new(:xml_pi, result.strip, nil, :category => :block)
-          elsif result = @src.scan(/\s*#{HTML_DOCTYPE_RE}/)
+          if (result = @src.scan(/\s*#{HTML_INSTRUCTION_RE}/o))
+            @tree.children << Element.new(:xml_pi, result.strip, nil, category: :block)
+          elsif (result = @src.scan(/\s*#{HTML_DOCTYPE_RE}/o))
             # ignore the doctype
-          elsif result = @src.scan(/\s*#{HTML_COMMENT_RE}/)
-            @tree.children << Element.new(:xml_comment, result.strip, nil, :category => :block)
+          elsif (result = @src.scan(/\s*#{HTML_COMMENT_RE}/o))
+            @tree.children << Element.new(:xml_comment, result.strip, nil, category: :block)
           else
             break
           end