nora_mark 0.2beta6 → 0.2beta7

data/lib/nora_mark/html/tag_writer.rb

@@ -24,9 +24,10 @@ module NoraMark
       end
 
       def attr_string(attrs)
+        return '' if attrs.nil?
         attrs.map do
           |name, vals|
-          if vals.size == 0
+          if vals.nil? || vals.size == 0
             ''
           else
             " #{name}='#{vals.join(' ')}'"            
@@ -76,7 +77,7 @@ module NoraMark
 
       def write(node)
         @node_preprocessors.each { |x| node = instance_exec node.dup, &x }
-        @context.enable_pgroup, saved_ep = !(node.parameters.include?('wo-pgroup') || !@context.enable_pgroup), @context.enable_pgroup
+        @context.enable_pgroup, saved_ep = !((node.parameters || []).include?('wo-pgroup') || !@context.enable_pgroup), @context.enable_pgroup
         tag_start node
         write_body node unless node.body_empty
         tag_end node unless node.body_empty
@@ -92,17 +93,17 @@ module NoraMark
       end
 
       def write_children(node)
-        write_array(node.content)
+        write_nodeset(node.children)
       end
 
-      def write_array(array)
-        return if array.nil? || array.size == 0
-        array.each { |x| @generator.to_html x }
+      def write_nodeset(nodeset)
+        return if nodeset.nil? || nodeset.size == 0
+        nodeset.each { |x| @generator.to_html x }
         @generator.context.chop_last_space if (@param[:chop_last_space]) 
       end
       
       def children_not_empty(node)
-        !node.content.nil? && node.content.size > 0 && node.content.reject { |x| x.nil? }.size > 0
+        !node.children.nil? && node.children.size > 0 && node.children.reject { |x| x.nil? }.size > 0
       end
     end
   end

data/lib/nora_mark/node.rb

@@ -2,14 +2,15 @@ require 'yaml'
 
 module NoraMark
   class Node
-    attr_accessor :content, :ids, :classes, :no_tag, :attrs, :name, :body_empty
+    include Enumerable
+    attr_accessor :content, :ids, :classes, :no_tag, :attrs, :name, :body_empty, :line_no
+    attr_accessor :parent, :first_child, :last_child, :prev, :next, :holders
 
     def named_parameters=(named_parameters)
       @named_parameters = named_parameters
     end
 
     def named_parameters
-      @named_parameters = Hash[*(parameters.select { |x| x.include?(':') }.map { |x| v = x.split(':', 2); [v[0].strip.to_sym, v[1]]}.flatten)] if !@parameters.nil?
       @named_parameters ||= {}
     end
 
@@ -20,9 +21,264 @@ module NoraMark
     def parameters
       @parameters ||= []
     end
