arti_mark 0.1.beta3 → 0.1.beta5

data/lib/arti_mark/html/generator.rb

@@ -1,10 +1,12 @@
 # -*- coding: utf-8 -*-
 require 'arti_mark/html/util'
-require 'arti_mark/html/result'
+require 'arti_mark/html/pages'
 require 'arti_mark/html/context'
 require 'arti_mark/html/tag_writer'
 require 'arti_mark/html/header_writer'
+require 'arti_mark/html/paragraph_writer'
 require 'arti_mark/html/writer_selector'
+require 'arti_mark/html/abstract_item_writer'
 module ArtiMark
   module Html
     class Generator
@@ -13,6 +15,7 @@ module ArtiMark
       def initialize(param = {})
         @context = Context.new(param)
         article_writer = TagWriter.create('article', self)
+        section_writer = TagWriter.create('section', self)
         link_writer = TagWriter.create('a', self, trailer: '', 
                                        item_preprocessor: proc do |item|
                                          (item[:attrs] ||= {}).merge!({:href => [ item[:args][0] ]})
@@ -20,31 +23,23 @@ module ArtiMark
                                        end)
 
         header_writer = HeaderWriter.new self
-
+        paragraph_writer = ParagraphWriter.new self
+        abstract_item_writer = AbstractItemWriter.new self
         @writers = {
-          :paragraph =>
-          TagWriter.create('p', self, chop_last_space: true,
-                           item_preprocessor: proc do |item|
-                             add_class(item, 'noindent') if item[:children][0] =~/^(「|『|（)/  # TODO: should be plaggable}
-                             item
-                           end
-                           ),
-          :paragraph_group =>
-          TagWriter.create("div", self,
-                           item_preprocessor: proc do |item|
-                             add_class item, 'pgroup'
-                             item[:no_tag] = true unless @context.enable_pgroup
-                             item
-                           end
-                           ),
-
+          :page => abstract_item_writer,
+          :headers => abstract_item_writer,
+          :paragraph => paragraph_writer,
+          :paragraph_group => paragraph_writer,
           :block =>
           WriterSelector.new(self,
                              {
                                'd' => TagWriter.create('div', self),
                                'art' => article_writer,
                                'arti' => article_writer,
-                               'article' => article_writer
+                               'article' => article_writer,
+                               'sec' => section_writer,
+                               'sect' => section_writer,
+                               'section' => section_writer,
                              }),
           :line_command =>
           WriterSelector.new(self,
@@ -69,21 +64,6 @@ module ArtiMark
                                                   :done
                                                 end
                                                 ),
-                               'newpage' =>
-                               TagWriter.create('div', self,
-                                                item_preprocessor: proc do |item|
-                                                  item[:no_tag] = true
-                                                  item
-                                                end,
-                                                write_body_preprocessor: proc do |item|
-                                                  title = nil
-                                                  if item[:args].size > 0 && item[:args][0].size > 0
-                                                    title = escape_html item[:args].first
-                                                  end
-                                                  @context.start_html(title)
-                                                  :done
-                                                end
-                                                ),
 
                                }),
           :inline =>
@@ -128,10 +108,47 @@ module ArtiMark
                              output "<dd>"; write_array item[:args][1]; output "</dd>"
                              :done
                            end),
+          :newpage =>
+          TagWriter.create('div', self,
+                           item_preprocessor: proc do |item|
+                             item[:no_tag] = true
+                             item
+                           end,
+                           write_body_preprocessor: proc do |item|
+                             title = nil
+                             if item[:args].size > 0 && item[:args][0].size > 0
+                               title = escape_html item[:args].first
+                             end
+                             @context.title = title unless title.nil?
+                             @context.end_html
+                             :done
+                           end
+                           ),
+          #headed-section
+          :h_section =>
+          TagWriter.create('section', self, write_body_preprocessor: proc do |item|
+                             output "<h#{item[:level]}>#{item[:heading].strip}</h#{item[:level]}>\n"
+                             :continue
+                           end),
           # headers
           :stylesheets => header_writer,
           :title => header_writer,
           :lang => header_writer,
+          :paragraph_style => header_writer,
+          # pre-formatted
+          :preformatted =>
+          TagWriter.create('pre', self,write_body_preprocessor: proc do |item|
+                             output "<code>" if item[:name] == 'precode'
+                             output item[:children].join "\n"
+                             output "</code>" if item[:name] == 'precode'
+                             :done
+                           end),
+          #break
+          :br =>
+            TagWriter.create('br', self, item_preprocessor: proc do |item|
+                               item[:no_body] = true
+                               item
+                             end),
           }
       end
 

data/lib/arti_mark/html/header_writer.rb

@@ -21,6 +21,9 @@ module ArtiMark
           end,
           :lang => proc do |item|
             @context.lang = escape_html item[:lang].strip
+          end,
+          :paragraph_style => proc do |item|
+            @context.paragraph_style = item[:paragraph_style].strip
           end
         }
       end

data/lib/arti_mark/html/pages.rb

