mega-sharp-mod 0.0.1

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

@@ -0,0 +1,171 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2026 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/kramdown-2.5.2/lib/kramdown/parser/kramdown/typographic_symbol.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2026 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/kramdown-2.5.2/lib/kramdown/parser/kramdown.rb

@@ -0,0 +1,377 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2026 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+require 'strscan'
+require 'stringio'
+require 'kramdown/parser'
+
+# TODO: use [[:alpha:]] in all regexp to allow parsing of international values in 1.9.1
+# NOTE: use @src.pre_match only before other check/match?/... operations, otherwise the content is changed
+
+module Kramdown
+
+  module Parser
+
+    # Used for parsing a document in kramdown format.
+    #
+    # If you want to extend the functionality of the parser, you need to do the following:
+    #
+    # * Create a new subclass
+    # * add the needed parser methods
+    # * modify the @block_parsers and @span_parsers variables and add the names of your parser
+    #   methods
+    #
+    # Here is a small example for an extended parser class that parses ERB style tags as raw text if
+    # they are used as span-level elements (an equivalent block-level parser should probably also be
+    # made to handle the block case):
+    #
+    #   require 'kramdown/parser/kramdown'
+    #
+    #   class Kramdown::Parser::ERBKramdown < Kramdown::Parser::Kramdown
+    #
+    #      def initialize(source, options)
+    #        super
+    #        @span_parsers.unshift(:erb_tags)
+    #      end
+    #
+    #      ERB_TAGS_START = /<%.*?%>/
+    #
+    #      def parse_erb_tags
+    #        @src.pos += @src.matched_size
+    #        @tree.children << Element.new(:raw, @src.matched)
+    #      end
+    #      define_parser(:erb_tags, ERB_TAGS_START, '<%')
+    #
+    #   end
+    #
+    # The new parser can be used like this:
+    #
+    #   require 'kramdown/document'
+    #   # require the file with the above parser class
+    #
+    #   Kramdown::Document.new(input_text, :input => 'ERBKramdown').to_html
+    #
+    class Kramdown < Base
+
+      include ::Kramdown
+
+      # Create a new Kramdown parser object with the given +options+.
+      def initialize(source, options)
+        super
+
+        reset_env
+
+        @alds = {}
+        @footnotes = {}
+        @link_defs = {}
+        update_link_definitions(@options[:link_defs])
+
+        @block_parsers = [:blank_line, :codeblock, :codeblock_fenced, :blockquote, :atx_header,
+                          :horizontal_rule, :list, :definition_list, :block_html, :setext_header,
+                          :block_math, :table, :footnote_definition, :link_definition,
+                          :abbrev_definition, :block_extensions, :eob_marker, :paragraph]
+        @span_parsers =  [:emphasis, :codespan, :autolink, :span_html, :footnote_marker, :link,
+                          :smart_quotes, :inline_math, :span_extensions, :html_entity,
+                          :typographic_syms, :line_break, :escaped_chars]
+
+        @span_pattern_cache ||= Hash.new {|h, k| h[k] = {} }
+      end
+      private_class_method(:new, :allocate)
+
+      # The source string provided on initialization is parsed into the @root element.
+      def parse
+        configure_parser
+        parse_blocks(@root, adapt_source(source))
+        update_tree(@root)
+        correct_abbreviations_attributes
+        replace_abbreviations(@root)
+        @footnotes.each do |_name, data|
+          update_tree(data[:content])
+          replace_abbreviations(data[:content])
+        end
+        footnote_count = 0
+        @footnotes.each do |name, data|
+          (footnote_count += 1; next) if data.key?(:marker)
+          line = data[:content].options[:location]
+          warning("Footnote definition for '#{name}' on line #{line} is unreferenced - ignoring")
+        end
+        @root.options[:footnote_count] = footnote_count
+      end
+
+      protected
+
+      # :doc:
+      #
+      # Update the parser specific link definitions with the data from +link_defs+ (the value of the
+      # :link_defs option).
+      #
+      # The parameter +link_defs+ is a hash where the keys are possibly unnormalized link IDs and
+      # the values are two element arrays consisting of the link target and a title (can be +nil+).
+      def update_link_definitions(link_defs)
+        link_defs.each {|k, v| @link_defs[normalize_link_id(k)] = v }
+      end
+
+      # Adapt the object to allow parsing like specified in the options.
+      def configure_parser
+        @parsers = {}
+        (@block_parsers + @span_parsers).each do |name|
+          if self.class.has_parser?(name)
+            @parsers[name] = self.class.parser(name)
+          else
+            raise Kramdown::Error, "Unknown parser: #{name}"
+          end
+        end
+        @span_start, @span_start_re = span_parser_regexps
+      end
+
+      # Create the needed span parser regexps.
+      def span_parser_regexps(parsers = @span_parsers)
+        span_start = /#{parsers.map {|name| @parsers[name].span_start }.join('|')}/
+        [span_start, /(?=#{span_start})/]
+      end
+
+      # Parse all block-level elements in +text+ into the element +el+.
+      def parse_blocks(el, text = nil)
+        @stack.push([@tree, @src, @block_ial])
+        @tree, @block_ial = el, nil
+        @src = (text.nil? ? @src : ::Kramdown::Utils::StringScanner.new(text, el.options[:location]))
+
+        status = catch(:stop_block_parsing) do
+          until @src.eos?
+            @block_parsers.any? do |name|
+              if @src.check(@parsers[name].start_re)
+                send(@parsers[name].method)
+              else
+                false
+              end
+            end || begin
+              warning('Warning: this should not occur - no block parser handled the line')
+              add_text(@src.scan(/.*\n/))
+            end
+          end
+        end
+
+        @tree, @src, @block_ial = *@stack.pop
+        status
+      end
+
+      # Update the tree by parsing all :+raw_text+ elements with the span-level parser (resets the
+      # environment) and by updating the attributes from the IALs.
+      def update_tree(element)
+        last_blank = nil
+        element.children.map! do |child|
+          case child.type
+          when :raw_text
+            last_blank = nil
+            reset_env(src: ::Kramdown::Utils::StringScanner.new(child.value, element.options[:location]),
+                      text_type: :text)
+            parse_spans(child)
+            child.children
+          when :eob
+            update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
+            []
+          when :blank
+            if last_blank
+              last_blank.value << child.value
+              []
+            else
+              last_blank = child
+              child
+            end
+          else
+            last_blank = nil
+            update_tree(child)
+            update_attr_with_ial(child.attr, child.options[:ial]) if child.options[:ial]
+            # DEPRECATED: option auto_id_stripping will be removed in 2.0 because then this will be
+            # the default behaviour
+            if child.type == :dt || (child.type == :header && @options[:auto_id_stripping])
+              update_raw_text(child)
+            end
+            child
+          end
+        end.flatten!
+      end
+
+      def span_pattern_cache(stop_re, span_start)
+        @span_pattern_cache[stop_re][span_start] ||= /(?=#{Regexp.union(stop_re, span_start)})/
+      end
+      private :span_pattern_cache
+
+      # Parse all span-level elements in the source string of @src into +el+.
+      #
+      # If the parameter +stop_re+ (a regexp) is used, parsing is immediately stopped if the regexp
+      # matches and if no block is given or if a block is given and it returns +true+.
+      #
+      # The parameter +parsers+ can be used to specify the (span-level) parsing methods that should
+      # be used for parsing.
+      #
+      # The parameter +text_type+ specifies the type which should be used for created text nodes.
+      def parse_spans(el, stop_re = nil, parsers = nil, text_type = @text_type)
+        @stack.push([@tree, @text_type]) unless @tree.nil?
+        @tree, @text_type = el, text_type
+
+        span_start = @span_start
+        span_start_re = @span_start_re
+        span_start, span_start_re = span_parser_regexps(parsers) if parsers
+        parsers ||= @span_parsers
+
+        used_re = (stop_re.nil? ? span_start_re : span_pattern_cache(stop_re, span_start))
+        stop_re_found = false
+        while !@src.eos? && !stop_re_found
+          if (result = @src.scan_until(used_re))
+            add_text(result)
+            if stop_re && @src.check(stop_re)
+              stop_re_found = (block_given? ? yield : true)
+            end
+            processed = parsers.any? do |name|
+              if @src.check(@parsers[name].start_re)
+                send(@parsers[name].method)
+                true
+              else
+                false
+              end
+            end unless stop_re_found
+            add_text(@src.getch) if !processed && !stop_re_found
+          else
+            (add_text(@src.rest); @src.terminate) unless stop_re
+            break
+          end
+        end
+
+        @tree, @text_type = @stack.pop
+
+        stop_re_found
+      end
+
+      # Reset the current parsing environment. The parameter +env+ can be used to set initial
+      # values for one or more environment variables.
+      def reset_env(opts = {})
+        opts = {text_type: :raw_text, stack: []}.merge(opts)
+        @src = opts[:src]
+        @tree = opts[:tree]
+        @block_ial = opts[:block_ial]
+        @stack = opts[:stack]
+        @text_type = opts[:text_type]
+      end
+
+      # Return the current parsing environment.
+      def save_env
+        [@src, @tree, @block_ial, @stack, @text_type]
+      end
+
+      # Restore the current parsing environment.
+      def restore_env(env)
+        @src, @tree, @block_ial, @stack, @text_type = *env
+      end
+
+      # Update the given attributes hash +attr+ with the information from the inline attribute list
+      # +ial+ and all referenced ALDs.
+      def update_attr_with_ial(attr, ial)
+        ial[:refs]&.each do |ref|
+          update_attr_with_ial(attr, ref) if (ref = @alds[ref])
+        end
+        ial.each do |k, v|
+          if k == IAL_CLASS_ATTR
+            attr[k] = "#{attr[k]} #{v}".lstrip
+          elsif k.kind_of?(String)
+            attr[k] = v
+          end
+        end
+      end
+
+      # Update the raw text for automatic ID generation.
+      def update_raw_text(item)
+        raw_text = +''
+
+        append_text = lambda do |child|
+          if child.type == :text
+            raw_text << child.value
+          else
+            child.children.each {|c| append_text.call(c) }
+          end
+        end
+
+        append_text.call(item)
+        item.options[:raw_text] = raw_text
+      end
+
+      # Create a new block-level element, taking care of applying a preceding block IAL if it
+      # exists. This method should always be used for creating a block-level element!
+      def new_block_el(*args)
+        el = Element.new(*args)
+        if @block_ial
+          el.options[:ial] = @block_ial
+          @block_ial = nil
+        end
+        el
+      end
+
+      @@parsers = {}
+
+      # Struct class holding all the needed data for one block/span-level parser method.
+      Data = Struct.new(:name, :start_re, :span_start, :method)
+
+      # Add a parser method
+      #
+      # * with the given +name+,
+      # * using +start_re+ as start regexp
+      # * and, for span parsers, +span_start+ as a String that can be used in a regexp and
+      #   which identifies the starting character(s)
+      #
+      # to the registry. The method name is automatically derived from the +name+ or can explicitly
+      # be set by using the +meth_name+ parameter.
+      def self.define_parser(name, start_re, span_start = nil, meth_name = "parse_#{name}")
+        raise "A parser with the name #{name} already exists!" if @@parsers.key?(name)
+        @@parsers[name] = Data.new(name, start_re, span_start, meth_name)
+      end
+
+      # Return the Data structure for the parser +name+.
+      def self.parser(name = nil)
+        @@parsers[name]
+      end
+
+      # Return +true+ if there is a parser called +name+.
+      def self.has_parser?(name)
+        @@parsers.key?(name)
+      end
+
+      # Regexp for matching indentation (one tab or four spaces)
+      INDENT = /^(?:\t| {4})/
+      # Regexp for matching the optional space (zero or up to three spaces)
+      OPT_SPACE = / {0,3}/
+
+      require 'kramdown/parser/kramdown/blank_line'
+      require 'kramdown/parser/kramdown/eob'
+      require 'kramdown/parser/kramdown/paragraph'
+      require 'kramdown/parser/kramdown/header'
+      require 'kramdown/parser/kramdown/blockquote'
+      require 'kramdown/parser/kramdown/table'
+      require 'kramdown/parser/kramdown/codeblock'
+      require 'kramdown/parser/kramdown/horizontal_rule'
+      require 'kramdown/parser/kramdown/list'
+      require 'kramdown/parser/kramdown/link'
+      require 'kramdown/parser/kramdown/extensions'
+      require 'kramdown/parser/kramdown/footnote'
+      require 'kramdown/parser/kramdown/html'
+      require 'kramdown/parser/kramdown/escaped_chars'
+      require 'kramdown/parser/kramdown/html_entity'
+      require 'kramdown/parser/kramdown/line_break'
+      require 'kramdown/parser/kramdown/typographic_symbol'
+      require 'kramdown/parser/kramdown/autolink'
+      require 'kramdown/parser/kramdown/codespan'
+      require 'kramdown/parser/kramdown/emphasis'
+      require 'kramdown/parser/kramdown/smart_quotes'
+      require 'kramdown/parser/kramdown/math'
+      require 'kramdown/parser/kramdown/abbreviation'
+
+    end
+
+  end
+
+end

data/kramdown-2.5.2/lib/kramdown/parser/markdown.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2026 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/kramdown-2.5.2/lib/kramdown/parser.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8; frozen_string_literal: true -*-
+#
+#--
+# Copyright (C) 2009-2026 Thomas Leitner <t_leitner@gmx.at>
+#
+# This file is part of kramdown which is licensed under the MIT.
+#++
+#
+
+module Kramdown
+
+  # This module contains all available parsers. A parser takes an input string and converts the
+  # string to an element tree.
+  #
+  # New parsers should be derived from the Base class which provides common functionality - see its
+  # API documentation for how to create a custom converter class.
+  module Parser
+
+    autoload :Base, 'kramdown/parser/base'
+    autoload :Kramdown, 'kramdown/parser/kramdown'
+    autoload :Html, 'kramdown/parser/html'
+    autoload :Markdown, 'kramdown/parser/markdown'
+
+  end
+
+end