+
+    def each
+      node = self
+      while !node.nil?
+        yield node
+        node = node.next
+      end
+    end
+
+    def match?(selector)
+      selector = build_selector(selector)
+      selector.inject(true) {
+        |result, selector|
+        result && selector.call(self)
+      }
+    end
+
+    def modify_selector(k,v)
+      case k
+      when :type
+        proc { | node | node.kind_of? NoraMark.const_get(v) }
+      when :name
+        proc { | node | node.name ==  v }
+      when :id
+        proc { | node | (node.ids || []).contain? v }
+      when :class
+        proc { | node | (node.class || []).contain? v }
+      when :proc
+        v
+      else
+        raise 'no selector'
+      end
+    end
+
+    def build_selector(selector)
+      if selector.is_a? String
+        selector = { name: selector }
+      end
+      selector.map { |k,v| modify_selector(k,v) }
+    end
+
+    def ancestors(selector = {})
+      result = []
+      node = parent
+      while !node.nil?
+        result << node if node.match?(selector)
+        node = node.parent
+      end
+      result
+    end
+
+    def reparent
+      return if @content.nil?
+
+      @content.each {|node| node.remove }
+
+      @first_child = @content.first
+      @last_child = @content.last
+      @content.inject(nil) do |prev, child_node|
+        child_node.prev = prev
+        prev.next = child_node if !prev.nil?
+        child_node.parent = self
+        child_node.reparent 
+        child_node
+      end
+      @content = nil
+      @children = nil
+    end
+
+    def children
+      return [] if @first_child.nil?
+      return @children ||= NodeSet.new(@first_child.collect { |node| node })
+    end
+
+    def children=(x)
+      @content = x.to_ary
+      reparent
+    end
+
+    def children_replaced
+      @children = nil
+    end
+
+    def unlink
+      @parent = nil
+      @prev = nil
+      @next = nil
+    end
+
+    def remove
+      @parent.first_child = @next  if !@parent.nil? && @parent.first_child == self
+      @parent.last_child = @prev  if !@parent.nil? && @parent.last_child == self
+      @next.prev = @prev unless @next.nil?
+      @prev.next = @next unless @prev.nil?
+      @parent.children_replaced unless @parent.nil?
+      unlink
+    end
+    
+    def replace(node)
+      node.parent = @parent
+      @parent.first_child = node if (@parent.first_child == self)
+      @parent.last_child = node if (@parent.last_child == self)
+
+      node.prev = @prev
+      node.next = @next
+
+      @prev.next = node unless @prev.nil?
+      @next.prev = node unless @next.nil?
+
+      node.reparent
+      node.parent.children_replaced
+
+      unlink
+    end
+
+    def prepend_child(node)
+      node.remove
+      node.reparent
+      if self.children.size == 0
+        @content = [ node ]
+        reparent
+      else
+        @first_child.prev = node
+        node.next = @first_child
+        node.parent = self
+        @first_child = node
+        children_replaced
+      end
+    end
+    
+    def append_child(node)
+      node.remove
+      node.reparent
+      if self.children.size == 0
+        @content = [ node ]
+        reparent
+      else
+        @last_child.next = node 
+        node.prev = @last_child
+        node.parent = self
+        @last_child = node
+        children_replaced
+      end
+    end
+
+    def all_nodes
+      return [] if @first_child.nil?
+      @first_child.inject([]) do
+        |result, node|
+        result << node
+        result + node.all_nodes
+      end
+    end
+    
+    def clone
+      @content = nil
+      all_nodes.each { |node| @content = nil }
+      Marshal.restore Marshal.dump self
+    end
+
+    def get_text
+      children.inject("") do
+        |result, node|
+        result << node.get_text
+      end
+    end
+  end
+
+  class Root < Node
+    attr_accessor :document_name
+  end
+
+  class Page < Node
+    attr_accessor :page_no
+  end
+
+  class DLItem < Node
+    def reparent
+      super
+      @parameters[0].inject(nil) do
+        |prev, child_node|
+        child_node.prev = prev
+        prev.next = child_node if !prev.nil?
+        child_node.parent = self
+        child_node.reparent 
+        child_node
+      end
+    end
+    def get_text
+      @parameters[0].inject('') do
+        |result, node|
+        result << node.get_text
+      end << super
+    end
   end
 
+  class Block < Node
+    def heading_info
+      @name =~ /h([1-6])/
+      return {} if $1.nil?
+      {level:  $1.to_i, id: @ids[0], text: get_text }
+    end
+  end
+
+  class HeadedSection < Node
+    def heading_info
+      {level: @level, id: (named_parameters[:heading_id] || [])[0], text: @heading.map(&:get_text).join('')}
+    end
+
+    def reparent
+      super
+      @heading.inject(nil) do
+        |prev, child_node|
+        child_node.prev = prev
+        prev.next = child_node if !prev.nil?
+        child_node.parent = self
+        child_node.reparent 
+        child_node
+      end
+    end
+
+    def get_text
+      @heading[0].inject('') do
+        |result, node|
+        result << node.get_text
+      end << super
+    end
+
+  end
+  class Text < Node
+    def reparent
+      # do nothing.
+    end
+
+    def get_text
+      @content
+    end
+  end
+
+
+  class PreformattedBlock < Node
+    def reparent
+      # do nothing.
+    end
+    def get_text
+      @content.join "\n"
+    end
+  end
+  
   class Frontmatter < Node