@@ -0,0 +1,56 @@
+require 'securerandom'
+module ArtiMark
+  module Html
+    class Context
+      class Pages
+        attr_reader :created_files
+        def initialize(filename_base = nil, sequence_format='%05d')
+          @filename_base = filename_base || "noramark_#{SecureRandom.uuid}"
+          @sequence_format = sequence_format || '%05d'
+          @result = []
+        end
+
+        def last
+          @result.last[:content]
+        end
+
+        def size
+          @result.size
+        end
+        
+        def <<(page)
+          seq = @result.size + 1
+          @result << { content: page, filename: "#{@filename_base}_#{@sequence_format%(seq)}.xhtml" }
+        end
+
+        def [](num)
+          page = @result[num]
+          page.nil? ? nil : page[:content]
+        end
+
+        def pages
+          @result
+        end
+
+        def write_as_files(directory: nil)
+          dir = directory || Dir.pwd
+          Dir.chdir(dir) do
+            @result.each do
+              |page|
+              File.open(page[:filename], 'w+') do
+                |file|
+                file << page[:content]
+              end
+            end
+          end
+        end 
+        def write_as_single_file(filename)
+          File.open(filename, 'w+') {
+            |file|
+            file << @result[0][:content]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/arti_mark/html/paragraph_writer.rb

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+module ArtiMark
+  module Html
+    class ParagraphWriter
+      def initialize(generator)
+        @generator = generator
+        @context = generator.context
+        @writer_set = { use_paragraph_group: {
+          :paragraph =>
+          TagWriter.create('p', @generator, chop_last_space: true,
+                           item_preprocessor: proc do |item|
+                             add_class(item, 'noindent') if item[:children][0] =~/^(「|『|（)/  # TODO: should be plaggable}
+                             item
+                           end
+                           ),
+          :paragraph_group =>
+          TagWriter.create("div", @generator,
+                           item_preprocessor: proc do |item|
+                             add_class item, 'pgroup'
+                             item[:no_tag] = true unless @context.enable_pgroup
+                             item
+                           end
+                           )
+          },
+          default: {
+          :paragraph => 
+          TagWriter.create(nil, @generator, chop_last_space: true,
+                           item_preprocessor: proc do |item|
+                             item[:no_tag] = true
+                             item
+                           end),
+          :paragraph_group =>
+          TagWriter.create("p", @generator,
+                           item_preprocessor: proc do |item|
+                             item[:children] = item[:children].inject([]) do |memo, item|
+                               memo << { :type => :br, :args => [] } if !memo.last.nil? && memo.last[:type] == :paragraph && item[:type] == :paragraph
+                               memo << item
+                             end
+                             item
+                           end
+                           )
+          }
+        }
+      end
+      def write(item)
+        writer_set = @writer_set[@context.paragraph_style]
+        writer_set = @writer_set['default'] if writer_set.nil?
+        writer_set[item[:type]].write(item)
+      end
+    end
+  end
+end

data/lib/arti_mark/parser.kpeg

@@ -38,6 +38,12 @@ blockend = lh - '}' - le empty_line*
 blockbody = (!blockend block)+:body { body } 
 explicit_block = < blockhead:head - blockbody:body - blockend > { create_item(:block, head, body, raw: text) }
 
+# preformatted block
+preformatted_command = command:command &{ ['pre', 'precode'].include? command[:name] }
+preformatted_command_head = lh - preformatted_command:command - '<<' &/[\w0-9]/ { command }
+preformat_end(start) = lh word:delimiter &{ delimiter == start }
+preformatted_block = < lh - preformatted_command_head:command !nl word:delimiter nl (!preformat_end(delimiter) (lh charstring nl))+:content preformat_end(delimiter) > { create_item(:preformatted, command, content, raw: text) }
+
 # inline command
 inline = img_inline | common_inline
 common_inline = < '[' command:c '{' documentcontent_except('}'):content '}' ']' > { create_item(:inline, c, content, raw: text) }
@@ -45,10 +51,17 @@ img_command = command:c &{ c[:name] == 'img' && c[:args].size == 2}
 img_inline = < '[' img_command:c  ']' > { create_item(:inline, c, nil, raw: text) } 
 
 # special line commands
+commandname_for_special_line_command = newpage_command | explicit_paragraph_command
+
+# newpage
+newpage_command = command:command &{ command[:name] == 'newpage' }
+newpage = < lh - newpage_command:c ':' documentcontent?:content - nl > { create_item(:newpage, c, content, raw:text) }
+
 # explicit paragraph
 explicit_paragraph_command = command:c &{ c[:name] == 'p' }
 explicit_paragraph = < lh - explicit_paragraph_command:c ':' documentcontent?:content le empty_line*> { create_item(:paragraph, c, content, raw:text) }
 
+
 # unordered list
 unordered_list = < unordered_item+:items > { create_item(:ul, nil, items, raw: text) }
 unordered_item = < lh '*:' documentcontent:content le > { create_item(:li, nil, content, raw: text) }
@@ -65,20 +78,30 @@ items_list = unordered_list | ordered_list | definition_list
 
 
 # generic line command
-line_command = < lh - !explicit_paragraph_command command:c ':' documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }
+line_command = < lh - !commandname_for_special_line_command command:c ':' documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }
 
 # blocks
-line_block = items_list | line_command 
-block = (line_block  | explicit_block | paragraph_group):block empty_line* {block}
+line_block =  items_list | line_command 
+block = (preformatted_block | headed_section | line_block  | explicit_block | paragraph_group ):block empty_line* {block}
 block_delimiter = blockhead | blockend 
-paragraph_delimiter = block_delimiter | line_block 
+paragraph_delimiter = block_delimiter | preformatted_command_head | line_block | newpage | headed_start
 
