kramdown 1.17.0 → 2.0.0.beta1

data/lib/kramdown/parser/kramdown/math.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -29,7 +29,7 @@ module Kramdown
         @src.pos += @src.matched_size
         data = @src[2].strip
         if before_block_boundary?
-          @tree.children << new_block_el(:math, data, nil, :category => :block, :location => start_line_number)
+          @tree.children << new_block_el(:math, data, nil, category: :block, location: start_line_number)
           true
         else
           @src.revert_pos(saved_pos)
@@ -38,14 +38,13 @@ module Kramdown
       end
       define_parser(:block_math, BLOCK_MATH_START)
 
-
       INLINE_MATH_START = /\$\$(.*?)\$\$/m
 
       # Parse the inline math at the current location.
       def parse_inline_math
         start_line_number = @src.current_line_number
         @src.pos += @src.matched_size
-        @tree.children << Element.new(:math, @src[1].strip, nil, :category => :span, :location => start_line_number)
+        @tree.children << Element.new(:math, @src[1].strip, nil, category: :span, location: start_line_number)
       end
       define_parser(:inline_math, INLINE_MATH_START, '\$')
 

data/lib/kramdown/parser/kramdown/paragraph.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -17,7 +17,7 @@ module Kramdown
   module Parser
     class Kramdown
 