+    def reparent
+      # do nothing.
+    end
+
+    def get_text
+      @content.join "\n"
+    end
+
     def yaml
       @yaml ||= YAML.load(@content.join("\n"))
       @yaml

data/lib/nora_mark/node_builder.rb

@@ -0,0 +1,18 @@
+module NoraMark
+  class NodeBuilder
+    include NodeUtil
+    def initialize(original_node, options)
+      @node = original_node
+      @options = options
+    end
+
+    def modify(&block)
+      instance_eval &block
+    end
+
+    def replace(&block)
+      new_node = instance_eval &block
+      @node.replace new_node
+    end
+  end
+end

data/lib/nora_mark/node_set.rb

@@ -0,0 +1,24 @@
+module NoraMark
+  class NodeSet
+    include Enumerable
+    def initialize(list = [])
+      @list = list
+    end
+
+    def [](n)
+      @list[n]
+    end
+
+    def size
+      @list.size
+    end
+
+    def each(&block)
+      @list.each(&block)
+    end
+
+    def to_ary
+      @list.dup
+    end
+  end
+end

data/lib/nora_mark/node_util.rb

@@ -0,0 +1,38 @@
+module NoraMark
+  module NodeUtil
+    def _node(klass, name, children = nil, ids: nil, children_: nil, classes: nil, parameters: nil, named_parameters: nil, attrs: nil, template: nil)
+      children_arg = children || children_
+      if !children_arg.nil?
+        children_arg = children_arg.to_ary if children_arg.kind_of? NodeSet
+        children_arg = [ children_arg ] if !children_arg.kind_of? Array
+        children_arg = children_arg.map { |node| (node.is_a? String) ? Text.new(node, 0) : node }
+      end
+      if !template.nil?
+        node = klass.new(name, template.ids, template.classes, template.parameters, template.named_parameters, template.children, template.line_no)
+        node.ids = (node.ids ||[] + ids) if !ids.nil?
+        node.classes = (node.classes || [])  +  classes if !classes.nil?
+        node.parameters = parameters if !parameters.nil?
+        node.named_parameters = named_parameters if !named_parameters.nil?
+        node.content = children_arg if !children_arg.nil?
+      else
+        node = klass.new(name, ids, classes, parameters, named_parameters, children_arg, 0)
+        node.reparent
+      end
+      node
+    end
+
+    def block(name, children = nil, ids: nil, children_: nil, classes: nil, parameters: nil, named_parameters: nil, attrs: nil, template: nil)
+      _node(Block, name, children, ids: ids, children_: children_, classes: classes, parameters: parameters, named_parameters: named_parameters, attrs: attrs, template: template)
+    end
+
+    def text value
+      Text.new(value, 0)
+    end
+
+    def inline(name, children = nil, ids: nil, children_: nil, classes: nil, parameters: nil, named_parameters: nil, attrs: nil, template: nil)
+      _node(Inline, name, children, ids: ids, children_: children_, classes: classes, parameters: parameters, named_parameters: named_parameters, attrs: attrs, template: template)
+    end
+
+
+  end
+end

data/lib/nora_mark/parser.kpeg

@@ -1,24 +1,27 @@
 %% name = NoraMark::Parser
 
 %% ast-location = ::NoraMark