+# markdown-style headings
+h_start_mark(n) = < '='+ ':' > &{ text.length - 1 == n }
+h_markup_terminator(n) = lh - < '='+ ':' > &{ text.length - 1 <= n }
+
+h_start(n) = lh - h_start_mark(n) charstring:s le { { level: n, heading: s } }
+h_section(n) = < h_start(n):h (!h_markup_terminator(n) !eof block)+:content > { create_item(:h_section, h, content, raw: text) }
+
+headed_start = h_start(1) | h_start(2) | h_start(3) | h_start(4) | h_start(5) | h_start(6)
+headed_section = h_section(1) | h_section(2)| h_section(3)| h_section(4)| h_section(5) | h_section(6)
 
 #header
 stylesheets = < lh - 'stylesheets:' !le charstring:s nl  > { create_item(:stylesheets, {:stylesheets => s.split(',').map(&:strip)}, nil, raw:text) }
 title = < lh - 'title:' !le charstring:t nl  > { create_item(:title, {:title => t }, nil, raw:text) }
 lang = < lh - 'lang:' !le charstring:l nl  > { create_item(:lang, {:lang => l }, nil, raw:text) }
-header = (stylesheets | title | lang) empty_line*
+paragraph_style = < lh - 'paragraph-style:' !le charstring:l nl  > { create_item(:paragraph_style, {:paragraph_style => l }, nil, raw:text) }
+header = (stylesheets | title | lang | paragraph_style ) empty_line*
 
 # texts
 char = < /[[:print:]]/ > { text }
@@ -89,7 +112,12 @@ documentcontent_except(e) = (inline | !inline char_except(e))+:content ~parse_te
 documentcontent = (inline | !inline char)+:content  ~parse_text(content)
 documentline = lh documentcontent:content le { content }
 
+#page
+headers = header*:headers { create_item(:headers, nil, headers) }
+page = headers:headers - (!newpage block)*:blocks { create_item(:page, nil, [headers] + blocks.select{ |x| !x.nil?}) }
+newpaged_page = newpage:newpage page:page { page[:children] = page[:children].unshift newpage; page }
 #root
-root = header*:headers - block*:blocks - eof_comment? eof { headers.concat blocks.select{ |x| !x.nil?} }
+root = page:page newpaged_page*:pages - eof_comment? eof { [ page ] + pages }
+
 
 

data/lib/arti_mark/parser.kpeg.rb

@@ -1082,6 +1082,253 @@ class ArtiMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
+  # preformatted_command = command:command &{ ['pre', 'precode'].include? command[:name] }
+  def _preformatted_command
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_command)
+      command = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = begin;  ['pre', 'precode'].include? command[:name] ; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_preformatted_command unless _tmp
+    return _tmp
+  end
+
+  # preformatted_command_head = lh - preformatted_command:command - "<<" &/[\w0-9]/ { command }
+  def _preformatted_command_head
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_lh)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_preformatted_command)
+      command = @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
+      _save1 = self.pos
+      _tmp = scan(/\A(?-mix:[\w0-9])/)
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  command ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_preformatted_command_head unless _tmp
+    return _tmp
+  end
+
+  # preformat_end = lh word:delimiter &{ delimiter == start }
+  def _preformat_end(start)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_lh)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_word)
+      delimiter = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save1 = self.pos
+      _tmp = begin;  delimiter == start ; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_preformat_end unless _tmp
+    return _tmp
+  end
+
+  # preformatted_block = < lh - preformatted_command_head:command !nl word:delimiter nl (!preformat_end(delimiter) lh charstring nl)+:content preformat_end(delimiter) > { create_item(:preformatted, command, content, raw: text) }
+  def _preformatted_block
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_lh)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_preformatted_command_head)
+        command = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save2 = self.pos
+        _tmp = apply(:_nl)
+        _tmp = _tmp ? nil : true
+        self.pos = _save2
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_word)
+        delimiter = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_nl)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save3 = self.pos
+        _ary = []
+
+        _save4 = self.pos
+        while true # sequence
+          _save5 = self.pos
+          _tmp = apply_with_args(:_preformat_end, delimiter)
+          _tmp = _tmp ? nil : true
+          self.pos = _save5
+          unless _tmp
+            self.pos = _save4
+            break
+          end
+          _tmp = apply(:_lh)
+          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
+
+        if _tmp
+          _ary << @result
+          while true
+
+            _save6 = self.pos
+            while true # sequence
+              _save7 = self.pos
+              _tmp = apply_with_args(:_preformat_end, delimiter)
+              _tmp = _tmp ? nil : true
+              self.pos = _save7
+              unless _tmp
+                self.pos = _save6
+                break
+              end
+              _tmp = apply(:_lh)
+              unless _tmp
+                self.pos = _save6
+                break
+              end
+              _tmp = apply(:_charstring)
+              unless _tmp
+                self.pos = _save6
+                break
+              end
+              _tmp = apply(:_nl)
+              unless _tmp
+                self.pos = _save6
+              end
+              break
+            end # end sequence
+
+            _ary << @result if _tmp
+            break unless _tmp
+          end
+          _tmp = true
+          @result = _ary
+        else
+          self.pos = _save3
+        end
+        content = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply_with_args(:_preformat_end, delimiter)
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  create_item(:preformatted, command, content, raw: text) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_preformatted_block unless _tmp
+    return _tmp
+  end
+
   # inline = (img_inline | common_inline)
   def _inline
 