-      LAZY_END_HTML_SPAN_ELEMENTS = HTML_SPAN_ELEMENTS + %w{script}
+      LAZY_END_HTML_SPAN_ELEMENTS = HTML_SPAN_ELEMENTS + %w[script]
       LAZY_END_HTML_START = /<(?>(?!(?:#{LAZY_END_HTML_SPAN_ELEMENTS.join('|')})\b)#{REXML::Parsers::BaseParser::UNAME_STR})/
       LAZY_END_HTML_STOP = /<\/(?!(?:#{LAZY_END_HTML_SPAN_ELEMENTS.join('|')})\b)#{REXML::Parsers::BaseParser::UNAME_STR}\s*>/m
 
@@ -32,7 +32,7 @@ module Kramdown
         pos = @src.pos
         start_line_number = @src.current_line_number
         result = @src.scan(PARAGRAPH_MATCH)
-        while !@src.match?(paragraph_end)
+        until @src.match?(paragraph_end)
           result << @src.scan(PARAGRAPH_MATCH)
         end
         result.rstrip!
@@ -45,7 +45,7 @@ module Kramdown
             add_text(result, @tree.children.last)
           end
         else
-          @tree.children << new_block_el(:p, nil, nil, :location => start_line_number)
+          @tree.children << new_block_el(:p, nil, nil, location: start_line_number)
           result.lstrip!
           add_text(result, @tree.children.last)
         end

data/lib/kramdown/parser/kramdown/smart_quotes.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -122,25 +122,25 @@ module Kramdown
       SQ_CLOSE = %![^\ \\\\\t\r\n\\[{(-]!
 
       SQ_RULES = [
-                  [/("|')(?=[_*]{1,2}\S)/, [:lquote1]],
-                  [/("|')(?=#{SQ_PUNCT}(?!\.\.)\B)/, [:rquote1]],
-                  # Special case for double sets of quotes, e.g.:
-                  #   <p>He said, "'Quoted' words in a larger quote."</p>
-                  [/(\s?)"'(?=\w)/, [1, :ldquo, :lsquo]],
-                  [/(\s?)'"(?=\w)/, [1, :lsquo, :ldquo]],
-                  # Special case for decade abbreviations (the '80s):
-                  [/(\s?)'(?=\d\ds)/, [1, :rsquo]],
+        [/("|')(?=[_*]{1,2}\S)/, [:lquote1]],
+        [/("|')(?=#{SQ_PUNCT}(?!\.\.)\B)/, [:rquote1]],
+        # Special case for double sets of quotes, e.g.:
+        #   <p>He said, "'Quoted' words in a larger quote."</p>
+        [/(\s?)"'(?=\w)/, [1, :ldquo, :lsquo]],
+        [/(\s?)'"(?=\w)/, [1, :lsquo, :ldquo]],
+        # Special case for decade abbreviations (the '80s):
+        [/(\s?)'(?=\d\ds)/, [1, :rsquo]],
 
-                  # Get most opening single/double quotes:
-                  [/(\s)('|")(?=\w)/, [1, :lquote2]],
-                  # Single/double closing quotes:
-                  [/(#{SQ_CLOSE})('|")/, [1, :rquote2]],
-                  # Special case for e.g. "<i>Custer</i>'s Last Stand."
-                  [/("|')(?=\s|s\b|$)/, [:rquote1]],
-                  # Any remaining single quotes should be opening ones:
-                  [/(.?)'/m, [1, :lsquo]],
-                  [/(.?)"/m, [1, :ldquo]],
-                 ] #'"
+        # Get most opening single/double quotes:
+        [/(\s)('|")(?=\w)/, [1, :lquote2]],
+        # Single/double closing quotes:
+        [/(#{SQ_CLOSE})('|")/, [1, :rquote2]],
+        # Special case for e.g. "<i>Custer</i>'s Last Stand."
+        [/("|')(?=\s|s\b|$)/, [:rquote1]],
+        # Any remaining single quotes should be opening ones:
+        [/(.?)'/m, [1, :lsquo]],
+        [/(.?)"/m, [1, :ldquo]],
+      ] # '"
 
       SQ_SUBSTS = {
         [:rquote1, '"'] => :rdquo,
@@ -157,13 +157,13 @@ module Kramdown
       # Parse the smart quotes at current location.
       def parse_smart_quotes
         start_line_number = @src.current_line_number
-        substs = SQ_RULES.find {|reg, subst| @src.scan(reg)}[1]
+        substs = SQ_RULES.find {|reg, _subst| @src.scan(reg) }[1]
         substs.each do |subst|
           if subst.kind_of?(Integer)
             add_text(@src[subst])
           else
-            val = SQ_SUBSTS[[subst, @src[subst.to_s[-1,1].to_i]]] || subst
-            @tree.children << Element.new(:smart_quote, val, nil, :location => start_line_number)
+            val = SQ_SUBSTS[[subst, @src[subst.to_s[-1, 1].to_i]]] || subst
+            @tree.children << Element.new(:smart_quote, val, nil, location: start_line_number)
           end
         end
       end

data/lib/kramdown/parser/kramdown/table.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -23,11 +23,11 @@ module Kramdown
 
       # Parse the table at the current location.
       def parse_table
-        return false if !after_block_boundary?
+        return false unless after_block_boundary?
 
         saved_pos = @src.save_pos
         orig_pos = @src.pos
-        table = new_block_el(:table, nil, nil, :alignment => [], :location => @src.current_line_number)
+        table = new_block_el(:table, nil, nil, alignment: [], location: @src.current_line_number)
         leading_pipe = (@src.check(TABLE_LINE) =~ /^\s*\|/)
         @src.scan(TABLE_SEP_LINE)
 
@@ -43,21 +43,22 @@ module Kramdown
           end
         end
 
-        while !@src.eos?
-          break if !@src.check(TABLE_LINE)
+        until @src.eos?
+          break unless @src.check(TABLE_LINE)
           if @src.scan(TABLE_SEP_LINE)
             if rows.empty?
               # nothing to do, ignoring multiple consecutive separator lines
             elsif table.options[:alignment].empty? && !has_footer
               add_container.call(:thead, false)
               table.options[:alignment] = @src[1].scan(TABLE_HSEP_ALIGN).map do |left, right|
-                (left.empty? && right.empty? && :default) || (right.empty? && :left) || (left.empty? && :right) || :center
+                (left.empty? && right.empty? && :default) || (right.empty? && :left) ||
+                  (left.empty? && :right) || :center
               end
             else # treat as normal separator line
               add_container.call(:tbody, false)
             end
           elsif @src.scan(TABLE_FSEP_LINE)
-            add_container.call(:tbody, true) if !rows.empty?
+            add_container.call(:tbody, true) unless rows.empty?
             has_footer = true
           elsif @src.scan(TABLE_ROW_LINE)
             trow = Element.new(:tr)
@@ -66,16 +67,16 @@ module Kramdown
             env = save_env
             cells = []
             @src[1].split(/(<code.*?>.*?<\/code>)/).each_with_index do |str, i|
-              if i % 2 == 1
+              if i.odd?
                 (cells.empty? ? cells : cells.last) << str
               else
-                reset_env(:src => Kramdown::Utils::StringScanner.new(str, @src.current_line_number))
+                reset_env(src: Kramdown::Utils::StringScanner.new(str, @src.current_line_number))
                 root = Element.new(:root)
                 parse_spans(root, nil, [:codespan])
 
                 root.children.each do |c|
                   if c.type == :raw_text
-                    f, *l = c.value.split(/(?<!\\)\|/, -1).map {|t| t.gsub(/\\\|/, '|')}
+                    f, *l = c.value.split(/(?<!\\)\|/, -1).map {|t| t.gsub(/\\\|/, '|') }
                     (cells.empty? ? cells : cells.last) << f
                     cells.concat(l)
                   else
@@ -102,16 +103,16 @@ module Kramdown
           end
         end
 
-        if !before_block_boundary?
+        unless before_block_boundary?
           @src.revert_pos(saved_pos)
           return false
         end
 
         # Parse all lines of the table with the code span parser
         env = save_env
-        l_src = ::Kramdown::Utils::StringScanner.new(extract_string(orig_pos...(@src.pos-1), @src),
+        l_src = ::Kramdown::Utils::StringScanner.new(extract_string(orig_pos...(@src.pos - 1), @src),
                                                      @src.current_line_number)
-        reset_env(:src => l_src)
+        reset_env(src: l_src)
         root = Element.new(:root)
         parse_spans(root, nil, [:codespan, :span_html])
         restore_env(env)
@@ -135,11 +136,11 @@ module Kramdown
             pipe_on_line = (lines.size > 1 ? false : pipe_on_line) || (lines.last =~ /^#{TABLE_PIPE_CHECK}/)
           end
         end
-        @src.revert_pos(saved_pos) and return false if !pipe_on_line
+        @src.revert_pos(saved_pos) and return false unless pipe_on_line
 
-        add_container.call(has_footer ? :tfoot : :tbody, false) if !rows.empty?
+        add_container.call(has_footer ? :tfoot : :tbody, false) unless rows.empty?
 
-        if !table.children.any? {|el| el.type == :tbody}
+        if table.children.none? {|el| el.type == :tbody }
           warning("Found table without body on line #{table.options[:location]} - ignoring it")
           @src.revert_pos(saved_pos)
           return false

data/lib/kramdown/parser/kramdown/typographic_symbol.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -16,7 +16,7 @@ module Kramdown
                           ['<< ', :laquo_space], [' >>', :raquo_space],
                           ['<<', :laquo], ['>>', :raquo]]
       TYPOGRAPHIC_SYMS_SUBST = Hash[*TYPOGRAPHIC_SYMS.flatten]
-      TYPOGRAPHIC_SYMS_RE = /#{TYPOGRAPHIC_SYMS.map {|k,v| Regexp.escape(k)}.join('|')}/
+      TYPOGRAPHIC_SYMS_RE = /#{TYPOGRAPHIC_SYMS.map {|k, _v| Regexp.escape(k) }.join('|')}/
 
       # Parse the typographic symbols at the current location.
       def parse_typographic_syms
@@ -24,17 +24,17 @@ module Kramdown
         @src.pos += @src.matched_size
         val = TYPOGRAPHIC_SYMS_SUBST[@src.matched]
         if val.kind_of?(Symbol)
-          @tree.children << Element.new(:typographic_sym, val, nil, :location => start_line_number)
+          @tree.children << Element.new(:typographic_sym, val, nil, location: start_line_number)
         elsif @src.matched == '\\<<'
           @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
-                                        nil, :location => start_line_number)
+                                        nil, location: start_line_number)
           @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
-                                        nil, :location => start_line_number)
+                                        nil, location: start_line_number)
         else
           @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
-                                        nil, :location => start_line_number)
+                                        nil, location: start_line_number)
           @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
-                                        nil, :location => start_line_number)
+                                        nil, location: start_line_number)
         end
       end
       define_parser(:typographic_syms, TYPOGRAPHIC_SYMS_RE, '--|\\.\\.\\.|(?:\\\\| )?(?:<<|>>)')

data/lib/kramdown/parser/markdown.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -25,25 +25,26 @@ module Kramdown
     class Markdown < Kramdown
 
       # Array with all the parsing methods that should be removed from the standard kramdown parser.
-      EXTENDED = [:codeblock_fenced, :table, :definition_list, :footnote_definition, :abbrev_definition, :block_math,
-                  :block_extensions,
+      EXTENDED = [:codeblock_fenced, :table, :definition_list, :footnote_definition,
+                  :abbrev_definition, :block_math, :block_extensions,
                   :footnote_marker, :smart_quotes, :inline_math, :span_extensions, :typographic_syms]
 
       def initialize(source, options) # :nodoc:
         super
-        @block_parsers.delete_if {|i| EXTENDED.include?(i)}
-        @span_parsers.delete_if {|i| EXTENDED.include?(i)}
+        @block_parsers.delete_if {|i| EXTENDED.include?(i) }
+        @span_parsers.delete_if {|i| EXTENDED.include?(i) }
       end
 
       # :stopdoc:
 
       BLOCK_BOUNDARY = /#{BLANK_LINE}|#{EOB_MARKER}|\Z/
-      LAZY_END = /#{BLANK_LINE}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|^#{OPT_SPACE}#{LAZY_END_HTML_START}|\Z/
+      LAZY_END = /#{BLANK_LINE}|#{EOB_MARKER}|^#{OPT_SPACE}#{LAZY_END_HTML_STOP}|
+                  ^#{OPT_SPACE}#{LAZY_END_HTML_START}|\Z/x
       CODEBLOCK_MATCH = /(?:#{BLANK_LINE}?(?:#{INDENT}[ \t]*\S.*\n)+)*/
       PARAGRAPH_END = LAZY_END
 
       IAL_RAND_CHARS = (('a'..'z').to_a + ('0'..'9').to_a)
-      IAL_RAND_STRING = (1..20).collect {|a| IAL_RAND_CHARS[rand(IAL_RAND_CHARS.size)]}.join
+      IAL_RAND_STRING = (1..20).collect { IAL_RAND_CHARS[rand(IAL_RAND_CHARS.size)] }.join
       LIST_ITEM_IAL = /^\s*(#{IAL_RAND_STRING})?\s*\n/
       IAL_SPAN_START = LIST_ITEM_IAL
 

data/lib/kramdown/utils.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -17,7 +17,6 @@ module Kramdown
 
     autoload :Entities, 'kramdown/utils/entities'
     autoload :Html, 'kramdown/utils/html'
-    autoload :OrderedHash, 'kramdown/utils/ordered_hash'
     autoload :Unidecoder, 'kramdown/utils/unidecoder'
     autoload :StringScanner, 'kramdown/utils/string_scanner'
     autoload :Configurable, 'kramdown/utils/configurable'
@@ -25,14 +24,14 @@ module Kramdown
 
     # Treat +name+ as if it were snake cased (e.g. snake_case) and camelize it (e.g. SnakeCase).
     def self.camelize(name)
-      name.split('_').inject('') {|s,x| s << x[0..0].upcase << x[1..-1] }
+      name.split('_').inject(+'') {|s, x| s << x[0..0].upcase << x[1..-1] }
     end
 
     # Treat +name+ as if it were camelized (e.g. CamelizedName) and snake-case it (e.g. camelized_name).
     def self.snake_case(name)
       name = name.dup
-      name.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-      name.gsub!(/([a-z])([A-Z])/,'\1_\2')
+      name.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      name.gsub!(/([a-z])([A-Z])/, '\1_\2')
       name.downcase!
       name
     end

data/lib/kramdown/utils/configurable.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -26,10 +26,11 @@ module Kramdown
       # add_<name>(ext_name, data=nil, &block):: Define an extension +ext_name+ by specifying either
       #                                          the data as argument or by using a block.
       def configurable(name)
-        singleton_class = (class << self; self; end)
-        singleton_class.send(:define_method, :configurables) do
-          @_configurables ||= Hash.new {|h, k| h[k] = {}}
-        end unless respond_to?(:configurables)
+        unless respond_to?(:configurables)
+          singleton_class.send(:define_method, :configurables) do
+            @_configurables ||= Hash.new {|h, k| h[k] = {} }
+          end
+        end
         singleton_class.send(:define_method, name) do |data|
           configurables[name][data]
         end

data/lib/kramdown/utils/entities.rb

@@ -1,7 +1,7 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8; frozen_string_literal: true -*-
 #
 #--
-# Copyright (C) 2009-2016 Thomas Leitner <t_leitner@gmx.at>
+# Copyright (C) 2009-2019 Thomas Leitner <t_leitner@gmx.at>
 #
 # This file is part of kramdown which is licensed under the MIT.
 #++
@@ -15,13 +15,11 @@ module Kramdown
     module Entities
 
       # Represents an entity that has a +code_point+ and +name+.
-      class Entity < Struct.new(:code_point, :name)
-
+      Entity = Struct.new(:code_point, :name) do
         # Return the UTF8 representation of the entity.
         def char
           [code_point].pack('U*') rescue nil
         end
-
       end
 
       # Array of arrays. Each sub-array specifies a code point and the associated name.
@@ -29,294 +27,294 @@ module Kramdown
       # This table is not used directly -- Entity objects are automatically created from it and put
       # into a Hash map when this file is loaded.
       ENTITY_TABLE = [
-                      [913, 'Alpha'],
-                      [914, 'Beta'],
-                      [915, 'Gamma'],
-                      [916, 'Delta'],
-                      [917, 'Epsilon'],
-                      [918, 'Zeta'],
-                      [919, 'Eta'],
-                      [920, 'Theta'],
-                      [921, 'Iota'],
-                      [922, 'Kappa'],
-                      [923, 'Lambda'],
-                      [924, 'Mu'],
-                      [925, 'Nu'],
-                      [926, 'Xi'],
-                      [927, 'Omicron'],
-                      [928, 'Pi'],
-                      [929, 'Rho'],
-                      [931, 'Sigma'],
-                      [932, 'Tau'],
-                      [933, 'Upsilon'],
-                      [934, 'Phi'],
-                      [935, 'Chi'],
-                      [936, 'Psi'],
-                      [937, 'Omega'],
-                      [945, 'alpha'],
-                      [946, 'beta'],
-                      [947, 'gamma'],
-                      [948, 'delta'],
-                      [949, 'epsilon'],
-                      [950, 'zeta'],
-                      [951, 'eta'],
-                      [952, 'theta'],
-                      [953, 'iota'],
-                      [954, 'kappa'],
-                      [955, 'lambda'],
-                      [956, 'mu'],
-                      [957, 'nu'],
-                      [958, 'xi'],
-                      [959, 'omicron'],
-                      [960, 'pi'],
-                      [961, 'rho'],
-                      [963, 'sigma'],
-                      [964, 'tau'],
-                      [965, 'upsilon'],
-                      [966, 'phi'],
-                      [967, 'chi'],
-                      [968, 'psi'],
-                      [969, 'omega'],
-                      [962, 'sigmaf'],
-                      [977, 'thetasym'],
-                      [978, 'upsih'],
-                      [982, 'piv'],
-                      [8204, 'zwnj'],
-                      [8205, 'zwj'],
-                      [8206, 'lrm'],
-                      [8207, 'rlm'],
-                      [8230, 'hellip'],
-                      [8242, 'prime'],
-                      [8243, 'Prime'],
-                      [8254, 'oline'],
-                      [8260, 'frasl'],
-                      [8472, 'weierp'],
-                      [8465, 'image'],
-                      [8476, 'real'],
-                      [8501, 'alefsym'],
-                      [8226, 'bull'],
-                      [8482, 'trade'],
-                      [8592, 'larr'],
-                      [8594, 'rarr'],
-                      [8593, 'uarr'],
-                      [8595, 'darr'],
-                      [8596, 'harr'],
-                      [8629, 'crarr'],
-                      [8657, 'uArr'],
-                      [8659, 'dArr'],
-                      [8656, 'lArr'],
-                      [8658, 'rArr'],
-                      [8660, 'hArr'],
-                      [8704, 'forall'],
-                      [8706, 'part'],
-                      [8707, 'exist'],
-                      [8709, 'empty'],
-                      [8711, 'nabla'],
-                      [8712, 'isin'],
-                      [8715, 'ni'],
-                      [8713, 'notin'],
-                      [8721, 'sum'],
-                      [8719, 'prod'],
-                      [8722, 'minus'],
-                      [8727, 'lowast'],
-                      [8730, 'radic'],
-                      [8733, 'prop'],
-                      [8734, 'infin'],
-                      [8736, 'ang'],
-                      [8743, 'and'],
-                      [8744, 'or'],
-                      [8745, 'cap'],
-                      [8746, 'cup'],
-                      [8747, 'int'],
-                      [8756, 'there4'],
-                      [8764, 'sim'],
-                      [8776, 'asymp'],
-                      [8773, 'cong'],
-                      [8800, 'ne'],
-                      [8801, 'equiv'],
-                      [8804, 'le'],
-                      [8805, 'ge'],
-                      [8834, 'sub'],
-                      [8835, 'sup'],
-                      [8838, 'sube'],
-                      [8839, 'supe'],
-                      [8836, 'nsub'],
-                      [8853, 'oplus'],
-                      [8855, 'otimes'],
-                      [8869, 'perp'],
-                      [8901, 'sdot'],
-                      [8942, 'vellip'],
-                      [8968, 'rceil'],
-                      [8969, 'lceil'],
-                      [8970, 'lfloor'],
-                      [8971, 'rfloor'],
-                      [9001, 'rang'],
-                      [9002, 'lang'],
-                      [9674, 'loz'],
-                      [9824, 'spades'],
-                      [9827, 'clubs'],
-                      [9829, 'hearts'],
-                      [9830, 'diams'],
-                      [38, 'amp'],
-                      [34, 'quot'],
-                      [39, 'apos'],
-                      [169, 'copy'],
-                      [60, 'lt'],
-                      [62, 'gt'],
-                      [338, 'OElig'],
-                      [339, 'oelig'],
-                      [352, 'Scaron'],
-                      [353, 'scaron'],
-                      [376, 'Yuml'],
-                      [710, 'circ'],
-                      [732, 'tilde'],
-                      [8211, 'ndash'],
-                      [8212, 'mdash'],
-                      [8216, 'lsquo'],
-                      [8217, 'rsquo'],
-                      [8220, 'ldquo'],
-                      [8221, 'rdquo'],
-                      [8224, 'dagger'],
-                      [8225, 'Dagger'],
-                      [8240, 'permil'],
-                      [8364, 'euro'],
-                      [8249, 'lsaquo'],
-                      [8250, 'rsaquo'],
-                      [160, 'nbsp'],
-                      [161, 'iexcl'],
-                      [163, 'pound'],
-                      [164, 'curren'],
-                      [165, 'yen'],
-                      [166, 'brvbar'],
-                      [167, 'sect'],
-                      [168, 'uml'],
-                      [171, 'laquo'],
-                      [187, 'raquo'],
-                      [174, 'reg'],
-                      [170, 'ordf'],
-                      [172, 'not'],
-                      [173, 'shy'],
-                      [175, 'macr'],
-                      [176, 'deg'],
-                      [177, 'plusmn'],
-                      [180, 'acute'],
-                      [181, 'micro'],
-                      [182, 'para'],
-                      [183, 'middot'],
-                      [184, 'cedil'],
-                      [186, 'ordm'],
-                      [162, 'cent'],
-                      [185, 'sup1'],
-                      [178, 'sup2'],
-                      [179, 'sup3'],
-                      [189, 'frac12'],
-                      [188, 'frac14'],
-                      [190, 'frac34'],
-                      [191, 'iquest'],
-                      [192, 'Agrave'],
-                      [193, 'Aacute'],
-                      [194, 'Acirc'],
-                      [195, 'Atilde'],
-                      [196, 'Auml'],
-                      [197, 'Aring'],
-                      [198, 'AElig'],
-                      [199, 'Ccedil'],
-                      [200, 'Egrave'],
-                      [201, 'Eacute'],
-                      [202, 'Ecirc'],
-                      [203, 'Euml'],
-                      [204, 'Igrave'],
-                      [205, 'Iacute'],
-                      [206, 'Icirc'],
-                      [207, 'Iuml'],
-                      [208, 'ETH'],
-                      [209, 'Ntilde'],
-                      [210, 'Ograve'],
-                      [211, 'Oacute'],
-                      [212, 'Ocirc'],
-                      [213, 'Otilde'],
-                      [214, 'Ouml'],
-                      [215, 'times'],
-                      [216, 'Oslash'],
-                      [217, 'Ugrave'],
-                      [218, 'Uacute'],
-                      [219, 'Ucirc'],
-                      [220, 'Uuml'],
-                      [221, 'Yacute'],
-                      [222, 'THORN'],
-                      [223, 'szlig'],
-                      [224, 'agrave'],
-                      [225, 'aacute'],
-                      [226, 'acirc'],
-                      [227, 'atilde'],
-                      [228, 'auml'],
-                      [229, 'aring'],
-                      [230, 'aelig'],
-                      [231, 'ccedil'],
-                      [232, 'egrave'],
-                      [233, 'eacute'],
-                      [234, 'ecirc'],
-                      [235, 'euml'],
-                      [236, 'igrave'],
-                      [237, 'iacute'],
-                      [238, 'icirc'],
-                      [239, 'iuml'],
-                      [240, 'eth'],
-                      [241, 'ntilde'],
-                      [242, 'ograve'],
-                      [243, 'oacute'],
-                      [244, 'ocirc'],
-                      [245, 'otilde'],
-                      [246, 'ouml'],
-                      [247, 'divide'],
-                      [248, 'oslash'],
-                      [249, 'ugrave'],
-                      [250, 'uacute'],
-                      [251, 'ucirc'],
-                      [252, 'uuml'],
-                      [253, 'yacute'],
-                      [254, 'thorn'],
-                      [255, 'yuml'],
+        [913, 'Alpha'],
+        [914, 'Beta'],
+        [915, 'Gamma'],
+        [916, 'Delta'],
+        [917, 'Epsilon'],
+        [918, 'Zeta'],
+        [919, 'Eta'],
+        [920, 'Theta'],
+        [921, 'Iota'],
+        [922, 'Kappa'],
+        [923, 'Lambda'],
+        [924, 'Mu'],
+        [925, 'Nu'],
+        [926, 'Xi'],
+        [927, 'Omicron'],
+        [928, 'Pi'],
+        [929, 'Rho'],
+        [931, 'Sigma'],
+        [932, 'Tau'],
+        [933, 'Upsilon'],
+        [934, 'Phi'],
+        [935, 'Chi'],
+        [936, 'Psi'],
+        [937, 'Omega'],
+        [945, 'alpha'],
+        [946, 'beta'],
+        [947, 'gamma'],
+        [948, 'delta'],
+        [949, 'epsilon'],
+        [950, 'zeta'],
+        [951, 'eta'],
+        [952, 'theta'],
+        [953, 'iota'],
+        [954, 'kappa'],
+        [955, 'lambda'],
+        [956, 'mu'],
+        [957, 'nu'],
+        [958, 'xi'],
+        [959, 'omicron'],
+        [960, 'pi'],
+        [961, 'rho'],
+        [963, 'sigma'],
+        [964, 'tau'],
+        [965, 'upsilon'],
+        [966, 'phi'],
+        [967, 'chi'],
+        [968, 'psi'],
+        [969, 'omega'],
+        [962, 'sigmaf'],
+        [977, 'thetasym'],
+        [978, 'upsih'],
+        [982, 'piv'],
+        [8204, 'zwnj'],
+        [8205, 'zwj'],
+        [8206, 'lrm'],
+        [8207, 'rlm'],
+        [8230, 'hellip'],
+        [8242, 'prime'],
+        [8243, 'Prime'],
+        [8254, 'oline'],
+        [8260, 'frasl'],
+        [8472, 'weierp'],
+        [8465, 'image'],
+        [8476, 'real'],
+        [8501, 'alefsym'],
+        [8226, 'bull'],
+        [8482, 'trade'],
+        [8592, 'larr'],
+        [8594, 'rarr'],
+        [8593, 'uarr'],
+        [8595, 'darr'],
+        [8596, 'harr'],
+        [8629, 'crarr'],
+        [8657, 'uArr'],
+        [8659, 'dArr'],
+        [8656, 'lArr'],
+        [8658, 'rArr'],
+        [8660, 'hArr'],
+        [8704, 'forall'],
+        [8706, 'part'],
+        [8707, 'exist'],
+        [8709, 'empty'],
+        [8711, 'nabla'],
+        [8712, 'isin'],
+        [8715, 'ni'],
+        [8713, 'notin'],
+        [8721, 'sum'],
+        [8719, 'prod'],
+        [8722, 'minus'],
+        [8727, 'lowast'],
+        [8730, 'radic'],
+        [8733, 'prop'],
+        [8734, 'infin'],
+        [8736, 'ang'],
+        [8743, 'and'],
+        [8744, 'or'],
+        [8745, 'cap'],
+        [8746, 'cup'],
+        [8747, 'int'],
+        [8756, 'there4'],
+        [8764, 'sim'],
+        [8776, 'asymp'],
+        [8773, 'cong'],
+        [8800, 'ne'],
+        [8801, 'equiv'],
+        [8804, 'le'],
+        [8805, 'ge'],
+        [8834, 'sub'],
+        [8835, 'sup'],
+        [8838, 'sube'],
+        [8839, 'supe'],
+        [8836, 'nsub'],
+        [8853, 'oplus'],
+        [8855, 'otimes'],
+        [8869, 'perp'],
+        [8901, 'sdot'],
+        [8942, 'vellip'],
+        [8968, 'rceil'],
+        [8969, 'lceil'],
+        [8970, 'lfloor'],
+        [8971, 'rfloor'],
+        [9001, 'rang'],
+        [9002, 'lang'],
+        [9674, 'loz'],
+        [9824, 'spades'],
+        [9827, 'clubs'],
+        [9829, 'hearts'],
+        [9830, 'diams'],
+        [38, 'amp'],
+        [34, 'quot'],
+        [39, 'apos'],
+        [169, 'copy'],
+        [60, 'lt'],
+        [62, 'gt'],
+        [338, 'OElig'],
+        [339, 'oelig'],
+        [352, 'Scaron'],
+        [353, 'scaron'],
+        [376, 'Yuml'],
+        [710, 'circ'],
+        [732, 'tilde'],
+        [8211, 'ndash'],
+        [8212, 'mdash'],
+        [8216, 'lsquo'],
+        [8217, 'rsquo'],
+        [8220, 'ldquo'],
+        [8221, 'rdquo'],
+        [8224, 'dagger'],
+        [8225, 'Dagger'],
+        [8240, 'permil'],
+        [8364, 'euro'],
+        [8249, 'lsaquo'],
+        [8250, 'rsaquo'],
+        [160, 'nbsp'],
+        [161, 'iexcl'],
+        [163, 'pound'],
+        [164, 'curren'],
+        [165, 'yen'],
+        [166, 'brvbar'],
+        [167, 'sect'],
+        [168, 'uml'],
+        [171, 'laquo'],
+        [187, 'raquo'],
+        [174, 'reg'],
+        [170, 'ordf'],
+        [172, 'not'],
+        [173, 'shy'],
+        [175, 'macr'],
+        [176, 'deg'],
+        [177, 'plusmn'],
+        [180, 'acute'],
+        [181, 'micro'],
+        [182, 'para'],
+        [183, 'middot'],
+        [184, 'cedil'],
+        [186, 'ordm'],
+        [162, 'cent'],
+        [185, 'sup1'],
+        [178, 'sup2'],
+        [179, 'sup3'],
+        [189, 'frac12'],
+        [188, 'frac14'],
+        [190, 'frac34'],
+        [191, 'iquest'],
+        [192, 'Agrave'],
+        [193, 'Aacute'],
+        [194, 'Acirc'],
+        [195, 'Atilde'],
+        [196, 'Auml'],
+        [197, 'Aring'],
+        [198, 'AElig'],
+        [199, 'Ccedil'],
+        [200, 'Egrave'],
+        [201, 'Eacute'],
+        [202, 'Ecirc'],
+        [203, 'Euml'],
+        [204, 'Igrave'],
+        [205, 'Iacute'],
+        [206, 'Icirc'],
+        [207, 'Iuml'],
+        [208, 'ETH'],
+        [209, 'Ntilde'],
+        [210, 'Ograve'],
+        [211, 'Oacute'],
+        [212, 'Ocirc'],
+        [213, 'Otilde'],
+        [214, 'Ouml'],
+        [215, 'times'],
+        [216, 'Oslash'],
+        [217, 'Ugrave'],
+        [218, 'Uacute'],
+        [219, 'Ucirc'],
+        [220, 'Uuml'],
+        [221, 'Yacute'],
+        [222, 'THORN'],
+        [223, 'szlig'],
+        [224, 'agrave'],
+        [225, 'aacute'],
+        [226, 'acirc'],
+        [227, 'atilde'],
+        [228, 'auml'],
+        [229, 'aring'],
+        [230, 'aelig'],
+        [231, 'ccedil'],
+        [232, 'egrave'],
+        [233, 'eacute'],
+        [234, 'ecirc'],
+        [235, 'euml'],
+        [236, 'igrave'],
+        [237, 'iacute'],
+        [238, 'icirc'],
+        [239, 'iuml'],
+        [240, 'eth'],
+        [241, 'ntilde'],
+        [242, 'ograve'],
+        [243, 'oacute'],
+        [244, 'ocirc'],
+        [245, 'otilde'],
+        [246, 'ouml'],
+        [247, 'divide'],
+        [248, 'oslash'],
+        [249, 'ugrave'],
+        [250, 'uacute'],
+        [251, 'ucirc'],
+        [252, 'uuml'],
+        [253, 'yacute'],
+        [254, 'thorn'],
+        [255, 'yuml'],
 
-                      [8218, 'sbquo'],
-                      [402, 'fnof'],
-                      [8222, 'bdquo'],
+        [8218, 'sbquo'],
+        [402, 'fnof'],
+        [8222, 'bdquo'],
 
-                      [128, 8364],
-                      [130, 8218],
-                      [131, 402],
-                      [132, 8222],
-                      [133, 8230],
-                      [134, 8224],
-                      [135, 8225],
-                      [136, 710],
-                      [137, 8240],
-                      [138, 352],
-                      [139, 8249],
-                      [140, 338],
-                      [142, 381],
-                      [145, 8216],
-                      [146, 8217],
-                      [147, 8220],
-                      [148, 8221],
-                      [149, 8226],
-                      [150, 8211],
-                      [151, 8212],
-                      [152, 732],
-                      [153, 8482],
-                      [154, 353],
-                      [155, 8250],
-                      [156, 339],
-                      [158, 382],
-                      [159, 376],
+        [128, 8364],
+        [130, 8218],
+        [131, 402],
+        [132, 8222],
+        [133, 8230],
+        [134, 8224],
+        [135, 8225],
+        [136, 710],
+        [137, 8240],
+        [138, 352],
+        [139, 8249],
+        [140, 338],
+        [142, 381],
+        [145, 8216],
+        [146, 8217],
+        [147, 8220],
+        [148, 8221],
+        [149, 8226],
+        [150, 8211],
+        [151, 8212],
+        [152, 732],
+        [153, 8482],
+        [154, 353],
+        [155, 8250],
+        [156, 339],
+        [158, 382],
+        [159, 376],
 
-                      [8194, 'ensp'],
-                      [8195, 'emsp'],
-                      [8201, 'thinsp'],
-                     ]
+        [8194, 'ensp'],
+        [8195, 'emsp'],
+        [8201, 'thinsp'],
+      ]
 
       # Contains the mapping of code point (or name) to the actual Entity object.
-      ENTITY_MAP = Hash.new do |h,k|
+      ENTITY_MAP = Hash.new do |h, k|
         if k.kind_of?(Integer)
           h[k] = Entity.new(k, nil)
         else
@@ -344,4 +342,3 @@ module Kramdown
   end
 
 end
-