highmark-markdown 0.0.379 → 0.0.382

package/src/node/markdown/directives.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 
-const { first, push } = arrayUtilities;
+const { clear, first, push } = arrayUtilities;
 
 export default class DirectivesMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, opacity, precedence, domElement, domElements) {
@@ -42,6 +42,8 @@ export default class DirectivesMarkdownNode extends MarkdownNode {
     const domElement = null,
           childNodes = this.getChildNodes();
 
+    clear(this.domElements);
+
     childNodes.forEach((childNode) => {
       const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
@@ -60,6 +62,13 @@ export default class DirectivesMarkdownNode extends MarkdownNode {
     return domElement;
   }
 
+  clone() {
+    const domElements = [],
+          directivesMarkdownNode = super.clone(domElements);
+
+    return directivesMarkdownNode;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
     const domElements = [],
           directivesMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DirectivesMarkdownNode, ruleName, childNodes, opacity, domElements);

package/src/node/markdown/division.js

@@ -2,20 +2,24 @@
 
 import { arrayUtilities } from "necessary";
 
+import Replacement from "../../replacement";
 import MarkdownNode from "../../node/markdown";
 import ContentsListMarkdownNode from "../../node/markdown/contentsList";
 import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
 
 import { EMPTY_STRING } from "../../constants";
-import { renumberLinkMarkdownNodes } from "../../utilities/footnotes";
-import { replaceNode, replaceNodes, replaceTokens } from "../../utilities/replace";
-import { headingMarkdownNodesFromNode,
+import { DIVISION_RULE_NAME } from "../../ruleNames";
+import { removeNode, removeTokens, replaceNode, replaceNodes, replaceTokens } from "../../utilities/node";
+import { footnoteMarkdownNodsFromNode,
+         headingMarkdownNodesFromNode,
+         subDivisionMarkdownNodesFromNode,
          embedDirectiveMarkdownNodesFromNode,
          ignoreDirectiveMarkdownNodeFromNode,
          contentsDirectiveMarkdownNodeFromNode,
-         footnotesDirectiveMarkdownNodeFromNode } from "../../utilities/query";
+         footnotesDirectiveMarkdownNodeFromNode,
+         pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
 
-const { filter } = arrayUtilities;
+const { clear, filter } = arrayUtilities;
 
 export default class DivisionMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, precedence, opacity, domElement, divisionClassName) {
@@ -74,6 +78,52 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return parentNode;
   }
 
+  paginate(context) {
+    const { linesPerPage } = context,
+          childNodes = this.getChildNodes(),
+          paginatedChildNodes = [],
+          divisionMarkdownNodes = [],
+          subDivisionReplacements = this.removeSubdivisionMarkdownNodes(pageNumberDirectiveMarkdownNodeFromNode, context);
+
+    let totalLines = 0;
+
+    childNodes.forEach((childNode) => {
+      const lines = childNode.lines(context),
+            paginatedChildNode = childNode;  ///
+
+      totalLines += lines;
+
+      paginatedChildNodes.push(paginatedChildNode);
+
+      if (totalLines > linesPerPage) {
+        const divisionMarkdownNode = DivisionMarkdownNode.fromSubdivisionReplacementsPaginatedChildNodesAndDivisionClassName(subDivisionReplacements, paginatedChildNodes, this.divisionClassName, context);
+
+        divisionMarkdownNodes.push(divisionMarkdownNode);
+
+        clear(paginatedChildNodes);
+
+        totalLines = 0;
+      }
+    });
+
+    if (totalLines > 0) {
+      const divisionMarkdownNode = DivisionMarkdownNode.fromSubdivisionReplacementsPaginatedChildNodesAndDivisionClassName(subDivisionReplacements, paginatedChildNodes, this.divisionClassName, context);
+
+      divisionMarkdownNodes.push(divisionMarkdownNode);
+    }
+
+    return divisionMarkdownNodes;
+  }
+
+  setPageNumber(pageNumber) {
+    const node = this,
+          pageNumberDirective = pageNumberDirectiveMarkdownNodeFromNode(node);
+
+    if (pageNumberDirective !== null) {
+      pageNumberDirective.setPageNumber(pageNumber);
+    }
+  }
+
   createContents(context) {
     let contentsCreated = false;
 
@@ -108,22 +158,40 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return contentsCreated;
   }
 
-  createFootnotes(context) {
-    const node = this,  ///
-          footnotesDirectiveMarkdownNode = footnotesDirectiveMarkdownNodeFromNode(node);
+  createFootnotes(footnoteReplacements, context) {
+    if (footnoteReplacements === null) {
+      return;
+    }
 
-    if (footnotesDirectiveMarkdownNode !== null) {
-      const divisionMarkdownNode = this,  ///
-            footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+    const divisionMarkdownNode = this,  ///
+          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context);
 
-      if (footnotesListMarkdownNode !== null) {
-        const childNode = footnotesListMarkdownNode;  ///
+    if (footnotesListMarkdownNode === null) {
+      return;
+    }
 
-        divisionMarkdownNode.appendChildNode(childNode);
+    const node = footnotesListMarkdownNode, ///
+          replacement = Replacement.fromNode(node, context);
 
-        renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context)
-      }
+    replacement.appendTo(divisionMarkdownNode, context);
+  }
+
+  prepareFootnotes(context) {
+    let subdivisionReplacements;
+
+    subdivisionReplacements = this.removeSubdivisionMarkdownNodes(footnoteMarkdownNodsFromNode, context);
+
+    let footnoteReplacements = footnoteReplacementsFromSubdivisionReplacements(subdivisionReplacements);
+
+    subdivisionReplacements = this.removeSubdivisionMarkdownNodes(footnotesDirectiveMarkdownNodeFromNode, context);
+
+    const subdivisionReplacementsLength = subdivisionReplacements.length;
+
+    if (subdivisionReplacementsLength === 0) {
+      footnoteReplacements = null;
     }
+
+    return footnoteReplacements;
   }
 
   resolveEmbeddings(context) {
@@ -131,14 +199,14 @@ export default class DivisionMarkdownNode extends MarkdownNode {
           embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodesFromNode(node);
 
     embedDirectiveMarkdownNodes.map((embedDirectiveMarkdownNode) => {
-      const replacementNodeAndTokens = embedDirectiveMarkdownNode.replacementNodeAndTokens(context);
+      const replacement = embedDirectiveMarkdownNode.replacement(context);
 
-      if (replacementNodeAndTokens !== null) {
+      if (replacement !== null) {
         let tokens;
 
-        tokens = replacementNodeAndTokens.getTokens();
+        tokens = replacement.getTokens();
 
-        const childNodes = replacementNodeAndTokens.getChildNodes(),
+        const childNodes = replacement.getChildNodes(),
               replacementNodes = childNodes, ///
               replacementTokens = tokens; ///
 
@@ -155,6 +223,32 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     });
   }
 
+  removeSubdivisionMarkdownNodes(markdownNodeFromNode, context) {
+    const { tokens } = context,
+          node = this,  ///
+          parentNode = this,  ///
+          subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node),
+          subDivisionReplacements = subDivisionMarkdownNodes.reduce((subDivisionReplacements, subDivisionMarkdownNode) => {
+            const node = subDivisionMarkdownNode, ///
+                  markdownNode = markdownNodeFromNode(node);
+
+            if (markdownNode !== null) {
+              const removedNode = subDivisionMarkdownNode,  ///
+                    subDivisionReplacement = Replacement.fromNode(subDivisionMarkdownNode, context);
+
+              subDivisionReplacements.push(subDivisionReplacement);
+
+              removeTokens(removedNode, tokens);
+
+              removeNode(removedNode, parentNode);
+            }
+
+            return subDivisionReplacements;
+          }, []);
+
+    return subDivisionReplacements;
+  }
+
   createFootnotesListMarkdownNode(context) {
     const divisionMarkdownNode = this,  ///
           footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
@@ -162,12 +256,6 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return footnotesListMarkdownNode;
   }
 
-  removeFootnotesListMarkdownNode(footnotesListMarkdownNode) {
-    const childNode = footnotesListMarkdownNode;  ///
-
-    this.removeChildNode(childNode);
-  }
-
   asHTML(context) {
     let html = null;
 
@@ -194,6 +282,36 @@ ${childNodesHTML}${indent}${closingTag}
 
     return divisionMarkdownNode;
   }
+
+  static fromSubdivisionReplacementsPaginatedChildNodesAndDivisionClassName(subDivisionReplacements, paginatedChildNodes, divisionClassName, context) {
+    const ruleName = DIVISION_RULE_NAME,
+          childNodes = [
+            ...paginatedChildNodes
+          ],
+          opacity = null,
+          divisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity, divisionClassName);
+
+    subDivisionReplacements.some((subDivisionReplacement) => {
+      subDivisionReplacement.appendTo(divisionMarkdownNode, context);
+
+      return true;  ///
+    });
+
+    return divisionMarkdownNode;
+  }
+}
+
+function footnoteReplacementsFromSubdivisionReplacements(subdivisionReplacements) {
+  const footnoteReplacements = subdivisionReplacements.map((subdivisionReplacement) => {
+    const node = subdivisionReplacement.getNode(),
+          footnoteMarkdownNode = footnoteMarkdownNodsFromNode(node),
+          descendentNode = footnoteMarkdownNode,  ///
+          footnoteReplacement = subdivisionReplacement.contract(descendentNode);
+
+    return footnoteReplacement;
+  });
+
+  return footnoteReplacements;
 }
 
 function headingMarkdownNodesFromDivisionMarkdownNodeAndContentsDirectiveMarkdownNode(divisionMarkdownNode, contentsDirectiveMarkdownNode, context) {

package/src/node/markdown/emailLink.js

@@ -10,6 +10,12 @@ import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 const { first, second, secondLast } = arrayUtilities;
 
 class EmailLinkMarkdownNode extends MarkdownNode {
+  lines(context) {
+    const lines = 0;
+
+    return lines;
+  }
+
   inlineText(context) {
     let inlineText = null;
 

package/src/node/markdown/endOfLine.js

@@ -5,6 +5,12 @@ import MarkdownNode from "../../node/markdown";
 import { CARRIAGE_RETURN } from "../../constants";
 
 export default class EndOfLineMarkdownNode extends MarkdownNode {
+  lines(context) {
+    const lines = 0;
+
+    return lines;
+  }
+
   content(context) {
     const content = CARRIAGE_RETURN;
 

package/src/node/markdown/footnoteItem.js

@@ -19,7 +19,7 @@ export default class FootnoteItemMarkdownNode extends MarkdownNode {
     return identifier;
   }
 
-  static fromFootnoteMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier) {
+  static fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier) {
     const anchorMarkdownNode = AnchorMarkdownNode.fromIdentifier(identifier),
           footnoteMarkdownNodeChildNodes = footnoteMarkdownNode.getChildNodes(),
           secondFootnoteMarkdownNodeChildNode = second(footnoteMarkdownNodeChildNodes),

package/src/node/markdown/footnotesList.js

@@ -1,65 +1,121 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import MarkdownNode from "../../node/markdown";
 import FootnoteItemMarkdownNode from "./footnoteItem";
 
+import { START_ATTRIBUTE_NAME } from "../../attributeNames";
 import { FOOTNOTES_LIST_RULE_NAME } from "../../ruleNames";
-import { linkMarkdownNodesFromNode, footnoteMarkdownNodesFromNode } from "../../utilities/query";
+import { linkMarkdownNodesFromNode } from "../../utilities/query";
+
+const { extract } = arrayUtilities;
 
 export default class FootnotesListMarkdownNode extends MarkdownNode {
-  identifierToNumberMap(context) {
-    const childNodes = this.getChildNodes(),
-          footnoteItemMarkdownNodes = childNodes, ///
-          identifierToNumberMap = footnoteItemMarkdownNodes.reduce((identifierToNumberMap, footnoteItemMarkdownNode, index) => {
-            const number = index + 1,
-                  identifier = footnoteItemMarkdownNode.identifier(context);
+  constructor(ruleName, childNodes, opacity, precedence, domElement, start) {
+    super(ruleName, childNodes, opacity, precedence, domElement);
+
+    this.start = start;
+  }
+
+  getStart() {
+    return this.start;
+  }
+
+  attributeName(context) {
+    const attributeName = START_ATTRIBUTE_NAME;
 
-            identifierToNumberMap[identifier] = number;
+    return attributeName;
+  }
 
-            return identifierToNumberMap;
-          }, {});
+  attributeValue(context) {
+    const attributeValue = this.start;  ///
 
-    return identifierToNumberMap;
+    return attributeValue;
   }
 
-  static fromDivisionMarkdownNode(divisionMarkdownNode, context) {
+  clone() { return super.clone(this.start); }
+
+  static fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context) {
     let footnotesListMarkdownNode = null;
 
+    const { footnoteNumberMap } = context;
+
     const node = divisionMarkdownNode,  ///
+          footnoteNumbers = Object.values(footnoteNumberMap),
           linkMarkdownNodes = linkMarkdownNodesFromNode(node),
-          footnoteMarkdownNodes = footnoteMarkdownNodesFromNode(node),
-          footnoteItemMarkdownNodes = [],
-          identifierToFootnoteMarkdownNodeMap = {};
+          footnoteNumbersLength = footnoteNumbers.length,
+          footnoteItemReplacements = [];
 
-    footnoteMarkdownNodes.forEach((footnoteMarkdownNode) => {
-      const identifier = footnoteMarkdownNode.identifier(context);
-
-      identifierToFootnoteMarkdownNodeMap[identifier] = footnoteMarkdownNode;
-    });
+    let count = 0;
 
     linkMarkdownNodes.forEach((linkMarkdownNode) => {
-      const identifier = linkMarkdownNode.identifier(context),
-            footnoteMarkdownNode = identifierToFootnoteMarkdownNodeMap[identifier] || null;
+      const identifier = linkMarkdownNode.identifier(context);
+
+      let footnoteNumber = footnoteNumberMap[identifier] || null;
+
+      if (footnoteNumber === null) {
+        const footnoteReplacement = footnoteReplacementFromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context);
 
-      if (footnoteMarkdownNode !== null) {
-        const footnoteItemMarkdownNode = FootnoteItemMarkdownNode.fromFootnoteMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier);
+        if (footnoteReplacement !== null) {
+          const footnoteItemReplacement = footnoteItemReplacementFromFootnoteReplacementAndIdentifier(footnoteReplacement, identifier);
 
-        footnoteItemMarkdownNodes.push(footnoteItemMarkdownNode);
+          footnoteItemReplacements.push(footnoteItemReplacement);
 
-        delete identifierToFootnoteMarkdownNodeMap[identifier];
+          count++;
+
+          footnoteNumber = footnoteNumbersLength + count;
+
+          footnoteNumberMap[identifier] = footnoteNumber;
+        }
+      }
+
+      if (footnoteNumber !== null) {
+        const number = footnoteNumber;  ///
+
+        linkMarkdownNode.setNumber(number);
       }
     });
 
-    const footnoteItemMarkdownNodesLength = footnoteItemMarkdownNodes.length;
+    const footnoteItemReplacementsLength = footnoteItemReplacements.length;
 
-    if (footnoteItemMarkdownNodesLength > 0) {
+    if (footnoteItemReplacementsLength > 0) {
       const ruleName = FOOTNOTES_LIST_RULE_NAME,
-            childNodes = footnoteItemMarkdownNodes, ///
-            opacity = null;
+            childNodes = [], ///
+            opacity = null,
+            start = footnoteNumbersLength + 1;
+
+      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
 
-      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity);
+      footnoteItemReplacements.forEach((footnotesItemReplacement) => {
+        footnotesItemReplacement.appendTo(footnotesListMarkdownNode, context);
+      });
     }
 
     return footnotesListMarkdownNode;
   }
 }
+
+function footnoteReplacementFromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context) {
+  const footnoteReplacement = extract(footnoteReplacements, (footnoteReplacement) => {
+          const node = footnoteReplacement.getNode(),
+            footnoteMarkdownNode = node,  ///
+            footnoteMarkdownNodeIdentifier = footnoteMarkdownNode.identifier(context);
+
+          if (footnoteMarkdownNodeIdentifier === identifier) {
+            return true;
+          }
+        }) || null;
+
+  return footnoteReplacement;
+}
+
+function footnoteItemReplacementFromFootnoteReplacementAndIdentifier(footnoteReplacement, identifier) {
+  const node = footnoteReplacement.getNode(),
+        footnoteMarkdownNode = node,  ///
+        footnoteItemMarkdownNode = FootnoteItemMarkdownNode.fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier),
+        ascendantNode = footnoteItemMarkdownNode, ///
+        footnoteItemReplacement = footnoteReplacement.expand(ascendantNode);
+
+  return footnoteItemReplacement;
+}

package/src/node/markdown/heading/primary.js

@@ -3,6 +3,8 @@
 import HeadingMarkdownNode from "../../../node/markdown/heading";
 
 export default class PrimaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static lines = 3;
+
   static depth = 1;
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(PrimaryHeadingMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/heading/quaternary.js

@@ -3,6 +3,8 @@
 import HeadingMarkdownNode from "../../../node/markdown/heading";
 
 export default class QuaternaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static lines = 2;
+
   static depth = 4;
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(QuaternaryHeadingMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/heading/secondary.js

@@ -3,6 +3,8 @@
 import HeadingMarkdownNode from "../../../node/markdown/heading";
 
 export default class SecondaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static lines = 2.5;
+
   static depth = 2;
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(SecondaryHeadingMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/heading/tertiary.js

@@ -3,6 +3,8 @@
 import HeadingMarkdownNode from "../../../node/markdown/heading";
 
 export default class TertiaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static lines = 2.25;
+
   static depth = 3;
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(TertiaryHeadingMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/heading.js

@@ -11,6 +11,12 @@ import { replaceSpacesWithHyphens, removedLeadingWhitespace, removeNonAlphabetic
 const { last } = arrayUtilities;
 
 export default class HeadingMarkdownNode extends MarkdownNode {
+  lines(context) {
+    const { lines } = this.constructor;
+
+    return lines;
+  }
+
   getDepth() {
     const { depth } = this.constructor;
 

package/src/node/markdown/line.js

@@ -2,9 +2,20 @@
 
 import MarkdownNode from "../../node/markdown";
 
-import { htmlFromChildNodes, domElementsFromChildNodes } from "../../utilities/childNodes";
+import { htmlFromChildNodes, plainTextFromChildNodes, domElementsFromChildNodes } from "../../utilities/childNodes";
 
 export default class LineMarkdownNode extends MarkdownNode {
+  lines(context) {
+    const { charactersPerLine } = context,
+          childNodes = this.getChildNodes(),
+          plainText = plainTextFromChildNodes(childNodes, context),
+          plainTextLength = plainText.length,
+          characters = plainTextLength, ///
+          lines = (characters / charactersPerLine) + 1;
+
+    return lines;
+  }
+
   asHTML(indent, context) {
     indent = this.adjustIndent(indent);
 

package/src/node/markdown/subDivision.js

@@ -8,42 +8,48 @@ const { second } = arrayUtilities;
 
 export default class SubDivisionMarkdownNode extends MarkdownNode {
   getDOMElement() {
-    const markdownNode = this.getMarkdownNode(),
-          domElement = markdownNode.getDOMElement();
+    const secondMarkdownNode = this.getSecondMarkdownNode(),
+          domElement = secondMarkdownNode.getDOMElement();
 
     return domElement;
   }
 
   getDOMElements() {
-    const markdownNode = this.getMarkdownNode(),
-          domElements = markdownNode.getDOMElements();
+    const secondMarkdownNode = this.getSecondMarkdownNode(),
+          domElements = secondMarkdownNode.getDOMElements();
 
     return domElements;
   }
 
+  lines(context) {
+    const secondMarkdownNode = this.getSecondMarkdownNode(),
+          lines = secondMarkdownNode.lines(context);
+
+    return lines;
+  }
+
   asHTML(indent, context) {
-    const markdownNode = this.getMarkdownNode(),
-          markdownNodeHTML = markdownNode.asHTML(indent, context),
-          html = markdownNodeHTML;  ///
+    const secondMarkdownNode = this.getSecondMarkdownNode(),
+          html = secondMarkdownNode.asHTML(indent, context);
 
     return html;
   }
 
   createDOMElement(context) {
     const domElement = null,
-          markdownNode = this.getMarkdownNode();
+          secondMarkdownNode = this.getSecondMarkdownNode();
 
-    markdownNode.createDOMElement(context);
+    secondMarkdownNode.createDOMElement(context);
 
     return domElement;
   }
 
-  getMarkdownNode() {
+  getSecondMarkdownNode() {
     const childNodes = this.getChildNodes(),
           secondChildNode = second(childNodes),
-          markdownNode = secondChildNode; ///
+          secondMarkdownNode = secondChildNode; ///
 
-    return markdownNode;
+    return secondMarkdownNode;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {

package/src/node/markdown.js

@@ -132,6 +132,25 @@ class MarkdownNode extends NonTerminalNode {
     });
   }
 
+  lines(context) {
+    const childNodes = this.getChildNodes(),
+          lines = childNodes.reduce((lines, childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode,  ///
+                    markdownNode = nonTerminalNode, ///
+                    markdownNodeLines = markdownNode.lines(context);
+
+              lines += markdownNodeLines;
+            }
+
+            return lines;
+          }, 0);
+
+    return lines;
+  }
+
   asHTML(indent, context) {
     const tagName = this.tagName(context);