@@ -1232,19 +1479,37 @@ class ArtiMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # explicit_paragraph_command = command:c &{ c[:name] == 'p' }
-  def _explicit_paragraph_command
+  # commandname_for_special_line_command = (newpage_command | explicit_paragraph_command)
+  def _commandname_for_special_line_command
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_newpage_command)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_explicit_paragraph_command)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_commandname_for_special_line_command unless _tmp
+    return _tmp
+  end
+
+  # newpage_command = command:command &{ command[:name] == 'newpage' }
+  def _newpage_command
 
     _save = self.pos
     while true # sequence
       _tmp = apply(:_command)
-      c = @result
+      command = @result
       unless _tmp
         self.pos = _save
         break
       end
       _save1 = self.pos
-      _tmp = begin;  c[:name] == 'p' ; end
+      _tmp = begin;  command[:name] == 'newpage' ; end
       self.pos = _save1
       unless _tmp
         self.pos = _save
@@ -1252,12 +1517,12 @@ class ArtiMark::Parser < KPeg::CompiledParser
       break
     end # end sequence
 
-    set_failed_rule :_explicit_paragraph_command unless _tmp
+    set_failed_rule :_newpage_command unless _tmp
     return _tmp
   end
 
-  # explicit_paragraph = < lh - explicit_paragraph_command:c ":" documentcontent?:content le empty_line* > { create_item(:paragraph, c, content, raw:text) }
-  def _explicit_paragraph
+  # newpage = < lh - newpage_command:c ":" documentcontent?:content - nl > { create_item(:newpage, c, content, raw:text) }
+  def _newpage
 
     _save = self.pos
     while true # sequence
@@ -1275,7 +1540,7 @@ class ArtiMark::Parser < KPeg::CompiledParser
           self.pos = _save1
           break
         end
-        _tmp = apply(:_explicit_paragraph_command)
+        _tmp = apply(:_newpage_command)
         c = @result
         unless _tmp
           self.pos = _save1
@@ -1298,16 +1563,12 @@ class ArtiMark::Parser < KPeg::CompiledParser
           self.pos = _save1
           break
         end
-        _tmp = apply(:_le)
+        _tmp = apply(:__hyphen_)
         unless _tmp
           self.pos = _save1
           break
         end
-        while true
-          _tmp = apply(:_empty_line)
-          break unless _tmp
-        end
-        _tmp = true
+        _tmp = apply(:_nl)
         unless _tmp
           self.pos = _save1
         end
@@ -1321,7 +1582,7 @@ class ArtiMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin;  create_item(:paragraph, c, content, raw:text) ; end
+      @result = begin;  create_item(:newpage, c, content, raw:text) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -1329,20 +1590,121 @@ class ArtiMark::Parser < KPeg::CompiledParser
       break
     end # end sequence
 
-    set_failed_rule :_explicit_paragraph unless _tmp
+    set_failed_rule :_newpage unless _tmp
     return _tmp
   end
 
-  # unordered_list = < unordered_item+:items > { create_item(:ul, nil, items, raw: text) }
-  def _unordered_list
+  # explicit_paragraph_command = command:c &{ c[:name] == 'p' }
+  def _explicit_paragraph_command
 
     _save = self.pos
     while true # sequence
-      _text_start = self.pos
+      _tmp = apply(:_command)
+      c = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _save1 = self.pos
-      _ary = []
-      _tmp = apply(:_unordered_item)
-      if _tmp
+      _tmp = begin;  c[:name] == 'p' ; end
+      self.pos = _save1
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_explicit_paragraph_command unless _tmp
+    return _tmp
+  end
+
+  # explicit_paragraph = < lh - explicit_paragraph_command:c ":" documentcontent?:content le empty_line* > { create_item(:paragraph, c, content, raw:text) }
+  def _explicit_paragraph
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_lh)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_explicit_paragraph_command)
+        c = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = match_string(":")
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save2 = self.pos
+        _tmp = apply(:_documentcontent)
+        @result = nil unless _tmp
+        unless _tmp
+          _tmp = true
+          self.pos = _save2
+        end
+        content = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_le)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        while true
+          _tmp = apply(:_empty_line)
+          break unless _tmp
+        end
+        _tmp = true
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  create_item(:paragraph, c, content, raw:text) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_explicit_paragraph unless _tmp
+    return _tmp
+  end
+
+  # unordered_list = < unordered_item+:items > { create_item(:ul, nil, items, raw: text) }
+  def _unordered_list
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+      _save1 = self.pos
+      _ary = []
+      _tmp = apply(:_unordered_item)
+      if _tmp
         _ary << @result
         while true
           _tmp = apply(:_unordered_item)
@@ -1656,7 +2018,7 @@ class ArtiMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # line_command = < lh - !explicit_paragraph_command command:c ":" documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }
+  # line_command = < lh - !commandname_for_special_line_command command:c ":" documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }
   def _line_command
 
     _save = self.pos
@@ -1676,7 +2038,7 @@ class ArtiMark::Parser < KPeg::CompiledParser
           break
         end
         _save2 = self.pos
-        _tmp = apply(:_explicit_paragraph_command)
+        _tmp = apply(:_commandname_for_special_line_command)
         _tmp = _tmp ? nil : true
         self.pos = _save2
         unless _tmp
