logstash-codec-json 2.0.3 → 2.0.4

data/vendor/gems/kramdown-1.9.0/lib/kramdown/parser/kramdown/table.rb

@@ -1,173 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-require 'kramdown/parser/kramdown/block_boundary'
-
-module Kramdown
-  module Parser
-    class Kramdown
-
-      TABLE_SEP_LINE = /^([+|: -]*?-[+|: -]*?)[ \t]*\n/
-      TABLE_HSEP_ALIGN = /[ ]?(:?)-+(:?)[ ]?/
-      TABLE_FSEP_LINE = /^[+|: =]*?=[+|: =]*?[ \t]*\n/
-      TABLE_ROW_LINE = /^(.*?)[ \t]*\n/
-      TABLE_PIPE_CHECK = /(?:\||.*?[^\\\n]\|)/
-      TABLE_LINE = /#{TABLE_PIPE_CHECK}.*?\n/
-      TABLE_START = /^#{OPT_SPACE}(?=\S)#{TABLE_LINE}/
-
-      # Parse the table at the current location.
-      def parse_table
-        return false if !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)
-        leading_pipe = (@src.check(TABLE_LINE) =~ /^\s*\|/)
-        @src.scan(TABLE_SEP_LINE)
-
-        rows = []
-        has_footer = false
-        columns = 0
-
-        add_container = lambda do |type, force|
-          if !has_footer || type != :tbody || force
-            cont = Element.new(type)
-            cont.children, rows = rows, []
-            table.children << cont
-          end
-        end
-
-        while !@src.eos?
-          break if !@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
-              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?
-            has_footer = true
-          elsif @src.scan(TABLE_ROW_LINE)
-            trow = Element.new(:tr)
-
-            # parse possible code spans on the line and correctly split the line into cells
-            env = save_env
-            cells = []
-            @src[1].split(/(<code.*?>.*?<\/code>)/).each_with_index do |str, i|
-              if i % 2 == 1
-                (cells.empty? ? cells : cells.last) << str
-              else
-                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
-                    # Only on Ruby 1.9: f, *l = c.value.split(/(?<!\\)\|/).map {|t| t.gsub(/\\\|/, '|')}
-                    f, *l = c.value.split(/\\\|/, -1).map {|t| t.split(/\|/, -1)}.inject([]) do |memo, t|
-                      memo.last << "|#{t.shift}" if memo.size > 0
-                      memo.concat(t)
-                    end
-                    (cells.empty? ? cells : cells.last) << f
-                    cells.concat(l)
-                  else
-                    delim = (c.value.scan(/`+/).max || '') + '`'
-                    tmp = "#{delim}#{' ' if delim.size > 1}#{c.value}#{' ' if delim.size > 1}#{delim}"
-                    (cells.empty? ? cells : cells.last) << tmp
-                  end
-                end
-              end
-            end
-            restore_env(env)
-
-            cells.shift if leading_pipe && cells.first.strip.empty?
-            cells.pop if cells.last.strip.empty?
-            cells.each do |cell_text|
-              tcell = Element.new(:td)
-              tcell.children << Element.new(:raw_text, cell_text.strip)
-              trow.children << tcell
-            end
-            columns = [columns, cells.length].max
-            rows << trow
-          else
-            break
-          end
-        end
-
-        if !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),
-                                                     @src.current_line_number)
-        reset_env(:src => l_src)
-        root = Element.new(:root)
-        parse_spans(root, nil, [:codespan, :span_html])
-        restore_env(env)
-
-        # Check if each line has at least one unescaped pipe that is not inside a code span/code
-        # HTML element
-        # Note: It doesn't matter that we parse *all* span HTML elements because the row splitting
-        # algorithm above only takes <code> elements into account!
-        pipe_on_line = false
-        while (c = root.children.shift)
-          lines = c.value.split(/\n/)
-          if c.type == :codespan
-            if lines.size > 2 || (lines.size == 2 && !pipe_on_line)
-              break
-            elsif lines.size == 2 && pipe_on_line
-              pipe_on_line = false
-            end
-          else
-            break if lines.size > 1 && !pipe_on_line && lines.first !~ /^#{TABLE_PIPE_CHECK}/
-            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
-
-        add_container.call(has_footer ? :tfoot : :tbody, false) if !rows.empty?
-
-        if !table.children.any? {|el| el.type == :tbody}
-          warning("Found table without body on line #{table.options[:location]} - ignoring it")
-          @src.revert_pos(saved_pos)
-          return false
-        end
-
-        # adjust all table rows to have equal number of columns, same for alignment defs
-        table.children.each do |kind|
-          kind.children.each do |row|
-            (columns - row.children.length).times do
-              row.children << Element.new(:td)
-            end
-          end
-        end
-        if table.options[:alignment].length > columns
-          table.options[:alignment] = table.options[:alignment][0...columns]
-        else
-          table.options[:alignment] += [:default] * (columns - table.options[:alignment].length)
-        end
-
-        @tree.children << table
-
-        true
-      end
-      define_parser(:table, TABLE_START)
-
-    end
-  end
-end

data/vendor/gems/kramdown-1.9.0/lib/kramdown/parser/kramdown/typographic_symbol.rb

