zine_brewer 1.3.2 → 1.5.0

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/parser/kramdown/table.rb

@@ -0,0 +1,171 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 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-]*?-[+|: \t-]*?)[ \t]*\n/
+      TABLE_HSEP_ALIGN = /[ \t]?(:?)-+(:?)[ \t]?/
+      TABLE_FSEP_LINE = /^[+|: \t=]*?=[+|: \t=]*?[ \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 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)
+        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
+
+        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
+              end
+            else # treat as normal separator line
+              add_container.call(:tbody, false)
+            end
+          elsif @src.scan(TABLE_FSEP_LINE)
+            add_container.call(:tbody, true) unless 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.odd?
+                (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
+                    f, *l = c.value.split(/(?<!\\)\|/, -1).map {|t| t.gsub(/\\\|/, '|') }
+                    (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
+
+        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),
+                                                     @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)
+          next unless (lines = c.value)
+          lines = lines.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}/o
+            pipe_on_line = (lines.size > 1 ? false : pipe_on_line) || (lines.last =~ /^#{TABLE_PIPE_CHECK}/o)
+          end
+        end
+        @src.revert_pos(saved_pos) and return false unless pipe_on_line
+
+        add_container.call(has_footer ? :tfoot : :tbody, false) unless rows.empty?
+
+        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
+        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/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/parser/kramdown/typographic_symbol.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 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/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/parser/markdown.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 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/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 { 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/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/utils.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 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 :Unidecoder, 'kramdown/utils/unidecoder'
+    autoload :StringScanner, 'kramdown/utils/string_scanner'
+    autoload :Configurable, 'kramdown/utils/configurable'
+    autoload :LRUCache, 'kramdown/utils/lru_cache'
+
+    # 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
+
+    def self.deep_const_get(str)
+      ::Object.const_get(str)
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/utils/configurable.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 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)
+        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
+        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/bundle/ruby/2.7.0/gems/kramdown-2.3.0/lib/kramdown/utils/entities.rb

@@ -0,0 +1,344 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2019 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+.
+      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.
+      #
+      # 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'],
+
+        [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