@@ -1699,28 +2061,404 @@ class ArtiMark::Parser < KPeg::CompiledParser
         @result = nil unless _tmp
         unless _tmp
           _tmp = true
-          self.pos = _save3
+          self.pos = _save3
+        end
+        content = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_le)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        while true
+          _tmp = apply(:_empty_line)
+          break unless _tmp
+        end
+        _tmp = true
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  create_item(:line_command, c, content, raw: text) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_line_command unless _tmp
+    return _tmp
+  end
+
+  # line_block = (items_list | line_command)
+  def _line_block
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_items_list)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_line_command)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_line_block unless _tmp
+    return _tmp
+  end
+
+  # block = (preformatted_block | headed_section | line_block | explicit_block | paragraph_group):block empty_line* {block}
+  def _block
+
+    _save = self.pos
+    while true # sequence
+
+      _save1 = self.pos
+      while true # choice
+        _tmp = apply(:_preformatted_block)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_headed_section)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_line_block)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_explicit_block)
+        break if _tmp
+        self.pos = _save1
+        _tmp = apply(:_paragraph_group)
+        break if _tmp
+        self.pos = _save1
+        break
+      end # end choice
+
+      block = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      while true
+        _tmp = apply(:_empty_line)
+        break unless _tmp
+      end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; block; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_block unless _tmp
+    return _tmp
+  end
+
+  # block_delimiter = (blockhead | blockend)
+  def _block_delimiter
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_blockhead)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_blockend)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_block_delimiter unless _tmp
+    return _tmp
+  end
+
+  # paragraph_delimiter = (block_delimiter | preformatted_command_head | line_block | newpage | headed_start)
+  def _paragraph_delimiter
+
+    _save = self.pos
+    while true # choice
+      _tmp = apply(:_block_delimiter)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_preformatted_command_head)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_line_block)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_newpage)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_headed_start)
+      break if _tmp
+      self.pos = _save
+      break
+    end # end choice
+
+    set_failed_rule :_paragraph_delimiter unless _tmp
+    return _tmp
+  end
+
+  # h_start_mark = < "="+ ":" > &{ text.length - 1 == n }
+  def _h_start_mark(n)
+
+    _save = self.pos
+    while true # sequence
+      _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
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save3 = self.pos
+      _tmp = begin;  text.length - 1 == n ; end
+      self.pos = _save3
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_h_start_mark unless _tmp
+    return _tmp
+  end
+
+  # h_markup_terminator = lh - < "="+ ":" > &{ text.length - 1 <= n }
+  def _h_markup_terminator(n)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_lh)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _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
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _save3 = self.pos
+      _tmp = begin;  text.length - 1 <= n ; end
+      self.pos = _save3
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_h_markup_terminator unless _tmp
+    return _tmp
+  end
+
+  # h_start = lh - h_start_mark(n) charstring:s le { { level: n, heading: s } }
+  def _h_start(n)
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_lh)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:__hyphen_)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply_with_args(:_h_start_mark, n)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_charstring)
+      s = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_le)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  { level: n, heading: s } ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_h_start unless _tmp
+    return _tmp
+  end
+
+  # h_section = < h_start(n):h (!h_markup_terminator(n) !eof block)+:content > { create_item(:h_section, h, content, raw: text) }
+  def _h_section(n)
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply_with_args(:_h_start, n)
+        h = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save2 = self.pos
+        _ary = []
+
+        _save3 = self.pos
+        while true # sequence
+          _save4 = self.pos
+          _tmp = apply_with_args(:_h_markup_terminator, n)
+          _tmp = _tmp ? nil : true
+          self.pos = _save4
+          unless _tmp
+            self.pos = _save3
+            break
+          end
+          _save5 = self.pos
+          _tmp = apply(:_eof)
+          _tmp = _tmp ? nil : true
+          self.pos = _save5
+          unless _tmp
+            self.pos = _save3
+            break
+          end
+          _tmp = apply(:_block)
+          unless _tmp
+            self.pos = _save3
+          end
+          break
+        end # end sequence
+
+        if _tmp
+          _ary << @result
+          while true
+
+            _save6 = self.pos
+            while true # sequence
+              _save7 = self.pos
+              _tmp = apply_with_args(:_h_markup_terminator, n)
+              _tmp = _tmp ? nil : true
+              self.pos = _save7
+              unless _tmp
+                self.pos = _save6
+                break
+              end
+              _save8 = self.pos
+              _tmp = apply(:_eof)
+              _tmp = _tmp ? nil : true
+              self.pos = _save8
+              unless _tmp
+                self.pos = _save6
+                break
+              end
+              _tmp = apply(:_block)
+              unless _tmp
+                self.pos = _save6
+              end
+              break
+            end # end sequence
+
+            _ary << @result if _tmp
+            break unless _tmp
+          end
+          _tmp = true
+          @result = _ary
+        else
+          self.pos = _save2
         end
         content = @result
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = apply(:__hyphen_)
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        _tmp = apply(:_le)
-        unless _tmp
-          self.pos = _save1
-          break
-        end
-        while true
-          _tmp = apply(:_empty_line)
-          break unless _tmp
-        end
-        _tmp = true
         unless _tmp
           self.pos = _save1
         end