-%% text = ast Text(content)
-%% paragraph = ast Paragraph(ids, classes, parameters, content)
-%% paragraph_group = ast ParagraphGroup(ids, classes, parameters, content)
-%% br = ast Breakline()
-%% line_command = ast LineCommand(name, ids, classes, parameters, content)
-%% block = ast Block(name, ids, classes, parameters, content)
-%% newpage = ast Newpage(ids, classes, parameters, content)
-%% inline = ast Inline(name, ids, classes, parameters, content)
-%% ul_item = ast UlItem(ids, classes, parameters, content)
-%% unordered_list = ast UnorderedList(ids, classes, parameters, content)
-%% ol_item = ast OlItem(ids, classes, parameters, content)
-%% ordered_list = ast OrderedList(ids, classes, parameters, content)
-%% dl_item = ast DLItem(ids, classes, parameters, content)
-%% definition_list = ast DefinitionList(ids, classes, parameters, content)
-%% preformatted_block = ast PreformattedBlock(name, ids, classes, parameters, codelanguage, content)
-%% frontmatter = ast Frontmatter(content)
-%% h_section = ast HeadedSection(level, heading, content)
-%% page = ast Page(content)
+%% text = ast Text(content, line_no)
+%% paragraph = ast Paragraph(ids, classes, parameters, named_parameters, content, line_no)
+%% paragraph_group = ast ParagraphGroup(ids, classes, parameters,named_parameters,  content, line_no)
+%% br = ast Breakline(line_no)
+%% block = ast Block(name, ids, classes, parameters, named_parameters,  content, line_no)
+%% newpage = ast Newpage(ids, classes, parameters, named_parameters,  content, line_no)
+%% inline = ast Inline(name, ids, classes, parameters, named_parameters,  content, line_no)
+%% ul_item = ast UlItem(ids, classes, parameters, named_parameters,  content, line_no)
+%% unordered_list = ast UnorderedList(ids, classes, parameters, named_parameters,  content, line_no)
+%% ol_item = ast OlItem(ids, classes, parameters, named_parameters,  content, line_no)
+%% ordered_list = ast OrderedList(ids, classes, parameters,named_parameters,  content, line_no)
+%% dl_item = ast DLItem(ids, classes, parameters, named_parameters, content, line_no)
+%% definition_list = ast DefinitionList(ids, classes, parameters, named_parameters, content, line_no)
+%% preformatted_block = ast PreformattedBlock(name, ids, classes, parameters, named_parameters, codelanguage, content, line_no)
+%% frontmatter = ast Frontmatter(content, line_no)
+%% h_section = ast HeadedSection(level, heading, content, line_no)
+%% page = ast Page(content, line_no)
+%% root = ast Root(content)
+
+# line number 
+ln = { current_line }
 
 # literals
 BOM = /\uFEFF/
@@ -26,8 +29,9 @@ Eof = !.
 Space = ' ' | '\t' 
 EofComment = Space* "#" (!Eof .)* 
 Comment =   Space* "#" (!Nl .)* Nl EmptyLine*
-- =  ( Space )* 
+- =  Space* 
 EmptyLine = /^/ - (Nl | Comment | EofComment)
+
 Nl = /\r?\n/
 Le = Nl | Eof
 Word  = < /[\w0-9]/ ( '-' | /[\w0-9]/ )* >  { text }
@@ -39,7 +43,7 @@ ClassNames = (ClassName)*:classnames { classnames }
 IdName = '#' Word:idname { idname }
 IdNames = (IdName)*:idnames { idnames }
 
