highmark-markdown 0.0.428 → 0.0.431

package/src/markdown/parser.js

@@ -11,43 +11,43 @@ export default class MarkdownParser extends CommonParser {
 
   static nodeMap = nodeMap;
 
-  static fromNothing(Class) {
-    if (Class === undefined) {
+  static fromBNF(Class, bnf) {
+    if (bnf === undefined) {
+      bnf = Class;  ///
+
       Class = MarkdownParser; ///
     }
 
     const { nodeMap } = Class,
-          markdownParser = CommonParser.fromNothing(Class);
+          markdownParser = CommonParser.fromBNF(Class, bnf);
 
     setNonTerminalNodes(markdownParser, nodeMap);
 
     return markdownParser;
   }
 
-  static fromBNF(Class, bnf) {
-    if (bnf === undefined) {
-      bnf = Class;  ///
+  static fromRules(Class, rules) {
+    if (rules === undefined) {
+      rules = Class;  ///
 
       Class = MarkdownParser; ///
     }
 
     const { nodeMap } = Class,
-          markdownParser = CommonParser.fromBNF(Class, bnf);
+          markdownParser = CommonParser.fromRules(Class, rules);
 
     setNonTerminalNodes(markdownParser, nodeMap);
 
     return markdownParser;
   }
 
-  static fromRules(Class, rules) {
-    if (rules === undefined) {
-      rules = Class;  ///
-
+  static fromNothing(Class) {
+    if (Class === undefined) {
       Class = MarkdownParser; ///
     }
 
     const { nodeMap } = Class,
-          markdownParser = CommonParser.fromRules(Class, rules);
+          markdownParser = CommonParser.fromNothing(Class);
 
     setNonTerminalNodes(markdownParser, nodeMap);
 

package/src/node/markdown/anchor.js

@@ -9,12 +9,17 @@ import { ANCHOR_RULE_NAME } from "../../ruleNames";
 import { ID_ATTRIBUTE_NAME } from "../../attributeNames";
 
 export default class AnchorMarkdownNode extends MarkdownNode {
-  constructor(ruleName, childNodes, opacity, precedence, domElement, identifier) {
-    super(ruleName, childNodes, opacity, precedence, domElement);
+  constructor(ruleName, childNodes, opacity, precedence, domElement, prepend, identifier) {
+    super(ruleName, childNodes, opacity, precedence, domElement, prepend);
 
+    this.prepend = prepend;
     this.identifier = identifier;
   }
 
+  getPrepend() {
+    return this.prepend;
+  }
+
   getIdentifier() {
     return this.identifier;
   }
@@ -26,7 +31,7 @@ export default class AnchorMarkdownNode extends MarkdownNode {
   }
 
   attributeValue(context) {
-    const attributeValue = this.identifier; ///
+    const attributeValue = `${this.prepend}-${this.identifier}`;
 
     return attributeValue;
   }
@@ -46,16 +51,16 @@ export default class AnchorMarkdownNode extends MarkdownNode {
     this.addDOMElement(domElement);
   }
 
-  clone() { return super.clone(this.identifier); }
+  clone() { return super.clone(this.prepend, this.identifier); }
 
-  static fromIdentifier(identifier) {
+  static fromPrependAndIdentifier(prepend, identifier) {
     const epsilonNode = EpsilonNode.fromNothing(),
           ruleName = ANCHOR_RULE_NAME,
           childNodes = [
             epsilonNode
           ],
           opacity = null,
-          anchorMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(AnchorMarkdownNode, ruleName, childNodes, opacity, identifier);
+          anchorMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(AnchorMarkdownNode, ruleName, childNodes, opacity, prepend, identifier);
 
     return anchorMarkdownNode;
   }

package/src/node/markdown/comma.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import { COMMA } from "../../constants";
+
+export default class CommaMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    const content = this.content(context),
+          html = content; ///
+
+    return html;
+  }
+
+  createDOMElement(context) {
+    const content = this.content(context),
+          textNode = document.createTextNode(content),
+          domElement = textNode;  ///
+
+    this.setDOMElement(domElement);
+
+    return domElement;
+  }
+
+  content(context) {
+    const content = COMMA; ///
+
+    return content;
+  }
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(CommaMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/contentsLink.js

@@ -2,6 +2,7 @@
 
 import MarkdownNode from "../../node/markdown";
 
+import { CONTENTS_PREPEND } from "../../prepends";
 import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 import { CONTENTS_LINK_RULE_NAME } from "../../ruleNames";
 
@@ -23,7 +24,8 @@ export default class ContentsLinkMarkdownNode extends MarkdownNode {
   }
 
   attributeValue(context) {
-    const attributeValue = `#${this.identifier}`;
+    const prepend = CONTENTS_PREPEND,
+          attributeValue = `#${prepend}-${this.identifier}`;
 
     return attributeValue;
   }

package/src/node/markdown/contentsList.js

@@ -5,6 +5,12 @@ import MarkdownNode from "../../node/markdown";
 import { CONTENTS_LIST_RULE_NAME } from "../../ruleNames";
 
 export default class ContentsListMarkdownNode extends MarkdownNode {
+  asPlainText(context) {
+    const plainText = null;
+
+    return plainText;
+  }
+
   static fromContentsItemReplacements(contentsItemReplacements) {
     const ruleName = CONTENTS_LIST_RULE_NAME,
           childNodes = contentsItemReplacements.map((contentsItemReplacement) => {

package/src/node/markdown/directive/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import DirectiveMarkdownNode from "../../../node/markdown/directive";
+
+export default class IndexDirectiveMarkdownNode extends DirectiveMarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return DirectiveMarkdownNode.fromRuleNameChildNodesAndOpacity(IndexDirectiveMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/directive.js

@@ -3,6 +3,12 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class DirectiveMarkdownNode extends MarkdownNode {
+  asPlainText(context) {
+    const plainText = null;
+
+    return plainText;
+  }
+
   static lines = 0;
 
   static fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity); }

package/src/node/markdown/division.js

@@ -4,16 +4,19 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 import FootnoteReplacement from "../../replacement/footnote";
+import IndexListReplacement from "../../replacement/indexList";
 import ContentsListReplacement from "../../replacement/contentsList";
 import FootnotesListReplacement from "../../replacement/footnotesList";
 import FootnoteSubDivisionReplacement from "../../replacement/subDivision/footnote";
+import IndexAnchorSubDivisionReplacement from "../../replacement/subDivision/indexAnchor";
+import IndexDirectiveSubDivisionReplacement from "../../replacement/subDivision/indexDirective";
 import ContentsDirectiveSubDivisionReplacement from "../../replacement/subDivision/contentsDirective";
 import FootnotesDirectiveSubDivisionReplacement from "../../replacement/subDivision/footnotesDirective";
 import PageNumberDirectiveSubDivisionReplacement from "../../replacement/subDivision/pageNumberDirective";
 
 import { EMPTY_STRING } from "../../constants";
 import { DIVISION_RULE_NAME } from "../../ruleNames";
-import { renumberLinkMarkdownNodes } from "../../utilities/footnotes";
+import { renumberFootnoteLinkMarkdownNodes } from "../../utilities/footnotes";
 import { subDivisionMarkdownNodesFromNode, ignoreDirectiveMarkdownNodeFromNode, pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
 
 const { clear, filter } = arrayUtilities;
@@ -95,6 +98,25 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     }
   }
 
+  getPageNumber() {
+    let pageNumber = null;
+
+    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
+
+    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
+      const node = subDivisionMarkdownNode, ///
+            pageNumberDirective = pageNumberDirectiveMarkdownNodeFromNode(node);
+
+      if (pageNumberDirective !== null) {
+        pageNumber = pageNumberDirective.getPageNumber();
+
+        return true;
+      }
+    });
+
+    return pageNumber;
+  }
+
   setPageNumber(pageNumber) {
     const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
 
@@ -110,6 +132,25 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     });
   }
 
+  createIndex(divisionMarkdownNodes, context) {
+    let indexCreated = false;
+
+    const indexDirectiveSubDivisionReplacement = this.findSubDivisionReplacement(IndexDirectiveSubDivisionReplacement, context);
+
+    if (indexDirectiveSubDivisionReplacement !== null) {
+      const divisionMarkdownNode = this,  ///
+            indexListReplacement = IndexListReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
+
+      if (indexListReplacement !== null) {
+        indexListReplacement.replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
+
+        indexCreated = true;
+      }
+    }
+
+    return indexCreated;
+  }
+
   createContents(divisionMarkdownNodes, context) {
     let contentsCreated = false;
 
@@ -123,6 +164,16 @@ export default class DivisionMarkdownNode extends MarkdownNode {
         contentsListReplacement.replaceContentsDirectiveSubdivisionReplacement(contentsDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
 
         contentsCreated = true;
+
+        divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+          const pageNumber = divisionMarkdownNode.getPageNumber();
+
+          if (pageNumber !== null) {
+            const indexAnchorSubDivisionReplacement = IndexAnchorSubDivisionReplacement.fromPageNumber(pageNumber, context);
+
+            indexAnchorSubDivisionReplacement.prependToDivisionMarkdownNode(divisionMarkdownNode, context);
+          }
+        });
       }
     }
 
@@ -130,20 +181,20 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   }
 
   createFootnotes(footnoteReplacementMap, context) {
-    const footnotesDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionReplacement, context);
+    const footnotesDirectiveSubDivisionReplacement = this.findSubDivisionReplacement(FootnotesDirectiveSubDivisionReplacement, context);
 
     if (footnotesDirectiveSubDivisionReplacement !== null) {
       const divisionMarkdownNode = this,  ///
-            footnotesListReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteReplacementMap(divisionMarkdownNode, footnoteReplacementMap, context);
+            footnotesListSubDivisionReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteReplacementMap(divisionMarkdownNode, footnoteReplacementMap, context);
 
-      if (footnotesListReplacement !== null) {
-        footnotesListReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
+      if (footnotesListSubDivisionReplacement !== null) {
+        footnotesListSubDivisionReplacement.replaceFootnotesDirectiveSubDivisionReplacement(footnotesDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
       }
 
-      renumberLinkMarkdownNodes(divisionMarkdownNode, footnoteReplacementMap, callback, context);
+      renumberFootnoteLinkMarkdownNodes(divisionMarkdownNode, footnoteReplacementMap, callback, context);
     }
 
-    function callback(linkMarkdownNode) {
+    function callback(footnoteLinkMarkdownNode) {
       ///
     }
   }
@@ -248,9 +299,9 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     });
 
     const divisionMarkdownNode = this,  ///
-          footnotesListReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteReplacementMap(divisionMarkdownNode, footnoteReplacementMap, context);
+          footnotesListSubDivisionReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteReplacementMap(divisionMarkdownNode, footnoteReplacementMap, context);
 
-    return footnotesListReplacement;
+    return footnotesListSubDivisionReplacement;
   }
 
   asHTML(context) {

package/src/node/markdown/{link.js → footnoteLink.js}

@@ -5,11 +5,12 @@ import { arrayUtilities } from "necessary";
 import MarkdownNode from "../../node/markdown";
 
 import { EMPTY_STRING } from "../../constants";
+import { FOOTNOTE_PREPEND } from "../../prepends";
 import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 
 const { first, second } = arrayUtilities;
 
-export default class LinkMarkdownNode extends MarkdownNode {
+export default class FootnoteLinkMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, opacity, precedence, domElement, number) {
     super(ruleName, childNodes, opacity, precedence, domElement);
 
@@ -48,8 +49,9 @@ export default class LinkMarkdownNode extends MarkdownNode {
   }
 
   attributeValue(context) {
-    const identifier = this.identifier(context),
-          attributeValue = `#${identifier}`; ///
+    const prepend = FOOTNOTE_PREPEND,
+          identifier = this.identifier(context),
+          attributeValue = `#${prepend}-${identifier}`; ///
 
     return attributeValue;
   }
@@ -73,9 +75,9 @@ export default class LinkMarkdownNode extends MarkdownNode {
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
     const number = null,
-          linkMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(LinkMarkdownNode, ruleName, childNodes, opacity, number);
+          footnoteLinkMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnoteLinkMarkdownNode, ruleName, childNodes, opacity, number);
 
-    return linkMarkdownNode;
+    return footnoteLinkMarkdownNode;
   }
 }
 

package/src/node/markdown/footnotesItem.js

@@ -5,22 +5,15 @@ import { arrayUtilities } from "necessary";
 import MarkdownNode from "../../node/markdown";
 import AnchorMarkdownNode from "../../node/markdown/anchor";
 
+import { FOOTNOTE_PREPEND } from "../../prepends";
 import { FOOTNOTES_ITEM_RULE_NAME } from "../../ruleNames";
 
-const { first, second } = arrayUtilities;
+const { second } = arrayUtilities;
 
 export default class FootnotesItemMarkdownNode extends MarkdownNode {
-  identifier(context) {
-    const childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          anchorMarkdownNode = firstChildNode,  ///
-          identifier = anchorMarkdownNode.getIdentifier();
-
-    return identifier;
-  }
-
   static fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier) {
-    const anchorMarkdownNode = AnchorMarkdownNode.fromIdentifier(identifier),
+    const prepend = FOOTNOTE_PREPEND,
+          anchorMarkdownNode = AnchorMarkdownNode.fromPrependAndIdentifier(prepend, identifier),
           footnoteMarkdownNodeChildNodes = footnoteMarkdownNode.getChildNodes(),
           secondFootnoteMarkdownNodeChildNode = second(footnoteMarkdownNodeChildNodes),
           paragraphMarkdownNode = secondFootnoteMarkdownNodeChildNode,  ///

package/src/node/markdown/heading.js

@@ -5,6 +5,7 @@ import { arrayUtilities } from "necessary";
 import MarkdownNode from "../../node/markdown";
 import AnchorMarkdownNode from "../../node/markdown/anchor";
 
+import { CONTENTS_PREPEND } from "../../prepends";
 import { plainTextFromChildNodes } from "../../utilities/childNodes";
 import { replaceSpacesWithHyphens, removedLeadingWhitespace, removeNonAlphabeticAndSpaceCharacters } from "../../utilities/string";
 
@@ -18,8 +19,9 @@ export default class HeadingMarkdownNode extends MarkdownNode {
   }
 
   addAnchor(context) {
-    const identifier = this.identifier(context),
-          anchorMarkdownNode = AnchorMarkdownNode.fromIdentifier(identifier),
+    const prepend = CONTENTS_PREPEND,
+          identifier = this.identifier(context),
+          anchorMarkdownNode = AnchorMarkdownNode.fromPrependAndIdentifier(prepend, identifier),
           prependedChildNode = anchorMarkdownNode; ///
 
     this.prependChildNode(prependedChildNode);
@@ -41,6 +43,13 @@ export default class HeadingMarkdownNode extends MarkdownNode {
     return lineMarkdownNode;
   }
 
+  asPlainText(context) {
+    const childNodes = this.getChildNodes(),
+          plainText = plainTextFromChildNodes(childNodes, context);
+
+    return plainText;
+  }
+
   static fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity); }
 }
 

package/src/node/markdown/indexItem.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class IndexItemMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexItemMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/indexLink.js

@@ -0,0 +1,63 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+import { INDEX_PREPEND } from "../../prepends";
+import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
+
+const { first } = arrayUtilities;
+
+export default class IndexLinkMarkdownNode extends MarkdownNode {
+  attributeName(context) {
+    const attributeName = HREF_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const content = this.content(context),
+          attributeValue = `${INDEX_PREPEND}-${content}`;
+
+    return attributeValue;
+  }
+
+  asHTML(indent, context) {
+    indent = this.adjustIndent(indent);
+
+    const childNodesHTML = this.childNodesAsHTML(indent, context),
+          startingTag = this.startingTag(context),
+          closingTag = this.closingTag(context),
+          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
+`;
+
+    return html;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const content = this.content(context),
+          childNodesHTML = content; ///
+
+    return childNodesHTML;
+  }
+
+  createChildNodeDOMElements(context) {
+    const content = this.content(context),
+          textNode  = document.createTextNode(content),
+          domElement = textNode; ///
+
+    this.addDOMElement(domElement);
+  }
+
+  content(context) {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          terminalNode = firstChildNode,  ///
+          content = terminalNode.getContent();
+
+    return content;
+  }
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexLinkMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/indexList.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import { INDEX_LIST_RULE_NAME } from "../../ruleNames";
+
+export default class IndexListMarkdownNode extends MarkdownNode {
+  asPlainText(context) {
+    const plainText = null;
+
+    return plainText;
+  }
+
+  static fromIndexItemReplacements(indexItemReplacements) {
+    let indexListMarkdownNode = null;
+
+    const indexItemReplacementsLength = indexItemReplacements.length;
+
+    if (indexItemReplacementsLength > 0) {
+      const ruleName = INDEX_LIST_RULE_NAME,
+            childNodes = indexItemReplacements.map((indexItemReplacement) => {
+              const indexItemReplacementNode = indexItemReplacement.getIndexItemMarkdownNode(),
+                    childNode = indexItemReplacementNode;  ///
+
+              return childNode;
+            }),
+            opacity = null;
+
+      indexListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexListMarkdownNode, ruleName, childNodes, opacity);
+    }
+
+    return indexListMarkdownNode;
+  }
+}

package/src/node/markdown/line.js

@@ -7,8 +7,7 @@ import { htmlFromChildNodes, plainTextFromChildNodes, domElementsFromChildNodes
 export default class LineMarkdownNode extends MarkdownNode {
   lines(context) {
     const { charactersPerLine } = context,
-          childNodes = this.getChildNodes(),
-          plainText = plainTextFromChildNodes(childNodes, context),
+          plainText = this.asPlainText(context),
           plainTextLength = plainText.length,
           characters = plainTextLength, ///
           lines = (characters / charactersPerLine) + 1;
@@ -28,6 +27,13 @@ export default class LineMarkdownNode extends MarkdownNode {
     return html;
   }
 
+  asPlainText(context) {
+    const childNodesPlainText = this.childNodesAsPlainText(context),
+          plainText = childNodesPlainText; ///
+
+    return plainText;
+  }
+
   createDOMElement(context) {
     const tagName = this.tagName(context),
           className = this.className(context),
@@ -51,6 +57,13 @@ export default class LineMarkdownNode extends MarkdownNode {
     return html;
   }
 
+  childNodesAsPlainText(context) {
+    const childNodes = this.getChildNodes(),
+          plainText = plainTextFromChildNodes(childNodes, context);
+
+    return plainText;
+  }
+
   createChildNodeDOMElements(context) {
     const domElement = this.getDOMElement(),
           childNodes = this.getChildNodes(),

package/src/node/markdown/subDivision.js

@@ -3,9 +3,12 @@
 import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
+import VerticalSpaceMarkdownNode from "../../node/markdown/verticalSpace";
 import EmbedDirectivesSubDivisionReplacement from "../../replacement/subDivision/embedDirectives";
 import IncludeDirectivesSubDivisionReplacement from "../../replacement/subDivision/includeDirectives";
 
+import { SUB_DIVISION_RULE_NAME } from "../../ruleNames";
+
 const { second } = arrayUtilities;
 
 export default class SubDivisionMarkdownNode extends MarkdownNode {
@@ -52,9 +55,16 @@ export default class SubDivisionMarkdownNode extends MarkdownNode {
     return html;
   }
 
+  asPlainText(context) {
+    const secondMarkdownNode = this.getSecondMarkdownNode(),
+          plainText = secondMarkdownNode.asPlainText(context);
+
+    return plainText;
+  }
+
   createDOMElement(context) {
-    const domElement = null,
-          secondMarkdownNode = this.getSecondMarkdownNode();
+    const secondMarkdownNode = this.getSecondMarkdownNode(),
+          domElement = null;
 
     secondMarkdownNode.createDOMElement(context);
 
@@ -69,5 +79,18 @@ export default class SubDivisionMarkdownNode extends MarkdownNode {
     return secondMarkdownNode;
   }
 
+  static fromAnchorMarkdownNode(anchorMarkdownNode) {
+    const ruleName = SUB_DIVISION_RULE_NAME,
+          verticalSpaceMarkdownNode = VerticalSpaceMarkdownNode.fromNothing(),
+          childNodes = [
+            verticalSpaceMarkdownNode,
+            anchorMarkdownNode
+          ],
+          opacity = null,
+          subDivisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(SubDivisionMarkdownNode, ruleName, childNodes, opacity);
+
+    return subDivisionMarkdownNode;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(SubDivisionMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/verticalSpace.js

@@ -1,8 +1,11 @@
 "use strict";
 
+import { StartOfContentNode } from "occam-parsers";
+
 import MarkdownNode from "../../node/markdown";
 
 import { CARRIAGE_RETURN } from "../../constants";
+import { VERTICAL_SPACE_RULE_NAME } from "../../ruleNames";
 
 export default class VerticalSpaceMarkdownNode extends MarkdownNode {
   asHTML(indent, context) {
@@ -21,5 +24,17 @@ export default class VerticalSpaceMarkdownNode extends MarkdownNode {
     return domElement;
   }
 
+  static fromNothing() {
+    const startOfContentNode = StartOfContentNode.fromNothing(),
+          ruleName = VERTICAL_SPACE_RULE_NAME,
+          childNodes = [
+            startOfContentNode
+          ],
+          opacity = null,
+          verticalSpaceMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(VerticalSpaceMarkdownNode, ruleName, childNodes, opacity);
+
+    return verticalSpaceMarkdownNode;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(VerticalSpaceMarkdownNode, ruleName, childNodes, opacity); }
 }