@@ -1734,7 +2472,7 @@ class ArtiMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin;  create_item(:line_command, c, content, raw: text) ; end
+      @result = begin;  create_item(:h_section, h, content, raw: text) ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -1742,107 +2480,67 @@ class ArtiMark::Parser < KPeg::CompiledParser
       break
     end # end sequence
 
-    set_failed_rule :_line_command unless _tmp
+    set_failed_rule :_h_section unless _tmp
     return _tmp
   end
 
-  # line_block = (items_list | line_command)
-  def _line_block
+  # headed_start = (h_start(1) | h_start(2) | h_start(3) | h_start(4) | h_start(5) | h_start(6))
+  def _headed_start
 
     _save = self.pos
     while true # choice
-      _tmp = apply(:_items_list)
+      _tmp = apply_with_args(:_h_start, 1)
       break if _tmp
       self.pos = _save
-      _tmp = apply(:_line_command)
+      _tmp = apply_with_args(:_h_start, 2)
       break if _tmp
       self.pos = _save
-      break
-    end # end choice
-
-    set_failed_rule :_line_block unless _tmp
-    return _tmp
-  end
-
-  # block = (line_block | explicit_block | paragraph_group):block empty_line* {block}
-  def _block
-
-    _save = self.pos
-    while true # sequence
-
-      _save1 = self.pos
-      while true # choice
-        _tmp = apply(:_line_block)
-        break if _tmp
-        self.pos = _save1
-        _tmp = apply(:_explicit_block)
-        break if _tmp
-        self.pos = _save1
-        _tmp = apply(:_paragraph_group)
-        break if _tmp
-        self.pos = _save1
-        break
-      end # end choice
-
-      block = @result
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      while true
-        _tmp = apply(:_empty_line)
-        break unless _tmp
-      end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-        break
-      end
-      @result = begin; block; end
-      _tmp = true
-      unless _tmp
-        self.pos = _save
-      end
-      break
-    end # end sequence
-
-    set_failed_rule :_block unless _tmp
-    return _tmp
-  end
-
-  # block_delimiter = (blockhead | blockend)
-  def _block_delimiter
-
-    _save = self.pos
-    while true # choice
-      _tmp = apply(:_blockhead)
+      _tmp = apply_with_args(:_h_start, 3)
       break if _tmp
       self.pos = _save
-      _tmp = apply(:_blockend)
+      _tmp = apply_with_args(:_h_start, 4)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_h_start, 5)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_h_start, 6)
       break if _tmp
       self.pos = _save
       break
     end # end choice
 
-    set_failed_rule :_block_delimiter unless _tmp
+    set_failed_rule :_headed_start unless _tmp
     return _tmp
   end
 
-  # paragraph_delimiter = (block_delimiter | line_block)
-  def _paragraph_delimiter
+  # headed_section = (h_section(1) | h_section(2) | h_section(3) | h_section(4) | h_section(5) | h_section(6))
+  def _headed_section
 
     _save = self.pos
     while true # choice
-      _tmp = apply(:_block_delimiter)
+      _tmp = apply_with_args(:_h_section, 1)
       break if _tmp
       self.pos = _save
-      _tmp = apply(:_line_block)
+      _tmp = apply_with_args(:_h_section, 2)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_h_section, 3)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_h_section, 4)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_h_section, 5)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply_with_args(:_h_section, 6)
       break if _tmp
       self.pos = _save
       break
     end # end choice
 
-    set_failed_rule :_paragraph_delimiter unless _tmp
+    set_failed_rule :_headed_section unless _tmp
     return _tmp
   end
 
@@ -2038,7 +2736,71 @@ class ArtiMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # header = (stylesheets | title | lang) empty_line*
+  # paragraph_style = < lh - "paragraph-style:" !le charstring:l nl > { create_item(:paragraph_style, {:paragraph_style => l }, nil, raw:text) }
+  def _paragraph_style
+
+    _save = self.pos
+    while true # sequence
+      _text_start = self.pos
+
+      _save1 = self.pos
+      while true # sequence
+        _tmp = apply(:_lh)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:__hyphen_)
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = match_string("paragraph-style:")
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _save2 = self.pos
+        _tmp = apply(:_le)
+        _tmp = _tmp ? nil : true
+        self.pos = _save2
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_charstring)
+        l = @result
+        unless _tmp
+          self.pos = _save1
+          break
+        end
+        _tmp = apply(:_nl)
+        unless _tmp
+          self.pos = _save1
+        end
+        break
+      end # end sequence
+
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  create_item(:paragraph_style, {:paragraph_style => l }, nil, raw:text) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_paragraph_style unless _tmp
+    return _tmp
+  end
+
+  # header = (stylesheets | title | lang | paragraph_style) empty_line*
   def _header
 
     _save = self.pos
@@ -2055,6 +2817,9 @@ class ArtiMark::Parser < KPeg::CompiledParser
         _tmp = apply(:_lang)
         break if _tmp
         self.pos = _save1
+        _tmp = apply(:_paragraph_style)
+        break if _tmp
+        self.pos = _save1
         break
       end # end choice
 
@@ -2406,8 +3171,8 @@ class ArtiMark::Parser < KPeg::CompiledParser
     return _tmp
   end
 
-  # root = header*:headers - block*:blocks - eof_comment? eof { headers.concat blocks.select{ |x| !x.nil?} }
-  def _root
+  # headers = header*:headers { create_item(:headers, nil, headers) }
+  def _headers
 
     _save = self.pos
     while true # sequence
