logstash-input-beats 0.9 → 0.9.1

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

@@ -0,0 +1,173 @@
+# -*- 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/jruby/1.9/gems/kramdown-1.9.0/lib/kramdown/parser/kramdown/typographic_symbol.rb

@@ -0,0 +1,44 @@
+# -*- 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/jruby/1.9/gems/kramdown-1.9.0/lib/kramdown/parser/markdown.rb

@@ -0,0 +1,56 @@
+# -*- 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/jruby/1.9/gems/kramdown-1.9.0/lib/kramdown/utils.rb

@@ -0,0 +1,58 @@
+# -*- 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/jruby/1.9/gems/kramdown-1.9.0/lib/kramdown/utils/configurable.rb

@@ -0,0 +1,44 @@
+# -*- 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/jruby/1.9/gems/kramdown-1.9.0/lib/kramdown/utils/entities.rb

@@ -0,0 +1,347 @@
+# -*- 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
+