@@ -1,44 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown
-  module Parser
-    class Kramdown
-
-      TYPOGRAPHIC_SYMS = [['---', :mdash], ['--', :ndash], ['...', :hellip],
-                          ['\\<<', '&lt;&lt;'], ['\\>>', '&gt;&gt;'],
-                          ['<< ', :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('|')}/
-
-      # Parse the typographic symbols at the current location.
-      def parse_typographic_syms
-        start_line_number = @src.current_line_number
-        @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)
-        elsif @src.matched == '\\<<'
-          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
-                                        nil, :location => start_line_number)
-          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('lt'),
-                                        nil, :location => start_line_number)
-        else
-          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
-                                        nil, :location => start_line_number)
-          @tree.children << Element.new(:entity, ::Kramdown::Utils::Entities.entity('gt'),
-                                        nil, :location => start_line_number)
-        end
-      end
-      define_parser(:typographic_syms, TYPOGRAPHIC_SYMS_RE, '--|\\.\\.\\.|(?:\\\\| )?(?:<<|>>)')
-
-    end
-  end
-end

data/vendor/gems/kramdown-1.9.0/lib/kramdown/parser/markdown.rb

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-require 'kramdown/parser'
-
-module Kramdown
-
-  module Parser
-
-    # Used for parsing a document in Markdown format.
-    #
-    # This parser is based on the kramdown parser and removes the parser methods for the additional
-    # non-Markdown features. However, since some things are handled differently by the kramdown
-    # parser methods (like deciding when a list item contains just text), this parser differs from
-    # real Markdown parsers in some respects.
-    #
-    # Note, though, that the parser basically fails just one of the Markdown test cases (some others
-    # also fail but those failures are negligible).
-    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,
-                  :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)}
-      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/
-      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
-      LIST_ITEM_IAL = /^\s*(#{IAL_RAND_STRING})?\s*\n/
-      IAL_SPAN_START = LIST_ITEM_IAL
-
-      # :startdoc:
-
-    end
-
-  end
-
-end

data/vendor/gems/kramdown-1.9.0/lib/kramdown/utils.rb

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown
-
-  # == \Utils Module
-  #
-  # This module contains utility class/modules/methods that can be used by both parsers and
-  # converters.
-  module Utils
-
-    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'
-
-    # 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] }
-    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.downcase!
-      name
-    end
-
-    if RUBY_VERSION < '2.0'
-
-      # Resolve the recursive constant +str+.
-      def self.deep_const_get(str)
-        names = str.split(/::/)
-        names.shift if names.first.empty?
-        names.inject(::Object) {|mod, s| mod.const_get(s)}
-      end
-
-    else
-
-      def self.deep_const_get(str)
-        ::Object.const_get(str)
-      end
-
-    end
-
-  end
-
-end

data/vendor/gems/kramdown-1.9.0/lib/kramdown/utils/configurable.rb

@@ -1,44 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown
-  module Utils
-
-    # Methods for registering configurable extensions.
-    module Configurable
-
-      # Create a new configurable extension called +name+.
-      #
-      # Three methods will be defined on the calling object which allow to use this configurable
-      # extension:
-      #
-      # configurables:: Returns a hash of hashes that is used to store all configurables of the
-      #                 object.
-      #
-      # <name>(ext_name):: Return the configured extension +ext_name+.
-      #
-      # 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)
-        singleton_class.send(:define_method, name) do |data|
-          configurables[name][data]
-        end
-        singleton_class.send(:define_method, "add_#{name}".intern) do |data, *args, &block|
-          configurables[name][data] = args.first || block
-        end
-      end
-
-    end
-
-  end
-end

data/vendor/gems/kramdown-1.9.0/lib/kramdown/utils/entities.rb

@@ -1,347 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#--
-# Copyright (C) 2009-2015 Thomas Leitner <t_leitner@gmx.at>
-#
-# This file is part of kramdown which is licensed under the MIT.
-#++
-#
-
-module Kramdown
-
-  module Utils
-
-    # Provides convenience methods for handling named and numeric entities.
-    module Entities
-
-      # Represents an entity that has a +code_point+ and +name+.
-      class Entity < Struct.new(:code_point, :name)
-
-        # 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.
-      #
-      # 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, 'cup'],
-                      [8746, 'cap'],
-                      [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'],
-
-                      [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'],
-                     ]
-
-      # Contains the mapping of code point (or name) to the actual Entity object.
-      ENTITY_MAP = Hash.new do |h,k|
-        if k.kind_of?(Integer)
-          h[k] = Entity.new(k, nil)
-        else
-          raise Kramdown::Error, "Can't handle generic non-integer character reference '#{k}'"
-        end
-      end
-
-      ENTITY_TABLE.each do |code_point, data|
-        if data.kind_of?(String)
-          ENTITY_MAP[code_point] = ENTITY_MAP[data] = Entity.new(code_point, data)
-        else
-          ENTITY_MAP[code_point] = ENTITY_MAP[data]
-        end
-      end
-
-      # Return the entity for the given code point or name +point_or_name+.
-      def entity(point_or_name)
-        ENTITY_MAP[point_or_name]
-      end
-
-      module_function :entity
-
-    end
-
-  end
-
-end
-