@@ -2424,6 +3189,29 @@ class ArtiMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
+      @result = begin;  create_item(:headers, nil, headers) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_headers unless _tmp
+    return _tmp
+  end
+
+  # page = headers:headers - (!newpage block)*:blocks { create_item(:page, nil, [headers] + blocks.select{ |x| !x.nil?}) }
+  def _page
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_headers)
+      headers = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _tmp = apply(:__hyphen_)
       unless _tmp
         self.pos = _save
@@ -2431,7 +3219,24 @@ class ArtiMark::Parser < KPeg::CompiledParser
       end
       _ary = []
       while true
-        _tmp = apply(:_block)
+
+        _save2 = self.pos
+        while true # sequence
+          _save3 = self.pos
+          _tmp = apply(:_newpage)
+          _tmp = _tmp ? nil : true
+          self.pos = _save3
+          unless _tmp
+            self.pos = _save2
+            break
+          end
+          _tmp = apply(:_block)
+          unless _tmp
+            self.pos = _save2
+          end
+          break
+        end # end sequence
+
         _ary << @result if _tmp
         break unless _tmp
       end
@@ -2442,16 +3247,81 @@ class ArtiMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
+      @result = begin;  create_item(:page, nil, [headers] + blocks.select{ |x| !x.nil?}) ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_page unless _tmp
+    return _tmp
+  end
+
+  # newpaged_page = newpage:newpage page:page { page[:children] = page[:children].unshift newpage; page }
+  def _newpaged_page
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_newpage)
+      newpage = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_page)
+      page = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin;  page[:children] = page[:children].unshift newpage; page ; end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_newpaged_page unless _tmp
+    return _tmp
+  end
+
+  # root = page:page newpaged_page*:pages - eof_comment? eof { [ page ] + pages }
+  def _root
+
+    _save = self.pos
+    while true # sequence
+      _tmp = apply(:_page)
+      page = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _ary = []
+      while true
+        _tmp = apply(:_newpaged_page)
+        _ary << @result if _tmp
+        break unless _tmp
+      end
+      _tmp = true
+      @result = _ary
+      pages = @result
+      unless _tmp
+        self.pos = _save
+        break
+      end
       _tmp = apply(:__hyphen_)
       unless _tmp
         self.pos = _save
         break
       end
-      _save3 = self.pos
+      _save2 = self.pos
       _tmp = apply(:_eof_comment)
       unless _tmp
         _tmp = true
-        self.pos = _save3
+        self.pos = _save2
       end
       unless _tmp
         self.pos = _save
@@ -2462,7 +3332,7 @@ class ArtiMark::Parser < KPeg::CompiledParser
         self.pos = _save
         break
       end
-      @result = begin;  headers.concat blocks.select{ |x| !x.nil?} ; end
+      @result = begin;  [ page ] + pages ; end
       _tmp = true
       unless _tmp
         self.pos = _save
@@ -2501,10 +3371,17 @@ class ArtiMark::Parser < KPeg::CompiledParser
   Rules[:_blockend] = rule_info("blockend", "lh - \"}\" - le empty_line*")
   Rules[:_blockbody] = rule_info("blockbody", "(!blockend block)+:body { body }")
   Rules[:_explicit_block] = rule_info("explicit_block", "< blockhead:head - blockbody:body - blockend > { create_item(:block, head, body, raw: text) }")
+  Rules[:_preformatted_command] = rule_info("preformatted_command", "command:command &{ ['pre', 'precode'].include? command[:name] }")
+  Rules[:_preformatted_command_head] = rule_info("preformatted_command_head", "lh - preformatted_command:command - \"<<\" &/[\\w0-9]/ { command }")
+  Rules[:_preformat_end] = rule_info("preformat_end", "lh word:delimiter &{ delimiter == start }")
+  Rules[:_preformatted_block] = rule_info("preformatted_block", "< lh - preformatted_command_head:command !nl word:delimiter nl (!preformat_end(delimiter) lh charstring nl)+:content preformat_end(delimiter) > { create_item(:preformatted, command, content, raw: text) }")
   Rules[:_inline] = rule_info("inline", "(img_inline | common_inline)")
   Rules[:_common_inline] = rule_info("common_inline", "< \"[\" command:c \"{\" documentcontent_except('}'):content \"}\" \"]\" > { create_item(:inline, c, content, raw: text) }")
   Rules[:_img_command] = rule_info("img_command", "command:c &{ c[:name] == 'img' && c[:args].size == 2}")
   Rules[:_img_inline] = rule_info("img_inline", "< \"[\" img_command:c \"]\" > { create_item(:inline, c, nil, raw: text) }")
+  Rules[:_commandname_for_special_line_command] = rule_info("commandname_for_special_line_command", "(newpage_command | explicit_paragraph_command)")
+  Rules[:_newpage_command] = rule_info("newpage_command", "command:command &{ command[:name] == 'newpage' }")
+  Rules[:_newpage] = rule_info("newpage", "< lh - newpage_command:c \":\" documentcontent?:content - nl > { create_item(:newpage, c, content, raw:text) }")
   Rules[:_explicit_paragraph_command] = rule_info("explicit_paragraph_command", "command:c &{ c[:name] == 'p' }")
   Rules[:_explicit_paragraph] = rule_info("explicit_paragraph", "< lh - explicit_paragraph_command:c \":\" documentcontent?:content le empty_line* > { create_item(:paragraph, c, content, raw:text) }")
   Rules[:_unordered_list] = rule_info("unordered_list", "< unordered_item+:items > { create_item(:ul, nil, items, raw: text) }")