-CommandName = Word:name IdNames?:idnames ClassNames?:classes  { {name: name, ids: idnames, classes: classes} }
+CommandName = Word:name IdNames?:idnames ClassNames?:classes ln:ln  { {name: name, ids: idnames, classes: classes, ln:ln } }
 ParameterNormal = < /[^,)]/* > { text }
 ParameterQuoted = '"' < /[^"]/* > '"' - &/[,)]/  { text }
 ParameterSingleQuoted = "'" < /[^']/* > "'" - &/[,)]/ { text }
@@ -47,103 +51,114 @@ Parameter = (ParameterQuoted
            | ParameterSingleQuoted
            | ParameterNormal ):value { value }
 
+NParameterNormal = < /[^,\]]/* > { text }
+NParameterQuoted = '"' < /[^"]/* > '"' - &/[,\]]/  { text }
+NParameterSingleQuoted = "'" < /[^']/* > "'" - &/[,\]]/ { text }
+NParameter = (NParameterQuoted
+           | NParameterSingleQuoted
+           | NParameterNormal ):value { value }
+
 Parameters = Parameter:parameter ',' - Parameters:parameters { [ parameter ] + parameters }
            | Parameter:parameter { [ parameter ] }
 
-Command = CommandName:cn ('(' - Parameters:args - ')')? { args ||= []; cn.merge({ args: args }) }
+NamedParameter = Word:key - ':' - NParameter:parameter { { key.to_sym => parameter } }
+NamedParameters = NamedParameter:parameter - ',' - NamedParameters:parameters { parameter.merge parameters }
+                | NamedParameter:parameter { parameter }
+
+Command = CommandName:cn ('(' - Parameters:args - ')')? ('[' - NamedParameters:named_args - ']')? { cn.merge({ args: args || [] , named_args: named_args || {}}) }
 
 # paragraph
-ImplicitParagraph = - !ParagraphDelimiter Comment* DocumentLine:content  Comment* EofComment? ~paragraph([],[], [], content)
+ImplicitParagraph =  - !ParagraphDelimiter Comment* DocumentLine:content ln:ln  Comment* EofComment? ~paragraph([],[], [], [], content, ln)
 
 # explicit paragraph
 ExplicitParagraphCommand = Command:c &{ c[:name] == 'p' }
-ExplicitParagraph = - ExplicitParagraphCommand:c ':' - DocumentContent?:content Le EmptyLine* ~paragraph(c[:ids], c[:classes], c[:args], content)
+ExplicitParagraph = - ExplicitParagraphCommand:c ':' - DocumentContent?:content Le EmptyLine* ~paragraph(c[:ids], c[:classes], c[:args], c[:named_args], content, c[:ln])
 
 Paragraph = ExplicitParagraph | ImplicitParagraph 
 
 # paragraph_group
-ParagraphGroup = Paragraph+:p EmptyLine* ~paragraph_group([],[],[],p)
+ParagraphGroup = ln:ln Paragraph+:p EmptyLine* ~paragraph_group([],[],[],[],p, ln)
 
 # explicit block 
-BlockHead = - Command:command - '{' - Nl EmptyLine* { command }
+BlockHead = Command:command - '{' - Nl EmptyLine* { command }
 BlockEnd =  - '}' - Le EmptyLine*
 BlockBody = (!BlockEnd Block)+:body { body } 
-ExplicitBlock = BlockHead:c - BlockBody:content - BlockEnd ~block(c[:name], c[:ids], c[:classes], c[:args], content)
+ExplicitBlock = -  BlockHead:c - BlockBody:content - BlockEnd ~block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args], content,  c[:ln])
 
 # preformatted block
 PreformattedCommand = Command:command &{ ['pre', 'code'].include? command[:name] }
-PreformattedCommandHeadSimple = - PreformattedCommand:command - '{' - Nl { command }
-PreformattedCommandHeadComplex = - PreformattedCommand:command - '{//' Word?:codelanguage - Nl { command.merge({codelanguage: codelanguage}) }
+PreformattedCommandHeadSimple = PreformattedCommand:command - '{' - Nl { command }
+PreformattedCommandHeadComplex =  PreformattedCommand:command - '{//' Word?:codelanguage - Nl { command.merge({codelanguage: codelanguage}) }
 PreformattedCommandHead = PreformattedCommandHeadComplex | PreformattedCommandHeadSimple
 PreformatEndSimple = - '}' - Le EmptyLine*
 PreformatEndComplex = - '//}' - Le EmptyLine*
 
-PreformattedBlockSimple = PreformattedCommandHeadSimple:c (!PreformatEndSimple (CharString Nl))+:content PreformatEndSimple
-                        ~preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:codelanguage], content)
+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])
 
-PreformattedBlockComplex = PreformattedCommandHeadComplex:c (!PreformatEndComplex (CharString Nl))+:content PreformatEndComplex
-                        ~preformatted_block(c[:name], c[:ids], c[:classes], c[:args], c[:codelanguage], content)
+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])
 
 PreformattedBlock = PreformattedBlockComplex | PreformattedBlockSimple
 
 # inline command
 Inline = ImgInline | CommonInline
-CommonInline = '[' Command:c '{' - DocumentContentExcept('}'):content '}' ']' ~inline(c[:name], c[:ids], c[:classes], c[:args], content)
+CommonInline =  '[' Command:c '{' - DocumentContentExcept('}'):content '}' ']' ~inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln])
 ImgCommand = Command:c &{ c[:name] == 'img' && c[:args].size == 2}
-ImgInline = '[' ImgCommand:c  ']' ~inline(c[:name], c[:ids], c[:classes], c[:args], nil)
+ImgInline =  '[' ImgCommand:c  ']' ~inline(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  nil,  c[:ln])
 
 # special line commands
 CommandNameForSpecialLineCommand = NewpageCommand | ExplicitParagraphCommand
 
 # newpage
 NewpageCommand = Command:command &{ command[:name] == 'newpage' }
-Newpage = - NewpageCommand:c ':' - DocumentContent?:content - Nl ~newpage(c[:ids],c[:classes],c[:args], content)
+Newpage = -  NewpageCommand:c ':' - DocumentContent?:content - Nl ~newpage(c[:ids],c[:classes],c[:args], c[:named_args],  content,  c[:ln])
 
 
 # unordered list
-UnorderedList = UnorderedItem+:items ~unordered_list([],[],[], items)
-UnorderedItem = '*:' - DocumentContent:content Le ~ul_item([], [], [], content)
+UnorderedList = ln:ln UnorderedItem+:items ~unordered_list([],[],[],[], items, ln)
+UnorderedItem = ln:ln '*:' - DocumentContent:content Le ~ul_item([], [], [], [], content, ln)
 
 # ordered list
-OrderedList = OrderedItem+:items ~ordered_list([],[],[], items)
-OrderedItem = Num ':' - DocumentContent:content Le ~ol_item([], [], [], content)
+OrderedList = ln:ln OrderedItem+:items ~ordered_list([],[],[], [], items, ln)
+OrderedItem = ln:ln Num ':' - DocumentContent:content Le ~ol_item([], [], [], [], content, ln)
 
 # definition list
-DefinitionList = DefinitionItem+:items ~definition_list([], [], [], items)
-DefinitionItem = - ';:' - DocumentContentExcept(':'):term ':' - DocumentContent:definition Le ~dl_item([], [], [term], definition)
+DefinitionList = ln:ln DefinitionItem+:items ~definition_list([], [], [], [], items, ln)
+DefinitionItem = -  ln:ln ';:' - DocumentContentExcept(':'):term ':' - DocumentContent:definition Le ~dl_item([], [], [term], [], definition, ln)
 
 # long definition list
-LongDefinitionList = LongDefinitionItem+:items ~definition_list([], [], [], items)
-LongDefinitionItem = - ';:' - DocumentContentExcept('{'):term '{' - Nl - BlockBody:definition - BlockEnd ~dl_item([], [], [term], definition)
+LongDefinitionList = ln:ln LongDefinitionItem+:items ~definition_list([], [], [], [], items, ln)
+LongDefinitionItem = -  ln:ln ';:' - DocumentContentExcept('{'):term '{' - Nl - BlockBody:definition - BlockEnd ~dl_item([], [], [term], [], definition, ln)
 
-ItemsList = UnorderedList
+ItemsList = (UnorderedList
           | OrderedList
           | DefinitionList
-          | LongDefinitionList
-
+          | LongDefinitionList) 
 
 # generic line command
-LineCommand = - !CommandNameForSpecialLineCommand Command:c ':' - DocumentContent?:content - Le EmptyLine*  ~line_command(c[:name], c[:ids], c[:classes], c[:args], content)
+LineCommand =  - !CommandNameForSpecialLineCommand Command:c ':' - DocumentContent?:content - Le EmptyLine*  ~block(c[:name], c[:ids], c[:classes], c[:args], c[:named_args],  content,  c[:ln])
 
 # blocks
 LineBlock =  ItemsList | LineCommand 
-Block = EmptyLine*
+Block = 
        (PreformattedBlock
        | HeadedSection
        | LineBlock 
        | ExplicitBlock
        | ParagraphGroup ):block
-         EmptyLine* {block}
+       EmptyLine*
+       {block} 
 
 BlockDelimiter = BlockHead | BlockEnd 
 ParagraphDelimiter = BlockDelimiter | PreformattedCommandHead | LineBlock | Newpage | HeadedStart
 
 # markdown-style headings
 HStartMark(n) = < '='+ ':' > &{ text.length - 1 == n }
-HMarkupTerminator(n) = - < '='+ ':' > &{ text.length - 1 <= n }
+HMarkupTerminator(n) = - < '='+ ':' > &{ text.length - 1 <= n } | - Eof
 
-HStart(n) = - HStartMark(n) - DocumentContent:s Le { { level: n, heading: s } }
-HSection(n) = HStart(n):h (!HMarkupTerminator(n) !Eof Block)*:content ~h_section(h[:level], h[:heading], content)
+HStart(n) = - HStartMark(n) ln:ln - DocumentContent:s Le { { level: n, heading: s, ln: ln} }
+HSection(n) = HStart(n):h EmptyLine* (!HMarkupTerminator(n) Block)*:content EmptyLine* ~h_section(h[:level], h[:heading], content, h[:ln])
 
 HeadedStart = HStart(1)
             | HStart(2)
@@ -161,25 +176,25 @@ HeadedSection = HSection(1)
 
 # frontmatter
 FrontmatterSeparator =  - '---' - Nl
-Frontmatter = FrontmatterSeparator (!FrontmatterSeparator ( CharString Nl))+:yaml FrontmatterSeparator EmptyLine* ~frontmatter(yaml)
+Frontmatter = FrontmatterSeparator ln:ln (!FrontmatterSeparator ( CharString Nl))+:yaml FrontmatterSeparator EmptyLine* ~frontmatter(yaml, ln)
 
 # texts
 Char = < /[[:print:]]/ > { text }
 CharString = < Char* > { text }
 CharExcept(e) = Char:c &{ c != e }
-DocumentTextExcept(e) = < (!Inline CharExcept(e))+ > ~text(text)
+DocumentTextExcept(e) = < (!Inline CharExcept(e))+ > ln:ln ~text(text, ln)
 DocumentContentExcept(e) = (Inline | DocumentTextExcept(e))+:content { content } 
-DocumentText = < (!Inline Char)+ > ~text(text)
+DocumentText = < (!Inline Char)+ > ln:ln ~text(text, ln)
 DocumentContent = (Inline | DocumentText)+:content  { content }
 DocumentLine = DocumentContent:content Le { content }
 
 #page
-Page = Frontmatter?:frontmatter - (!Newpage Block)*:blocks ~page(([frontmatter] +  blocks).select{ |x| !x.nil?})
+Page = Frontmatter?:frontmatter - (!Newpage Block)*:blocks EmptyLine* ~page(([frontmatter] +  blocks).select{ |x| !x.nil?}, 1)
 Pages = Page:page Newpage:newpage Pages:pages { [ page, newpage ] + pages }
       | Page:page { [ page ] }  
 
 #root
-root = BOM? Pages:pages - EofComment? Eof { pages }
+root = BOM? EmptyLine* Pages:pages EofComment? Eof ~root(pages)