nora_mark 0.2beta7 → 0.2beta8

data/lib/nora_mark/parser.kpeg.rb

@@ -1,26 +1,31 @@
 require 'kpeg/compiled_parser'
 
 class NoraMark::Parser < KPeg::CompiledParser
+
+
+   PARAMETER_END = /[,)]/
+
+
   # :stopdoc:
 
   module ::NoraMark
     class Node; end
     class Block < Node
-      def initialize(name, ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(name, ids, classes, params, named_params, raw_content, line_no)
         @name = name
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :name
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class Breakline < Node
@@ -29,36 +34,52 @@ class NoraMark::Parser < KPeg::CompiledParser
       end
       attr_reader :line_no
     end
-    class DefinitionList < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+    class CodeInline < Node
+      def initialize(ids, classes, params, named_params, content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
+        @params = params
+        @named_params = named_params
         @content = content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
+      attr_reader :params
+      attr_reader :named_params
       attr_reader :content
       attr_reader :line_no
     end
+    class DefinitionList < Node
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
+        @ids = ids
+        @classes = classes
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
+        @line_no = line_no
+      end
+      attr_reader :ids
+      attr_reader :classes
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
+      attr_reader :line_no
+    end
     class DLItem < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class Frontmatter < Node
@@ -70,130 +91,134 @@ class NoraMark::Parser < KPeg::CompiledParser
       attr_reader :line_no
     end
     class HeadedSection < Node
-      def initialize(level, heading, content, line_no)
+      def initialize(level, heading, params, named_params, raw_content, line_no)
         @level = level
         @heading = heading
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :level
       attr_reader :heading
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class Inline < Node
-      def initialize(name, ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(name, ids, classes, params, named_params, raw_content, line_no)
         @name = name
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :name
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class Newpage < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class OlItem < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class OrderedList < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class Page < Node
-      def initialize(content, line_no)
-        @content = content
+      def initialize(raw_content, line_no)
+        @raw_content = raw_content
         @line_no = line_no
       end
-      attr_reader :content
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class Paragraph < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class ParagraphGroup < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class PreformattedBlock < Node
-      def initialize(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
+      def initialize(name, ids, classes, params, named_params, codelanguage, content, line_no)
         @name = name
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
+        @params = params
+        @named_params = named_params
         @codelanguage = codelanguage
         @content = content
         @line_no = line_no
@@ -201,17 +226,17 @@ class NoraMark::Parser < KPeg::CompiledParser
       attr_reader :name
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
+      attr_reader :params
+      attr_reader :named_params
       attr_reader :codelanguage
       attr_reader :content
       attr_reader :line_no
     end
     class Root < Node
-      def initialize(content)
-        @content = content
+      def initialize(raw_content)
+        @raw_content = raw_content
       end
-      attr_reader :content
+      attr_reader :raw_content
     end
     class Text < Node
       def initialize(content, line_no)
@@ -222,92 +247,95 @@ class NoraMark::Parser < KPeg::CompiledParser
       attr_reader :line_no
     end
     class UlItem < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
     class UnorderedList < Node
-      def initialize(ids, classes, parameters, named_parameters, content, line_no)
+      def initialize(ids, classes, params, named_params, raw_content, line_no)
         @ids = ids
         @classes = classes
-        @parameters = parameters
-        @named_parameters = named_parameters
-        @content = content
+        @params = params
+        @named_params = named_params
+        @raw_content = raw_content
         @line_no = line_no
       end
       attr_reader :ids
       attr_reader :classes
-      attr_reader :parameters
-      attr_reader :named_parameters
-      attr_reader :content
+      attr_reader :params
+      attr_reader :named_params
+      attr_reader :raw_content
       attr_reader :line_no
     end
   end
   module ::NoraMarkConstruction
-    def block(name, ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::Block.new(name, ids, classes, parameters, named_parameters, content, line_no)
+    def block(name, ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::Block.new(name, ids, classes, params, named_params, raw_content, line_no)
     end
     def br(line_no)
       ::NoraMark::Breakline.new(line_no)
     end
-    def definition_list(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::DefinitionList.new(ids, classes, parameters, named_parameters, content, line_no)
+    def code_inline(ids, classes, params, named_params, content, line_no)
+      ::NoraMark::CodeInline.new(ids, classes, params, named_params, content, line_no)
+    end
+    def definition_list(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::DefinitionList.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def dl_item(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::DLItem.new(ids, classes, parameters, named_parameters, content, line_no)
+    def dl_item(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::DLItem.new(ids, classes, params, named_params, raw_content, line_no)
     end
     def frontmatter(content, line_no)
       ::NoraMark::Frontmatter.new(content, line_no)
     end
-    def h_section(level, heading, content, line_no)
-      ::NoraMark::HeadedSection.new(level, heading, content, line_no)
+    def h_section(level, heading, params, named_params, raw_content, line_no)
+      ::NoraMark::HeadedSection.new(level, heading, params, named_params, raw_content, line_no)
     end
-    def inline(name, ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::Inline.new(name, ids, classes, parameters, named_parameters, content, line_no)
+    def inline(name, ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::Inline.new(name, ids, classes, params, named_params, raw_content, line_no)
     end
-    def newpage(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::Newpage.new(ids, classes, parameters, named_parameters, content, line_no)
+    def newpage(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::Newpage.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def ol_item(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::OlItem.new(ids, classes, parameters, named_parameters, content, line_no)
+    def ol_item(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::OlItem.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def ordered_list(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::OrderedList.new(ids, classes, parameters, named_parameters, content, line_no)
+    def ordered_list(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::OrderedList.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def page(content, line_no)
-      ::NoraMark::Page.new(content, line_no)
+    def page(raw_content, line_no)
+      ::NoraMark::Page.new(raw_content, line_no)
     end
-    def paragraph(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::Paragraph.new(ids, classes, parameters, named_parameters, content, line_no)
+    def paragraph(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::Paragraph.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def paragraph_group(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::ParagraphGroup.new(ids, classes, parameters, named_parameters, content, line_no)
+    def paragraph_group(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::ParagraphGroup.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def preformatted_block(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
-      ::NoraMark::PreformattedBlock.new(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
+    def preformatted_block(name, ids, classes, params, named_params, codelanguage, content, line_no)
+      ::NoraMark::PreformattedBlock.new(name, ids, classes, params, named_params, codelanguage, content, line_no)
     end
-    def root(content)
-      ::NoraMark::Root.new(content)
+    def root(raw_content)
+      ::NoraMark::Root.new(raw_content)
     end
     def text(content, line_no)
       ::NoraMark::Text.new(content, line_no)
     end
-    def ul_item(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::UlItem.new(ids, classes, parameters, named_parameters, content, line_no)
+    def ul_item(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::UlItem.new(ids, classes, params, named_params, raw_content, line_no)
     end
-    def unordered_list(ids, classes, parameters, named_parameters, content, line_no)
-      ::NoraMark::UnorderedList.new(ids, classes, parameters, named_parameters, content, line_no)
+    def unordered_list(ids, classes, params, named_params, raw_content, line_no)
+      ::NoraMark::UnorderedList.new(ids, classes, params, named_params, raw_content, line_no)
     end
   end
   include ::NoraMarkConstruction
@@ -355,40 +383,47 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # EofComment = Space* "#" (!Eof .)*
+  # - = Space*
+  def __hyphen_
+    while true
+      _tmp = apply(:_Space)
+      break unless _tmp
+    end
+    _tmp = true
+    set_failed_rule :__hyphen_ unless _tmp
+    return _tmp
+  end
+
+  # EofComment = - "//" (!Eof .)*
   def _EofComment
 
     _save = self.pos
     while true # sequence
-      while true
-        _tmp = apply(:_Space)
-        break unless _tmp
-      end
-      _tmp = true
+      _tmp = apply(:__hyphen_)
       unless _tmp
         self.pos = _save
         break
       end
-      _tmp = match_string("#")
+      _tmp = match_string("//")
       unless _tmp
         self.pos = _save
         break
       end
       while true
 
-        _save3 = self.pos
+        _save2 = self.pos
         while true # sequence
-          _save4 = self.pos
+          _save3 = self.pos
           _tmp = apply(:_Eof)
           _tmp = _tmp ? nil : true
-          self.pos = _save4
+          self.pos = _save3
           unless _tmp
-            self.pos = _save3
+            self.pos = _save2
             break
           end
           _tmp = get_byte
           unless _tmp
-            self.pos = _save3
+            self.pos = _save2
           end
           break
         end # end sequence
@@ -406,40 +441,36 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # Comment = Space* "#" (!Nl .)* Nl EmptyLine*
+  # Comment = - "//" (!Nl .)* Nl EmptyLine*
   def _Comment
 
     _save = self.pos
     while true # sequence
-      while true
-        _tmp = apply(:_Space)
-        break unless _tmp
-      end
-      _tmp = true
+      _tmp = apply(:__hyphen_)
       unless _tmp
         self.pos = _save
         break
       end
-      _tmp = match_string("#")
+      _tmp = match_string("//")
       unless _tmp
         self.pos = _save
         break
       end
       while true
 
-        _save3 = self.pos
+        _save2 = self.pos
         while true # sequence
-          _save4 = self.pos
+          _save3 = self.pos
           _tmp = apply(:_Nl)
           _tmp = _tmp ? nil : true
-          self.pos = _save4
+          self.pos = _save3
           unless _tmp
-            self.pos = _save3
+            self.pos = _save2
             break
           end
           _tmp = get_byte
           unless _tmp
-            self.pos = _save3
+            self.pos = _save2
           end
           break
         end # end sequence
@@ -471,17 +502,6 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # - = Space*
-  def __hyphen_
-    while true
-      _tmp = apply(:_Space)
-      break unless _tmp
-    end
-    _tmp = true
-    set_failed_rule :__hyphen_ unless _tmp
-    return _tmp
-  end
-
   # EmptyLine = /^/ - (Nl | Comment | EofComment)
   def _EmptyLine
 
@@ -547,7 +567,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # Word = < /[\w0-9]/ ("-" | /[\w0-9]/)* > { text }
+  # Word = < /[\w]/ ("-" | /[\w]/)* > { text }
   def _Word
 
     _save = self.pos
@@ -556,7 +576,7 @@ class NoraMark::Parser < KPeg::CompiledParser
 
       _save1 = self.pos
       while true # sequence
-        _tmp = scan(/\A(?-mix:[\w0-9])/)
+        _tmp = scan(/\A(?-mix:[\w])/)
         unless _tmp
           self.pos = _save1
           break
@@ -568,7 +588,7 @@ class NoraMark::Parser < KPeg::CompiledParser
             _tmp = match_string("-")
             break if _tmp
             self.pos = _save3
-            _tmp = scan(/\A(?-mix:[\w0-9])/)
+            _tmp = scan(/\A(?-mix:[\w])/)
             break if _tmp
             self.pos = _save3
             break
@@ -821,25 +841,18 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ParameterNormal = < /[^,)]/* > { text }
+  # ParameterNormal = DocumentContentExcept(PARAMETER_END):content { content }
   def _ParameterNormal
 
     _save = self.pos
     while true # sequence
-      _text_start = self.pos
-      while true
-        _tmp = scan(/\A(?-mix:[^,)])/)
-        break unless _tmp
-      end
-      _tmp = true
-      if _tmp
-        text = get_text(_text_start)
-      end
+      _tmp = apply_with_args(:_DocumentContentExcept, PARAMETER_END)
+      content = @result
       unless _tmp
         self.pos = _save
         break
       end
-      @result = begin;  text ; end
+      @result = begin;  content ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -851,7 +864,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ParameterQuoted = "\"" < /[^"]/* > "\"" - &/[,)]/ { text }
+  # ParameterQuoted = "\"" DocumentContentExcept('"'):content "\"" - &/[,)]/ { content }
   def _ParameterQuoted
 
     _save = self.pos
@@ -861,15 +874,8 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _text_start = self.pos
-      while true
-        _tmp = scan(/\A(?-mix:[^"])/)
-        break unless _tmp
-      end
-      _tmp = true
-      if _tmp
-        text = get_text(_text_start)
-      end
+      _tmp = apply_with_args(:_DocumentContentExcept, '"')
+      content = @result
       unless _tmp
         self.pos = _save
         break
@@ -884,14 +890,14 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _save2 = self.pos
+      _save1 = self.pos
       _tmp = scan(/\A(?-mix:[,)])/)
-      self.pos = _save2
+      self.pos = _save1
       unless _tmp
         self.pos = _save
         break
       end
-      @result = begin;  text ; end
+      @result = begin;  content ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -903,7 +909,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ParameterSingleQuoted = "'" < /[^']/* > "'" - &/[,)]/ { text }
+  # ParameterSingleQuoted = "'" DocumentContentExcept("'"):content "'" - &/[,)]/ { content }
   def _ParameterSingleQuoted
 
     _save = self.pos
@@ -913,15 +919,8 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _text_start = self.pos
-      while true
-        _tmp = scan(/\A(?-mix:[^'])/)
-        break unless _tmp
-      end
-      _tmp = true
-      if _tmp
-        text = get_text(_text_start)
-      end
+      _tmp = apply_with_args(:_DocumentContentExcept, "'")
+      content = @result
       unless _tmp
         self.pos = _save
         break
@@ -936,14 +935,14 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _save2 = self.pos
+      _save1 = self.pos
       _tmp = scan(/\A(?-mix:[,)])/)
-      self.pos = _save2
+      self.pos = _save1
       unless _tmp
         self.pos = _save
         break
       end
-      @result = begin;  text ; end
+      @result = begin;  content ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -1447,7 +1446,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], [], content, ln)}
+  # ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], {}, content, ln)}
   def _ImplicitParagraph
 
     _save = self.pos
@@ -1505,7 +1504,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; paragraph([],[], [], [], content, ln); end
+      @result = begin; paragraph([],[], [], {}, content, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -1623,7 +1622,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ParagraphGroup = ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],[],p, ln)}
+  # ParagraphGroup = ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],{},p, ln)}
   def _ParagraphGroup
 
     _save = self.pos
@@ -1663,7 +1662,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; paragraph_group([],[],[],[],p, ln); end
+      @result = begin; paragraph_group([],[],[],{},p, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2009,26 +2008,8 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # PreformattedCommandHead = (PreformattedCommandHeadComplex | PreformattedCommandHeadSimple)
-  def _PreformattedCommandHead
-
-    _save = self.pos
-    while true # choice
-      _tmp = apply(:_PreformattedCommandHeadComplex)
-      break if _tmp
-      self.pos = _save
-      _tmp = apply(:_PreformattedCommandHeadSimple)
-      break if _tmp
-      self.pos = _save
-      break
-    end # end choice
-
-    set_failed_rule :_PreformattedCommandHead unless _tmp
-    return _tmp
-  end
-
-  # PreformatEndSimple = - "}" - Le EmptyLine*
-  def _PreformatEndSimple
+  # PreformattedFence = - "```" Word?:codelanguage ("(" - Parameters:args - ")")? ("[" - NamedParameters:named_args - "]")? - Nl { {codelanguage: codelanguage,                      args: args || [],                      named_args: named_args || {} } }
+  def _PreformattedFence
 
     _save = self.pos
     while true # sequence
@@ -2037,47 +2018,99 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _tmp = match_string("}")
+      _tmp = match_string("```")
       unless _tmp
         self.pos = _save
         break
       end
-      _tmp = apply(:__hyphen_)
+      _save1 = self.pos
+      _tmp = apply(:_Word)
+      @result = nil unless _tmp
       unless _tmp
-        self.pos = _save
-        break
+        _tmp = true
+        self.pos = _save1
       end
-      _tmp = apply(:_Le)
+      codelanguage = @result
       unless _tmp
         self.pos = _save
         break
       end
-      while true
-        _tmp = apply(:_EmptyLine)
-        break unless _tmp
+      _save2 = self.pos
+
+      _save3 = self.pos
+      while true # sequence
+        _tmp = match_string("(")
+        unless _tmp
+          self.pos = _save3
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save3
+          break
+        end
+        _tmp = apply(:_Parameters)
+        args = @result
+        unless _tmp
+          self.pos = _save3
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save3
+          break
+        end
+        _tmp = match_string(")")
+        unless _tmp
+          self.pos = _save3
+        end
+        break
+      end # end sequence
+
+      unless _tmp
+        _tmp = true
+        self.pos = _save2
       end
-      _tmp = true
       unless _tmp
         self.pos = _save
+        break
       end
-      break
-    end # end sequence
-
-    set_failed_rule :_PreformatEndSimple unless _tmp
-    return _tmp
-  end
+      _save4 = self.pos
 
-  # PreformatEndComplex = - "//}" - Le EmptyLine*
-  def _PreformatEndComplex
+      _save5 = self.pos
+      while true # sequence
+        _tmp = match_string("[")
+        unless _tmp
+          self.pos = _save5
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save5
+          break
+        end
+        _tmp = apply(:_NamedParameters)
+        named_args = @result
+        unless _tmp
+          self.pos = _save5
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save5
+          break
+        end
+        _tmp = match_string("]")
+        unless _tmp
+          self.pos = _save5
+        end
+        break
+      end # end sequence
 
-    _save = self.pos
-    while true # sequence
-      _tmp = apply(:__hyphen_)
       unless _tmp
-        self.pos = _save
-        break
+        _tmp = true
+        self.pos = _save4
       end
-      _tmp = match_string("//}")
       unless _tmp
         self.pos = _save
         break
@@ -2087,15 +2120,14 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _tmp = apply(:_Le)
+      _tmp = apply(:_Nl)
       unless _tmp
         self.pos = _save
         break
       end
-      while true
-        _tmp = apply(:_EmptyLine)
-        break unless _tmp
-      end
+      @result = begin;  {codelanguage: codelanguage,
+                     args: args || [],
+                     named_args: named_args || {} } ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2103,11 +2135,112 @@ class NoraMark::Parser < KPeg::CompiledParser
       break
     end # end sequence
 
-    set_failed_rule :_PreformatEndComplex unless _tmp
+    set_failed_rule :_PreformattedFence unless _tmp
     return _tmp
   end
 
-  # PreformattedBlockSimple = - PreformattedCommandHeadSimple:c (!PreformatEndSimple CharString Nl)+:content PreformatEndSimple {preformatted_block(c[:name], c[:ids], c[:classes], c[:args],  c[:named_args], c[:codelanguage], content,  c[:ln])}
+  # PreformattedCommandHead = (PreformattedCommandHeadComplex | PreformattedCommandHeadSimple | PreformattedFence)
+  def _PreformattedCommandHead
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_PreformattedCommandHeadComplex)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_PreformattedCommandHeadSimple)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_PreformattedFence)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_PreformattedCommandHead unless _tmp
+    return _tmp
+  end
+
+  # PreformatEndSimple = - "}" - Le EmptyLine*
+  def _PreformatEndSimple
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("}")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_Le)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      while true
+        _tmp = apply(:_EmptyLine)
+        break unless _tmp
+      end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_PreformatEndSimple unless _tmp
+    return _tmp
+  end
+
+  # PreformatEndComplex = - "//}" - Le EmptyLine*
+  def _PreformatEndComplex
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("//}")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_Le)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      while true
+        _tmp = apply(:_EmptyLine)
+        break unless _tmp
+      end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_PreformatEndComplex unless _tmp
+    return _tmp
+  end
+
+  # PreformattedBlockSimple = - PreformattedCommandHeadSimple:c (!PreformatEndSimple CharString Nl)+:content PreformatEndSimple {preformatted_block(c[:name], c[:ids], c[:classes], c[:args],  c[:named_args], c[:codelanguage], content,  c[:ln])}
   def _PreformattedBlockSimple
 
     _save = self.pos
@@ -2301,7 +2434,134 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # PreformattedBlock = (PreformattedBlockComplex | PreformattedBlockSimple)
+  # PreformattedBlockFence = - ln:ln PreformattedFence:c (!"```" CharString Nl)+:content - "```" - Le EmptyLine* {preformatted_block('code', [], [], c[:args], c[:named_args], c[:codelanguage], content, ln)}
+  def _PreformattedBlockFence
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_ln)
+      ln = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_PreformattedFence)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _ary = []
+
+      _save2 = self.pos
+      while true # sequence
+        _save3 = self.pos
+        _tmp = match_string("```")
+        _tmp = _tmp ? nil : true
+        self.pos = _save3
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = apply(:_CharString)
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = apply(:_Nl)
+        unless _tmp
+          self.pos = _save2
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        _ary << @result
+        while true
+
+          _save4 = self.pos
+          while true # sequence
+            _save5 = self.pos
+            _tmp = match_string("```")
+            _tmp = _tmp ? nil : true
+            self.pos = _save5
+            unless _tmp
+              self.pos = _save4
+              break
+            end
+            _tmp = apply(:_CharString)
+            unless _tmp
+              self.pos = _save4
+              break
+            end
+            _tmp = apply(:_Nl)
+            unless _tmp
+              self.pos = _save4
+            end
+            break
+          end # end sequence
+
+          _ary << @result if _tmp
+          break unless _tmp
+        end
+        _tmp = true
+        @result = _ary
+      else
+        self.pos = _save1
+      end
+      content = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("```")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_Le)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      while true
+        _tmp = apply(:_EmptyLine)
+        break unless _tmp
+      end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; preformatted_block('code', [], [], c[:args], c[:named_args], c[:codelanguage], content, ln); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_PreformattedBlockFence unless _tmp
+    return _tmp
+  end
+
+  # PreformattedBlock = (PreformattedBlockComplex | PreformattedBlockSimple | PreformattedBlockFence)
   def _PreformattedBlock
 
     _save = self.pos
@@ -2312,6 +2572,9 @@ class NoraMark::Parser < KPeg::CompiledParser
       _tmp = apply(:_PreformattedBlockSimple)
       break if _tmp
       self.pos = _save
+      _tmp = apply(:_PreformattedBlockFence)
+      break if _tmp
+      self.pos = _save
       break
     end # end choice
 
@@ -2319,17 +2582,29 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # Inline = (ImgInline | CommonInline)
+  # Inline = (EscapedChar | ImgInline | MediaInline | CodeInline | CommonInline | FenceInline)
   def _Inline
 
     _save = self.pos
     while true # choice
+      _tmp = apply(:_EscapedChar)
+      break if _tmp
+      self.pos = _save
       _tmp = apply(:_ImgInline)
       break if _tmp
       self.pos = _save
+      _tmp = apply(:_MediaInline)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_CodeInline)
+      break if _tmp
+      self.pos = _save
       _tmp = apply(:_CommonInline)
       break if _tmp
       self.pos = _save
+      _tmp = apply(:_FenceInline)
+      break if _tmp
+      self.pos = _save
       break
     end # end choice
 
@@ -2436,7 +2711,253 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  nil,  c[:ln]); end
+      @result = begin; inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  nil,  c[:ln]); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_ImgInline unless _tmp
+    return _tmp
+  end
+
+  # MediaCommand = Command:c &{ (c[:name] == 'video' || c[:name] == 'audio') && c[:args].size > 0}
+  def _MediaCommand
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_Command)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = begin;  (c[:name] == 'video' || c[:name] == 'audio') && c[:args].size > 0; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_MediaCommand unless _tmp
+    return _tmp
+  end
+
+  # MediaInline = "[" MediaCommand:c ("{" - DocumentContentExcept('}'):content "}")? "]" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln])}
+  def _MediaInline
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("[")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_MediaCommand)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+
+      _save2 = self.pos
+      while true # sequence
+        _tmp = match_string("{")
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = apply_with_args(:_DocumentContentExcept, '}')
+        content = @result
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = match_string("}")
+        unless _tmp
+          self.pos = _save2
+        end
+        break
+      end # end sequence
+
+      unless _tmp
+        _tmp = true
+        self.pos = _save1
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("]")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln]); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_MediaInline unless _tmp
+    return _tmp
+  end
+
+  # FenceInline = "`" ln:ln CharStringExcept('`'):content "`" {code_inline([], [], [], {}, content, ln)}
+  def _FenceInline
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("`")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_ln)
+      ln = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply_with_args(:_CharStringExcept, '`')
+      content = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("`")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; code_inline([], [], [], {}, content, ln); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_FenceInline unless _tmp
+    return _tmp
+  end
+
+  # CodeCommand = Command:c &{ c[:name] == 'code' }
+  def _CodeCommand
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_Command)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = begin;  c[:name] == 'code' ; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_CodeCommand unless _tmp
+    return _tmp
+  end
+
+  # CodeInline = "[" CodeCommand:c "{" - CharStringExcept('}'):content "}" "]" {code_inline(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}
+  def _CodeInline
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("[")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_CodeCommand)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("{")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply_with_args(:_CharStringExcept, '}')
+      content = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("}")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("]")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; code_inline(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln]); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_CodeInline unless _tmp
+    return _tmp
+  end
+
+  # EscapedChar = "\\" < /[`]/ > ln:ln {text(text, ln)}
+  def _EscapedChar
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("\\")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _text_start = self.pos
+      _tmp = scan(/\A(?-mix:[`])/)
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_ln)
+      ln = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; text(text, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2444,7 +2965,7 @@ class NoraMark::Parser < KPeg::CompiledParser
       break
     end # end sequence
 
-    set_failed_rule :_ImgInline unless _tmp
+    set_failed_rule :_EscapedChar unless _tmp
     return _tmp
   end
 
@@ -2550,8 +3071,45 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # UnorderedList = ln:ln UnorderedItem+:items {unordered_list([],[],[],[], items, ln)}
-  def _UnorderedList
+  # UnorderedStart = /^/ - < /\*+/ > &{ text.length == n && text.size < 5 }
+  def _UnorderedStart(n)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = scan(/\A(?-mix:^)/)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _text_start = self.pos
+      _tmp = scan(/\A(?-mix:\*+)/)
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = begin;  text.length == n && text.size < 5 ; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_UnorderedStart unless _tmp
+    return _tmp
+  end
+
+  # UnorderedList = ln:ln UnorderedItem(n)+:items {unordered_list([],[],[],{}, items, ln)}
+  def _UnorderedList(n)
 
     _save = self.pos
     while true # sequence
@@ -2563,11 +3121,11 @@ class NoraMark::Parser < KPeg::CompiledParser
       end
       _save1 = self.pos
       _ary = []
-      _tmp = apply(:_UnorderedItem)
+      _tmp = apply_with_args(:_UnorderedItem, n)
       if _tmp
         _ary << @result
         while true
-          _tmp = apply(:_UnorderedItem)
+          _tmp = apply_with_args(:_UnorderedItem, n)
           _ary << @result if _tmp
           break unless _tmp
         end
@@ -2581,7 +3139,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; unordered_list([],[],[],[], items, ln); end
+      @result = begin; unordered_list([],[],[],{}, items, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2593,18 +3151,18 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # UnorderedItem = ln:ln "*:" - DocumentContent:content Le {ul_item([], [], [], [], content, ln)}
-  def _UnorderedItem
+  # UnorderedItem = UnorderedStart(n) ln:ln - UnorderedItemBody(n):content {ul_item([], [], [], {}, content, ln)}
+  def _UnorderedItem(n)
 
     _save = self.pos
     while true # sequence
-      _tmp = apply(:_ln)
-      ln = @result
+      _tmp = apply_with_args(:_UnorderedStart, n)
       unless _tmp
         self.pos = _save
         break
       end
-      _tmp = match_string("*:")
+      _tmp = apply(:_ln)
+      ln = @result
       unless _tmp
         self.pos = _save
         break
@@ -2614,18 +3172,13 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _tmp = apply(:_DocumentContent)
+      _tmp = apply_with_args(:_UnorderedItemBody, n)
       content = @result
       unless _tmp
         self.pos = _save
         break
       end
-      _tmp = apply(:_Le)
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin; ul_item([], [], [], [], content, ln); end
+      @result = begin; ul_item([], [], [], {}, content, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2637,7 +3190,91 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # OrderedList = ln:ln OrderedItem+:items {ordered_list([],[],[], [], items, ln)}
+  # UnorderedItemBody = (DocumentContent:content Nl - &UnorderedStart(n + 1) ln:ln UnorderedList(n + 1):sub_ul { content << sub_ul } | DocumentContent:content Le { content })
+  def _UnorderedItemBody(n)
+
+    _save = self.pos
+    while true # choice
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_DocumentContent)
+        content = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_Nl)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save2 = self.pos
+        _tmp = apply_with_args(:_UnorderedStart, n + 1)
+        self.pos = _save2
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_ln)
+        ln = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply_with_args(:_UnorderedList, n + 1)
+        sub_ul = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        @result = begin;  content << sub_ul ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
+
+      _save3 = self.pos
+      while true # sequence
+        _tmp = apply(:_DocumentContent)
+        content = @result
+        unless _tmp
+          self.pos = _save3
+          break
+        end
+        _tmp = apply(:_Le)
+        unless _tmp
+          self.pos = _save3
+          break
+        end
+        @result = begin;  content ; end
+        _tmp = true
+        unless _tmp
+          self.pos = _save3
+        end
+        break
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_UnorderedItemBody unless _tmp
+    return _tmp
+  end
+
+  # OrderedList = ln:ln OrderedItem+:items {ordered_list([],[],[], {}, items, ln)}
   def _OrderedList
 
     _save = self.pos
@@ -2668,7 +3305,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; ordered_list([],[],[], [], items, ln); end
+      @result = begin; ordered_list([],[],[], {}, items, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2680,11 +3317,16 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # OrderedItem = ln:ln Num ":" - DocumentContent:content Le {ol_item([], [], [], [], content, ln)}
+  # OrderedItem = - ln:ln Num "." - DocumentContent:content Le {ol_item([], [], [], {}, content, ln)}
   def _OrderedItem
 
     _save = self.pos
     while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _tmp = apply(:_ln)
       ln = @result
       unless _tmp
@@ -2696,7 +3338,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _tmp = match_string(":")
+      _tmp = match_string(".")
       unless _tmp
         self.pos = _save
         break
@@ -2717,7 +3359,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; ol_item([], [], [], [], content, ln); end
+      @result = begin; ol_item([], [], [], {}, content, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2729,7 +3371,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # DefinitionList = ln:ln DefinitionItem+:items {definition_list([], [], [], [], items, ln)}
+  # DefinitionList = ln:ln DefinitionItem+:items {definition_list([], [], [], {}, items, ln)}
   def _DefinitionList
 
     _save = self.pos
@@ -2760,7 +3402,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; definition_list([], [], [], [], items, ln); end
+      @result = begin; definition_list([], [], [], {}, items, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2772,7 +3414,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # DefinitionItem = - ln:ln ";:" - DocumentContentExcept(':'):term ":" - DocumentContent:definition Le {dl_item([], [], [term], [], definition, ln)}
+  # DefinitionItem = - ln:ln - ";:" - DocumentContentExcept(':'):term ":" - DocumentContent:definition Le {dl_item([], [], [term], {}, definition, ln)}
   def _DefinitionItem
 
     _save = self.pos
@@ -2788,6 +3430,11 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _tmp = match_string(";:")
       unless _tmp
         self.pos = _save
@@ -2825,7 +3472,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; dl_item([], [], [term], [], definition, ln); end
+      @result = begin; dl_item([], [], [term], {}, definition, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2837,7 +3484,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # LongDefinitionList = ln:ln LongDefinitionItem+:items {definition_list([], [], [], [], items, ln)}
+  # LongDefinitionList = ln:ln LongDefinitionItem+:items {definition_list([], [], [], {}, items, ln)}
   def _LongDefinitionList
 
     _save = self.pos
@@ -2868,7 +3515,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; definition_list([], [], [], [], items, ln); end
+      @result = begin; definition_list([], [], [], {}, items, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2880,7 +3527,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # LongDefinitionItem = - ln:ln ";:" - DocumentContentExcept('{'):term "{" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], [], definition, ln)}
+  # LongDefinitionItem = - ln:ln ";:" - DocumentContentExcept('{'):term "{" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], {}, definition, ln)}
   def _LongDefinitionItem
 
     _save = self.pos
@@ -2948,7 +3595,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; dl_item([], [], [term], [], definition, ln); end
+      @result = begin; dl_item([], [], [term], {}, definition, ln); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2960,12 +3607,12 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # ItemsList = (UnorderedList | OrderedList | DefinitionList | LongDefinitionList)
+  # ItemsList = (UnorderedList(1) | OrderedList | DefinitionList | LongDefinitionList)
   def _ItemsList
 
     _save = self.pos
     while true # choice
-      _tmp = apply(:_UnorderedList)
+      _tmp = apply_with_args(:_UnorderedList, 1)
       break if _tmp
       self.pos = _save
       _tmp = apply(:_OrderedList)
@@ -3176,37 +3823,28 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # HStartMark = < "="+ ":" > &{ text.length - 1 == n }
+  # HStartMark = - < "#"+ > &{ text.length == n }
   def _HStartMark(n)
 
     _save = self.pos
     while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _text_start = self.pos
-
       _save1 = self.pos
-      while true # sequence
-        _save2 = self.pos
-        _tmp = match_string("=")
-        if _tmp
-          while true
-            _tmp = match_string("=")
-            break unless _tmp
-          end
-          _tmp = true
-        else
-          self.pos = _save2
-        end
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = match_string(":")
-        unless _tmp
-          self.pos = _save1
+      _tmp = match_string("#")
+      if _tmp
+        while true
+          _tmp = match_string("#")
+          break unless _tmp
         end
-        break
-      end # end sequence
-
+        _tmp = true
+      else
+        self.pos = _save1
+      end
       if _tmp
         text = get_text(_text_start)
       end
@@ -3214,9 +3852,9 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _save3 = self.pos
-      _tmp = begin;  text.length - 1 == n ; end
-      self.pos = _save3
+      _save2 = self.pos
+      _tmp = begin;  text.length == n ; end
+      self.pos = _save2
       unless _tmp
         self.pos = _save
       end
@@ -3227,7 +3865,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # HMarkupTerminator = (- < "="+ ":" > &{ text.length - 1 <= n } | - Eof)
+  # HMarkupTerminator = (- < "#"+ > - CharString:cs Le &{ text.length <= n && !cs.strip.end_with?('{') } | - Eof)
   def _HMarkupTerminator(n)
 
     _save = self.pos
@@ -3241,74 +3879,183 @@ class NoraMark::Parser < KPeg::CompiledParser
           break
         end
         _text_start = self.pos
-
         _save2 = self.pos
-        while true # sequence
-          _save3 = self.pos
-          _tmp = match_string("=")
-          if _tmp
-            while true
-              _tmp = match_string("=")
-              break unless _tmp
-            end
-            _tmp = true
-          else
-            self.pos = _save3
-          end
-          unless _tmp
-            self.pos = _save2
-            break
-          end
-          _tmp = match_string(":")
-          unless _tmp
-            self.pos = _save2
+        _tmp = match_string("#")
+        if _tmp
+          while true
+            _tmp = match_string("#")
+            break unless _tmp
           end
+          _tmp = true
+        else
+          self.pos = _save2
+        end
+        if _tmp
+          text = get_text(_text_start)
+        end
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_CharString)
+        cs = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_Le)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save3 = self.pos
+        _tmp = begin;  text.length <= n && !cs.strip.end_with?('{') ; end
+        self.pos = _save3
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
+
+      _save4 = self.pos
+      while true # sequence
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save4
+          break
+        end
+        _tmp = apply(:_Eof)
+        unless _tmp
+          self.pos = _save4
+        end
+        break
+      end # end sequence
+
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_HMarkupTerminator unless _tmp
+    return _tmp
+  end
+
+  # HStartCommand = - HStartMark(n) ("(" - Parameters:args - ")")? ("[" - NamedParameters:named_args - "]")? { { args: args || [] , named_args: named_args || {}} }
+  def _HStartCommand(n)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply_with_args(:_HStartMark, n)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+
+      _save2 = self.pos
+      while true # sequence
+        _tmp = match_string("(")
+        unless _tmp
+          self.pos = _save2
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save2
           break
-        end # end sequence
-
-        if _tmp
-          text = get_text(_text_start)
         end
+        _tmp = apply(:_Parameters)
+        args = @result
         unless _tmp
-          self.pos = _save1
+          self.pos = _save2
           break
         end
-        _save4 = self.pos
-        _tmp = begin;  text.length - 1 <= n ; end
-        self.pos = _save4
+        _tmp = apply(:__hyphen_)
         unless _tmp
-          self.pos = _save1
+          self.pos = _save2
+          break
+        end
+        _tmp = match_string(")")
+        unless _tmp
+          self.pos = _save2
         end
         break
       end # end sequence
 
-      break if _tmp
-      self.pos = _save
+      unless _tmp
+        _tmp = true
+        self.pos = _save1
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save3 = self.pos
 
-      _save5 = self.pos
+      _save4 = self.pos
       while true # sequence
+        _tmp = match_string("[")
+        unless _tmp
+          self.pos = _save4
+          break
+        end
         _tmp = apply(:__hyphen_)
         unless _tmp
-          self.pos = _save5
+          self.pos = _save4
           break
         end
-        _tmp = apply(:_Eof)
+        _tmp = apply(:_NamedParameters)
+        named_args = @result
         unless _tmp
-          self.pos = _save5
+          self.pos = _save4
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save4
+          break
+        end
+        _tmp = match_string("]")
+        unless _tmp
+          self.pos = _save4
         end
         break
       end # end sequence
 
-      break if _tmp
-      self.pos = _save
+      unless _tmp
+        _tmp = true
+        self.pos = _save3
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  { args: args || [] , named_args: named_args || {}} ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
       break
-    end # end choice
+    end # end sequence
 
-    set_failed_rule :_HMarkupTerminator unless _tmp
+    set_failed_rule :_HStartCommand unless _tmp
     return _tmp
   end
 
-  # HStart = - HStartMark(n) ln:ln - DocumentContent:s Le { { level: n, heading: s, ln: ln} }
+  # HStart = - HStartCommand(n):hsc ln:ln - DocumentContent:s Le { hsc.merge({ level: n, heading: s, ln: ln}) }
   def _HStart(n)
 
     _save = self.pos
@@ -3318,7 +4065,8 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      _tmp = apply_with_args(:_HStartMark, n)
+      _tmp = apply_with_args(:_HStartCommand, n)
+      hsc = @result
       unless _tmp
         self.pos = _save
         break
@@ -3345,7 +4093,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin;  { level: n, heading: s, ln: ln} ; end
+      @result = begin;  hsc.merge({ level: n, heading: s, ln: ln}) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -3357,7 +4105,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # HSection = HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], content, h[:ln])}
+  # HSection = HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}
   def _HSection(n)
 
     _save = self.pos
@@ -3416,7 +4164,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin; h_section(h[:level], h[:heading], content, h[:ln]); end
+      @result = begin; h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln]); end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -3428,27 +4176,163 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # HeadedStart = (HStart(1) | HStart(2) | HStart(3) | HStart(4) | HStart(5) | HStart(6))
+  # BlockHStart = - HStartCommand(n):hsc ln:ln - DocumentContentExcept('{'):s - "{" - Nl { hsc.merge({ level: n, heading: s, ln: ln}) }
+  def _BlockHStart(n)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply_with_args(:_HStartCommand, n)
+      hsc = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_ln)
+      ln = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply_with_args(:_DocumentContentExcept, '{')
+      s = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = match_string("{")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_Nl)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  hsc.merge({ level: n, heading: s, ln: ln}) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_BlockHStart unless _tmp
+    return _tmp
+  end
+
+  # ExplicitHSection = BlockHStart(n):h EmptyLine* - BlockBody:content - BlockEnd {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}
+  def _ExplicitHSection(n)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply_with_args(:_BlockHStart, n)
+      h = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      while true
+        _tmp = apply(:_EmptyLine)
+        break unless _tmp
+      end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_BlockBody)
+      content = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_BlockEnd)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln]); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_ExplicitHSection unless _tmp
+    return _tmp
+  end
+
+  # HeadedStart = (HStart(6) | HStart(5) | HStart(4) | HStart(3) | HStart(2) | HStart(1) | BlockHStart(6) | BlockHStart(5) | BlockHStart(4) | BlockHStart(3) | BlockHStart(2) | BlockHStart(1))
   def _HeadedStart
 
     _save = self.pos
     while true # choice
-      _tmp = apply_with_args(:_HStart, 1)
+      _tmp = apply_with_args(:_HStart, 6)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HStart, 2)
+      _tmp = apply_with_args(:_HStart, 5)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_HStart, 4)
       break if _tmp
       self.pos = _save
       _tmp = apply_with_args(:_HStart, 3)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HStart, 4)
+      _tmp = apply_with_args(:_HStart, 2)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HStart, 5)
+      _tmp = apply_with_args(:_HStart, 1)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HStart, 6)
+      _tmp = apply_with_args(:_BlockHStart, 6)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_BlockHStart, 5)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_BlockHStart, 4)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_BlockHStart, 3)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_BlockHStart, 2)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_BlockHStart, 1)
       break if _tmp
       self.pos = _save
       break
@@ -3458,29 +4342,47 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # HeadedSection = (HSection(1) | HSection(2) | HSection(3) | HSection(4) | HSection(5) | HSection(6))
+  # HeadedSection = (ExplicitHSection(6) | ExplicitHSection(5) | ExplicitHSection(4) | ExplicitHSection(3) | ExplicitHSection(2) | ExplicitHSection(1) | HSection(6) | HSection(5) | HSection(4) | HSection(3) | HSection(2) | HSection(1))
   def _HeadedSection
 
     _save = self.pos
     while true # choice
-      _tmp = apply_with_args(:_HSection, 1)
+      _tmp = apply_with_args(:_ExplicitHSection, 6)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HSection, 2)
+      _tmp = apply_with_args(:_ExplicitHSection, 5)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HSection, 3)
+      _tmp = apply_with_args(:_ExplicitHSection, 4)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HSection, 4)
+      _tmp = apply_with_args(:_ExplicitHSection, 3)
       break if _tmp
       self.pos = _save
-      _tmp = apply_with_args(:_HSection, 5)
+      _tmp = apply_with_args(:_ExplicitHSection, 2)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_ExplicitHSection, 1)
       break if _tmp
       self.pos = _save
       _tmp = apply_with_args(:_HSection, 6)
       break if _tmp
       self.pos = _save
+      _tmp = apply_with_args(:_HSection, 5)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_HSection, 4)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_HSection, 3)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_HSection, 2)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_HSection, 1)
+      break if _tmp
+      self.pos = _save
       break
     end # end choice
 
@@ -3681,7 +4583,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # CharExcept = Char:c &{ c != e }
+  # CharExcept = Char:c &{ e.is_a?(Regexp) ? e !~ c : e != c }
   def _CharExcept(e)
 
     _save = self.pos
@@ -3693,7 +4595,7 @@ class NoraMark::Parser < KPeg::CompiledParser
         break
       end
       _save1 = self.pos
-      _tmp = begin;  c != e ; end
+      _tmp = begin;  e.is_a?(Regexp) ? e !~ c : e != c ; end
       self.pos = _save1
       unless _tmp
         self.pos = _save
@@ -3705,6 +4607,42 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
+  # CharStringExcept = < CharExcept(e)+ > { text }
+  def _CharStringExcept(e)
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+      _save1 = self.pos
+      _tmp = apply_with_args(:_CharExcept, e)
+      if _tmp
+        while true
+          _tmp = apply_with_args(:_CharExcept, e)
+          break unless _tmp
+        end
+        _tmp = true
+      else
+        self.pos = _save1
+      end
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  text ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_CharStringExcept unless _tmp
+    return _tmp
+  end
+
   # DocumentTextExcept = < (!Inline CharExcept(e))+ > ln:ln {text(text, ln)}
   def _DocumentTextExcept(e)
 
@@ -4076,7 +5014,7 @@ class NoraMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # Pages = (Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages } | Page:page { [ page ] })
+  # Pages = (Page:page Newpage:newpage Pages:pages { pages.unshift(page) } | Page:page { [ page ] })
   def _Pages
 
     _save = self.pos
@@ -4102,7 +5040,7 @@ class NoraMark::Parser < KPeg::CompiledParser
           self.pos = _save1
           break
         end
-        @result = begin;  [ page, newpage ] + pages ; end
+        @result = begin;  pages.unshift(page) ; end
         _tmp = true
         unless _tmp
           self.pos = _save1
@@ -4200,22 +5138,22 @@ class NoraMark::Parser < KPeg::CompiledParser
   Rules[:_BOM] = rule_info("BOM", "/\\uFEFF/")
   Rules[:_Eof] = rule_info("Eof", "!.")
   Rules[:_Space] = rule_info("Space", "(\" \" | \"\\\\t\")")
-  Rules[:_EofComment] = rule_info("EofComment", "Space* \"\#\" (!Eof .)*")
-  Rules[:_Comment] = rule_info("Comment", "Space* \"\#\" (!Nl .)* Nl EmptyLine*")
   Rules[:__hyphen_] = rule_info("-", "Space*")
+  Rules[:_EofComment] = rule_info("EofComment", "- \"//\" (!Eof .)*")
+  Rules[:_Comment] = rule_info("Comment", "- \"//\" (!Nl .)* Nl EmptyLine*")
   Rules[:_EmptyLine] = rule_info("EmptyLine", "/^/ - (Nl | Comment | EofComment)")
   Rules[:_Nl] = rule_info("Nl", "/\\r?\\n/")
   Rules[:_Le] = rule_info("Le", "(Nl | Eof)")
-  Rules[:_Word] = rule_info("Word", "< /[\\w0-9]/ (\"-\" | /[\\w0-9]/)* > { text }")
+  Rules[:_Word] = rule_info("Word", "< /[\\w]/ (\"-\" | /[\\w]/)* > { text }")
   Rules[:_Num] = rule_info("Num", "< [0-9]+ > { text.to_i }")
   Rules[:_ClassName] = rule_info("ClassName", "\".\" Word:classname { classname }")
   Rules[:_ClassNames] = rule_info("ClassNames", "ClassName*:classnames { classnames }")
   Rules[:_IdName] = rule_info("IdName", "\"\#\" Word:idname { idname }")
   Rules[:_IdNames] = rule_info("IdNames", "IdName*:idnames { idnames }")
   Rules[:_CommandName] = rule_info("CommandName", "Word:name IdNames?:idnames ClassNames?:classes ln:ln { {name: name, ids: idnames, classes: classes, ln:ln } }")
-  Rules[:_ParameterNormal] = rule_info("ParameterNormal", "< /[^,)]/* > { text }")
-  Rules[:_ParameterQuoted] = rule_info("ParameterQuoted", "\"\\\"\" < /[^\"]/* > \"\\\"\" - &/[,)]/ { text }")
-  Rules[:_ParameterSingleQuoted] = rule_info("ParameterSingleQuoted", "\"'\" < /[^']/* > \"'\" - &/[,)]/ { text }")
+  Rules[:_ParameterNormal] = rule_info("ParameterNormal", "DocumentContentExcept(PARAMETER_END):content { content }")
+  Rules[:_ParameterQuoted] = rule_info("ParameterQuoted", "\"\\\"\" DocumentContentExcept('\"'):content \"\\\"\" - &/[,)]/ { content }")
+  Rules[:_ParameterSingleQuoted] = rule_info("ParameterSingleQuoted", "\"'\" DocumentContentExcept(\"'\"):content \"'\" - &/[,)]/ { content }")
   Rules[:_Parameter] = rule_info("Parameter", "(ParameterQuoted | ParameterSingleQuoted | ParameterNormal):value { value }")
   Rules[:_NParameterNormal] = rule_info("NParameterNormal", "< /[^,\\]]/* > { text }")
   Rules[:_NParameterQuoted] = rule_info("NParameterQuoted", "\"\\\"\" < /[^\"]/* > \"\\\"\" - &/[,\\]]/ { text }")
@@ -4225,11 +5163,11 @@ class NoraMark::Parser < KPeg::CompiledParser
   Rules[:_NamedParameter] = rule_info("NamedParameter", "Word:key - \":\" - NParameter:parameter { { key.to_sym => parameter } }")
   Rules[:_NamedParameters] = rule_info("NamedParameters", "(NamedParameter:parameter - \",\" - NamedParameters:parameters { parameter.merge parameters } | NamedParameter:parameter { parameter })")
   Rules[:_Command] = rule_info("Command", "CommandName:cn (\"(\" - Parameters:args - \")\")? (\"[\" - NamedParameters:named_args - \"]\")? { cn.merge({ args: args || [] , named_args: named_args || {}}) }")
-  Rules[:_ImplicitParagraph] = rule_info("ImplicitParagraph", "- !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], [], content, ln)}")
+  Rules[:_ImplicitParagraph] = rule_info("ImplicitParagraph", "- !ParagraphDelimiter Comment* DocumentLine:content ln:ln Comment* EofComment? {paragraph([],[], [], {}, content, ln)}")
   Rules[:_ExplicitParagraphCommand] = rule_info("ExplicitParagraphCommand", "Command:c &{ c[:name] == 'p' }")
   Rules[:_ExplicitParagraph] = rule_info("ExplicitParagraph", "- ExplicitParagraphCommand:c \":\" - DocumentContent?:content Le EmptyLine* {paragraph(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
   Rules[:_Paragraph] = rule_info("Paragraph", "(ExplicitParagraph | ImplicitParagraph)")
-  Rules[:_ParagraphGroup] = rule_info("ParagraphGroup", "ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],[],p, ln)}")
+  Rules[:_ParagraphGroup] = rule_info("ParagraphGroup", "ln:ln Paragraph+:p EmptyLine* {paragraph_group([],[],[],{},p, ln)}")
   Rules[:_BlockHead] = rule_info("BlockHead", "Command:command - \"{\" - Nl EmptyLine* { command }")
   Rules[:_BlockEnd] = rule_info("BlockEnd", "- \"}\" - Le EmptyLine*")
   Rules[:_BlockBody] = rule_info("BlockBody", "(!BlockEnd Block)+:body { body }")
@@ -4237,51 +5175,65 @@ class NoraMark::Parser < KPeg::CompiledParser
   Rules[:_PreformattedCommand] = rule_info("PreformattedCommand", "Command:command &{ ['pre', 'code'].include? command[:name] }")
   Rules[:_PreformattedCommandHeadSimple] = rule_info("PreformattedCommandHeadSimple", "PreformattedCommand:command - \"{\" - Nl { command }")
   Rules[:_PreformattedCommandHeadComplex] = rule_info("PreformattedCommandHeadComplex", "PreformattedCommand:command - \"{//\" Word?:codelanguage - Nl { command.merge({codelanguage: codelanguage}) }")
-  Rules[:_PreformattedCommandHead] = rule_info("PreformattedCommandHead", "(PreformattedCommandHeadComplex | PreformattedCommandHeadSimple)")
+  Rules[:_PreformattedFence] = rule_info("PreformattedFence", "- \"```\" Word?:codelanguage (\"(\" - Parameters:args - \")\")? (\"[\" - NamedParameters:named_args - \"]\")? - Nl { {codelanguage: codelanguage,                      args: args || [],                      named_args: named_args || {} } }")
+  Rules[:_PreformattedCommandHead] = rule_info("PreformattedCommandHead", "(PreformattedCommandHeadComplex | PreformattedCommandHeadSimple | PreformattedFence)")
   Rules[:_PreformatEndSimple] = rule_info("PreformatEndSimple", "- \"}\" - Le EmptyLine*")
   Rules[:_PreformatEndComplex] = rule_info("PreformatEndComplex", "- \"//}\" - Le EmptyLine*")
   Rules[:_PreformattedBlockSimple] = rule_info("PreformattedBlockSimple", "- PreformattedCommandHeadSimple:c (!PreformatEndSimple CharString Nl)+:content PreformatEndSimple {preformatted_block(c[:name], c[:ids], c[:classes], c[:args],  c[:named_args], c[:codelanguage], content,  c[:ln])}")
   Rules[:_PreformattedBlockComplex] = rule_info("PreformattedBlockComplex", "- PreformattedCommandHeadComplex:c (!PreformatEndComplex CharString Nl)+:content PreformatEndComplex {preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  c[:codelanguage], content,  c[:ln])}")
-  Rules[:_PreformattedBlock] = rule_info("PreformattedBlock", "(PreformattedBlockComplex | PreformattedBlockSimple)")
-  Rules[:_Inline] = rule_info("Inline", "(ImgInline | CommonInline)")
+  Rules[:_PreformattedBlockFence] = rule_info("PreformattedBlockFence", "- ln:ln PreformattedFence:c (!\"```\" CharString Nl)+:content - \"```\" - Le EmptyLine* {preformatted_block('code', [], [], c[:args], c[:named_args], c[:codelanguage], content, ln)}")
+  Rules[:_PreformattedBlock] = rule_info("PreformattedBlock", "(PreformattedBlockComplex | PreformattedBlockSimple | PreformattedBlockFence)")
+  Rules[:_Inline] = rule_info("Inline", "(EscapedChar | ImgInline | MediaInline | CodeInline | CommonInline | FenceInline)")
   Rules[:_CommonInline] = rule_info("CommonInline", "\"[\" Command:c \"{\" - DocumentContentExcept('}'):content \"}\" \"]\" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln])}")
   Rules[:_ImgCommand] = rule_info("ImgCommand", "Command:c &{ c[:name] == 'img' && c[:args].size == 2}")
   Rules[:_ImgInline] = rule_info("ImgInline", "\"[\" ImgCommand:c \"]\" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  nil,  c[:ln])}")
+  Rules[:_MediaCommand] = rule_info("MediaCommand", "Command:c &{ (c[:name] == 'video' || c[:name] == 'audio') && c[:args].size > 0}")
+  Rules[:_MediaInline] = rule_info("MediaInline", "\"[\" MediaCommand:c (\"{\" - DocumentContentExcept('}'):content \"}\")? \"]\" {inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln])}")
+  Rules[:_FenceInline] = rule_info("FenceInline", "\"`\" ln:ln CharStringExcept('`'):content \"`\" {code_inline([], [], [], {}, content, ln)}")
+  Rules[:_CodeCommand] = rule_info("CodeCommand", "Command:c &{ c[:name] == 'code' }")
+  Rules[:_CodeInline] = rule_info("CodeInline", "\"[\" CodeCommand:c \"{\" - CharStringExcept('}'):content \"}\" \"]\" {code_inline(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])}")
+  Rules[:_EscapedChar] = rule_info("EscapedChar", "\"\\\\\" < /[`]/ > ln:ln {text(text, ln)}")
   Rules[:_CommandNameForSpecialLineCommand] = rule_info("CommandNameForSpecialLineCommand", "(NewpageCommand | ExplicitParagraphCommand)")
   Rules[:_NewpageCommand] = rule_info("NewpageCommand", "Command:command &{ command[:name] == 'newpage' }")
   Rules[:_Newpage] = rule_info("Newpage", "- NewpageCommand:c \":\" - DocumentContent?:content - Nl {newpage(c[:ids],c[:classes],c[:args], c[:named_args],  content,  c[:ln])}")
-  Rules[:_UnorderedList] = rule_info("UnorderedList", "ln:ln UnorderedItem+:items {unordered_list([],[],[],[], items, ln)}")
-  Rules[:_UnorderedItem] = rule_info("UnorderedItem", "ln:ln \"*:\" - DocumentContent:content Le {ul_item([], [], [], [], content, ln)}")
-  Rules[:_OrderedList] = rule_info("OrderedList", "ln:ln OrderedItem+:items {ordered_list([],[],[], [], items, ln)}")
-  Rules[:_OrderedItem] = rule_info("OrderedItem", "ln:ln Num \":\" - DocumentContent:content Le {ol_item([], [], [], [], content, ln)}")
-  Rules[:_DefinitionList] = rule_info("DefinitionList", "ln:ln DefinitionItem+:items {definition_list([], [], [], [], items, ln)}")
-  Rules[:_DefinitionItem] = rule_info("DefinitionItem", "- ln:ln \";:\" - DocumentContentExcept(':'):term \":\" - DocumentContent:definition Le {dl_item([], [], [term], [], definition, ln)}")
-  Rules[:_LongDefinitionList] = rule_info("LongDefinitionList", "ln:ln LongDefinitionItem+:items {definition_list([], [], [], [], items, ln)}")
-  Rules[:_LongDefinitionItem] = rule_info("LongDefinitionItem", "- ln:ln \";:\" - DocumentContentExcept('{'):term \"{\" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], [], definition, ln)}")
-  Rules[:_ItemsList] = rule_info("ItemsList", "(UnorderedList | OrderedList | DefinitionList | LongDefinitionList)")
+  Rules[:_UnorderedStart] = rule_info("UnorderedStart", "/^/ - < /\\*+/ > &{ text.length == n && text.size < 5 }")
+  Rules[:_UnorderedList] = rule_info("UnorderedList", "ln:ln UnorderedItem(n)+:items {unordered_list([],[],[],{}, items, ln)}")
+  Rules[:_UnorderedItem] = rule_info("UnorderedItem", "UnorderedStart(n) ln:ln - UnorderedItemBody(n):content {ul_item([], [], [], {}, content, ln)}")
+  Rules[:_UnorderedItemBody] = rule_info("UnorderedItemBody", "(DocumentContent:content Nl - &UnorderedStart(n + 1) ln:ln UnorderedList(n + 1):sub_ul { content << sub_ul } | DocumentContent:content Le { content })")
+  Rules[:_OrderedList] = rule_info("OrderedList", "ln:ln OrderedItem+:items {ordered_list([],[],[], {}, items, ln)}")
+  Rules[:_OrderedItem] = rule_info("OrderedItem", "- ln:ln Num \".\" - DocumentContent:content Le {ol_item([], [], [], {}, content, ln)}")
+  Rules[:_DefinitionList] = rule_info("DefinitionList", "ln:ln DefinitionItem+:items {definition_list([], [], [], {}, items, ln)}")
+  Rules[:_DefinitionItem] = rule_info("DefinitionItem", "- ln:ln - \";:\" - DocumentContentExcept(':'):term \":\" - DocumentContent:definition Le {dl_item([], [], [term], {}, definition, ln)}")
+  Rules[:_LongDefinitionList] = rule_info("LongDefinitionList", "ln:ln LongDefinitionItem+:items {definition_list([], [], [], {}, items, ln)}")
+  Rules[:_LongDefinitionItem] = rule_info("LongDefinitionItem", "- ln:ln \";:\" - DocumentContentExcept('{'):term \"{\" - Nl - BlockBody:definition - BlockEnd {dl_item([], [], [term], {}, definition, ln)}")
+  Rules[:_ItemsList] = rule_info("ItemsList", "(UnorderedList(1) | OrderedList | DefinitionList | LongDefinitionList)")
   Rules[:_LineCommand] = rule_info("LineCommand", "- !CommandNameForSpecialLineCommand Command:c \":\" - DocumentContent?:content - Le EmptyLine* {block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln])}")
   Rules[:_LineBlock] = rule_info("LineBlock", "(ItemsList | LineCommand)")
   Rules[:_Block] = rule_info("Block", "(PreformattedBlock | HeadedSection | LineBlock | ExplicitBlock | ParagraphGroup):block EmptyLine* {block}")
   Rules[:_BlockDelimiter] = rule_info("BlockDelimiter", "(BlockHead | BlockEnd)")
   Rules[:_ParagraphDelimiter] = rule_info("ParagraphDelimiter", "(BlockDelimiter | PreformattedCommandHead | LineBlock | Newpage | HeadedStart)")
-  Rules[:_HStartMark] = rule_info("HStartMark", "< \"=\"+ \":\" > &{ text.length - 1 == n }")
-  Rules[:_HMarkupTerminator] = rule_info("HMarkupTerminator", "(- < \"=\"+ \":\" > &{ text.length - 1 <= n } | - Eof)")
-  Rules[:_HStart] = rule_info("HStart", "- HStartMark(n) ln:ln - DocumentContent:s Le { { level: n, heading: s, ln: ln} }")
-  Rules[:_HSection] = rule_info("HSection", "HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], content, h[:ln])}")
-  Rules[:_HeadedStart] = rule_info("HeadedStart", "(HStart(1) | HStart(2) | HStart(3) | HStart(4) | HStart(5) | HStart(6))")
-  Rules[:_HeadedSection] = rule_info("HeadedSection", "(HSection(1) | HSection(2) | HSection(3) | HSection(4) | HSection(5) | HSection(6))")
+  Rules[:_HStartMark] = rule_info("HStartMark", "- < \"\#\"+ > &{ text.length == n }")
+  Rules[:_HMarkupTerminator] = rule_info("HMarkupTerminator", "(- < \"\#\"+ > - CharString:cs Le &{ text.length <= n && !cs.strip.end_with?('{') } | - Eof)")
+  Rules[:_HStartCommand] = rule_info("HStartCommand", "- HStartMark(n) (\"(\" - Parameters:args - \")\")? (\"[\" - NamedParameters:named_args - \"]\")? { { args: args || [] , named_args: named_args || {}} }")
+  Rules[:_HStart] = rule_info("HStart", "- HStartCommand(n):hsc ln:ln - DocumentContent:s Le { hsc.merge({ level: n, heading: s, ln: ln}) }")
+  Rules[:_HSection] = rule_info("HSection", "HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}")
+  Rules[:_BlockHStart] = rule_info("BlockHStart", "- HStartCommand(n):hsc ln:ln - DocumentContentExcept('{'):s - \"{\" - Nl { hsc.merge({ level: n, heading: s, ln: ln}) }")
+  Rules[:_ExplicitHSection] = rule_info("ExplicitHSection", "BlockHStart(n):h EmptyLine* - BlockBody:content - BlockEnd {h_section(h[:level], h[:heading], h[:args], h[:named_args], content, h[:ln])}")
+  Rules[:_HeadedStart] = rule_info("HeadedStart", "(HStart(6) | HStart(5) | HStart(4) | HStart(3) | HStart(2) | HStart(1) | BlockHStart(6) | BlockHStart(5) | BlockHStart(4) | BlockHStart(3) | BlockHStart(2) | BlockHStart(1))")
+  Rules[:_HeadedSection] = rule_info("HeadedSection", "(ExplicitHSection(6) | ExplicitHSection(5) | ExplicitHSection(4) | ExplicitHSection(3) | ExplicitHSection(2) | ExplicitHSection(1) | HSection(6) | HSection(5) | HSection(4) | HSection(3) | HSection(2) | HSection(1))")
   Rules[:_FrontmatterSeparator] = rule_info("FrontmatterSeparator", "- \"---\" - Nl")
   Rules[:_Frontmatter] = rule_info("Frontmatter", "FrontmatterSeparator ln:ln (!FrontmatterSeparator CharString Nl)+:yaml FrontmatterSeparator EmptyLine* {frontmatter(yaml, ln)}")
   Rules[:_Char] = rule_info("Char", "< /[[:print:]]/ > { text }")
   Rules[:_CharString] = rule_info("CharString", "< Char* > { text }")
-  Rules[:_CharExcept] = rule_info("CharExcept", "Char:c &{ c != e }")
+  Rules[:_CharExcept] = rule_info("CharExcept", "Char:c &{ e.is_a?(Regexp) ? e !~ c : e != c }")
+  Rules[:_CharStringExcept] = rule_info("CharStringExcept", "< CharExcept(e)+ > { text }")
   Rules[:_DocumentTextExcept] = rule_info("DocumentTextExcept", "< (!Inline CharExcept(e))+ > ln:ln {text(text, ln)}")
   Rules[:_DocumentContentExcept] = rule_info("DocumentContentExcept", "(Inline | DocumentTextExcept(e))+:content { content }")
   Rules[:_DocumentText] = rule_info("DocumentText", "< (!Inline Char)+ > ln:ln {text(text, ln)}")
   Rules[:_DocumentContent] = rule_info("DocumentContent", "(Inline | DocumentText)+:content { content }")
   Rules[:_DocumentLine] = rule_info("DocumentLine", "DocumentContent:content Le { content }")
   Rules[:_Page] = rule_info("Page", "Frontmatter?:frontmatter - (!Newpage Block)*:blocks EmptyLine* {page(([frontmatter] +  blocks).select{ |x| !x.nil?}, 1)}")
-  Rules[:_Pages] = rule_info("Pages", "(Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages } | Page:page { [ page ] })")
+  Rules[:_Pages] = rule_info("Pages", "(Page:page Newpage:newpage Pages:pages { pages.unshift(page) } | Page:page { [ page ] })")
   Rules[:_root] = rule_info("root", "BOM? EmptyLine* Pages:pages EofComment? Eof {root(pages)}")
   # :startdoc:
 end