@@ -2514,15 +3391,22 @@ class ArtiMark::Parser < KPeg::CompiledParser
   Rules[:_definition_list] = rule_info("definition_list", "< definition_item+:items > { create_item(:dl, nil, items, raw: text) }")
   Rules[:_definition_item] = rule_info("definition_item", "< lh \";:\" - documentcontent_except(':'):term \":\" - documentcontent:definition le > { create_item(:dtdd, {:args => [term, definition]}, nil, raw: text) }")
   Rules[:_items_list] = rule_info("items_list", "(unordered_list | ordered_list | definition_list)")
-  Rules[:_line_command] = rule_info("line_command", "< lh - !explicit_paragraph_command command:c \":\" documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }")
+  Rules[:_line_command] = rule_info("line_command", "< lh - !commandname_for_special_line_command command:c \":\" documentcontent?:content - le empty_line* > { create_item(:line_command, c, content, raw: text) }")
   Rules[:_line_block] = rule_info("line_block", "(items_list | line_command)")
-  Rules[:_block] = rule_info("block", "(line_block | explicit_block | paragraph_group):block empty_line* {block}")
+  Rules[:_block] = rule_info("block", "(preformatted_block | headed_section | line_block | explicit_block | paragraph_group):block empty_line* {block}")
   Rules[:_block_delimiter] = rule_info("block_delimiter", "(blockhead | blockend)")
-  Rules[:_paragraph_delimiter] = rule_info("paragraph_delimiter", "(block_delimiter | line_block)")
+  Rules[:_paragraph_delimiter] = rule_info("paragraph_delimiter", "(block_delimiter | preformatted_command_head | line_block | newpage | headed_start)")
+  Rules[:_h_start_mark] = rule_info("h_start_mark", "< \"=\"+ \":\" > &{ text.length - 1 == n }")
+  Rules[:_h_markup_terminator] = rule_info("h_markup_terminator", "lh - < \"=\"+ \":\" > &{ text.length - 1 <= n }")
+  Rules[:_h_start] = rule_info("h_start", "lh - h_start_mark(n) charstring:s le { { level: n, heading: s } }")
+  Rules[:_h_section] = rule_info("h_section", "< h_start(n):h (!h_markup_terminator(n) !eof block)+:content > { create_item(:h_section, h, content, raw: text) }")
+  Rules[:_headed_start] = rule_info("headed_start", "(h_start(1) | h_start(2) | h_start(3) | h_start(4) | h_start(5) | h_start(6))")
+  Rules[:_headed_section] = rule_info("headed_section", "(h_section(1) | h_section(2) | h_section(3) | h_section(4) | h_section(5) | h_section(6))")
   Rules[:_stylesheets] = rule_info("stylesheets", "< lh - \"stylesheets:\" !le charstring:s nl > { create_item(:stylesheets, {:stylesheets => s.split(',').map(&:strip)}, nil, raw:text) }")
   Rules[:_title] = rule_info("title", "< lh - \"title:\" !le charstring:t nl > { create_item(:title, {:title => t }, nil, raw:text) }")
   Rules[:_lang] = rule_info("lang", "< lh - \"lang:\" !le charstring:l nl > { create_item(:lang, {:lang => l }, nil, raw:text) }")
-  Rules[:_header] = rule_info("header", "(stylesheets | title | lang) empty_line*")
+  Rules[:_paragraph_style] = rule_info("paragraph_style", "< lh - \"paragraph-style:\" !le charstring:l nl > { create_item(:paragraph_style, {:paragraph_style => l }, nil, raw:text) }")
+  Rules[:_header] = rule_info("header", "(stylesheets | title | lang | paragraph_style) empty_line*")
   Rules[:_char] = rule_info("char", "< /[[:print:]]/ > { text }")
   Rules[:_charstring] = rule_info("charstring", "< char* > { text }")
   Rules[:_char_except] = rule_info("char_except", "char:c &{ c != e }")
@@ -2530,6 +3414,9 @@ class ArtiMark::Parser < KPeg::CompiledParser
   Rules[:_documentcontent_except] = rule_info("documentcontent_except", "(inline | !inline char_except(e))+:content {parse_text(content)}")
   Rules[:_documentcontent] = rule_info("documentcontent", "(inline | !inline char)+:content {parse_text(content)}")
   Rules[:_documentline] = rule_info("documentline", "lh documentcontent:content le { content }")
-  Rules[:_root] = rule_info("root", "header*:headers - block*:blocks - eof_comment? eof { headers.concat blocks.select{ |x| !x.nil?} }")
+  Rules[:_headers] = rule_info("headers", "header*:headers { create_item(:headers, nil, headers) }")
+  Rules[:_page] = rule_info("page", "headers:headers - (!newpage block)*:blocks { create_item(:page, nil, [headers] + blocks.select{ |x| !x.nil?}) }")
+  Rules[:_newpaged_page] = rule_info("newpaged_page", "newpage:newpage page:page { page[:children] = page[:children].unshift newpage; page }")
+  Rules[:_root] = rule_info("root", "page:page newpaged_page*:pages - eof_comment? eof { [ page ] + pages }")
   # :startdoc:
 end