highmark-markdown 0.0.405 → 0.0.407

package/src/node/markdown/blockListingEnd.js

@@ -3,5 +3,7 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class BlockListingEndMarkdownNode extends MarkdownNode {
+  static lines = 1;
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(BlockListingEndMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/blockListingStart.js

@@ -24,5 +24,7 @@ export default class BlockListingStartMarkdownNode extends MarkdownNode {
     return className;
   }
 
+  static lines = 1;
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(BlockListingStartMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/contentsLink.js

@@ -31,8 +31,7 @@ export default class ContentsLinkMarkdownNode extends MarkdownNode {
   clone() { return super.clone(this.identifier); }
 
   static fromLineReplacementAndIdentifier(lineReplacement, identifier) {
-      const lineReplacementNode = lineReplacement.getNode(),
-            lineMarkdownNode = lineReplacementNode, ///
+      const lineMarkdownNode = lineReplacement.getLineMarkdownNode(),
             ruleName = CONTENTS_LINK_RULE_NAME,
             childNodes = [
               lineMarkdownNode

package/src/node/markdown/contentsList.js

@@ -8,7 +8,7 @@ export default class ContentsListMarkdownNode extends MarkdownNode {
   static fromContentsItemReplacements(contentsItemReplacements) {
     const ruleName = CONTENTS_LIST_RULE_NAME,
           childNodes = contentsItemReplacements.map((contentsItemReplacement) => {
-            const contentsItemReplacementNode = contentsItemReplacement.getNode(),
+            const contentsItemReplacementNode = contentsItemReplacement.getContentsItemMarkdownNode(),
                   childNode = contentsItemReplacementNode;  ///
 
             return childNode;

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

@@ -2,38 +2,35 @@
 
 import { arrayUtilities } from "necessary";
 
-import ImportedReplacement from "../../../replacement/imported";
 import DirectiveMarkdownNode from "../../../node/markdown/directive";
+import EmbedDirectiveReplacement from "../../../replacement/embedDirective";
 
 const { last } = arrayUtilities;
 
 export default class EmbedDirectiveMarkdownNode extends DirectiveMarkdownNode {
-  import(context) {
-    let importedReplacement = null;
+  resolve(context) {
+    let embedDirectiveReplacement = null;
 
-    const { importer = null } = context;
+    const { importer } = context;
 
-    if (importer !== null) {
-      const filePath = this.filePath(context);
+    const filePath = this.filePath(context);
 
-      importer(filePath, context);
+    importer(filePath, context);
 
-      const { importedNode = null,
-              importedTokens = null } = context;
+    const { importedNode = null,
+            importedTokens = null } = context;
 
-      if (importedNode !== null) {
-        const node = importedNode,  ///
-              tokens = importedTokens;  ///
+    if (importedNode !== null) {
+      delete context.importedNode;
+      delete context.importedTokens;
 
-        importedReplacement = ImportedReplacement.fromNodeAndTokens(node, tokens);
+      const divisionMarkdownNode = importedNode,  ///
+            tokens = importedTokens;  ///
 
-        delete context.importedNode;
-        delete context.importedTokens;
-        delete context.importedClassName;
-      }
+      embedDirectiveReplacement = EmbedDirectiveReplacement.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
     }
 
-    return importedReplacement;
+    return embedDirectiveReplacement;
   }
 
   filePath(context) {

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

@@ -3,47 +3,39 @@
 import { arrayUtilities } from "necessary";
 
 import DirectiveMarkdownNode from "../../../node/markdown/directive";
+import IncludeDirectiveReplacement from "../../../replacement/includeDirective";
 
-const { push, last } = arrayUtilities;
+const { last } = arrayUtilities;
 
 export default class IncludeDirectiveMarkdownNode extends DirectiveMarkdownNode {
-  resolveIncludes(context) {
-    let html = null;
+  resolve(context) {
+    let includeDirectiveReplacement = null;
 
-    const { importer = null } = context;
+    const { importer } = context;
 
-    if (importer !== null) {
-      const filePath = this.filePath(context);
+    const filePath = this.filePath(context);
 
-      importer(filePath, context);
+    importer(filePath, context);
 
-      const { importedNode = null,
-              importedTokens = null,
-              importedClassName = null } = context;
+    const { importedNode = null,
+          importedTokens = null,
+          importedClassName = null } = context;
 
-      if (importedNode !== null) {
-        delete context.importedNode;
-        delete context.importedTokens;
-        delete context.importedClassName;
+    if (importedNode !== null) {
+      delete context.importedNode;
+      delete context.importedTokens;
+      delete context.importedClassName;
 
-        const { tokens, divisionMarkdownNodes } = context,
-              divisionMarkdownNode = importedNode,  ///
-              divisionClassName = importedClassName,  ///
-              ignored = divisionMarkdownNode.isIgnored();
+      const divisionMarkdownNode = importedNode,  ///
+            divisionClassName = importedClassName,  ///
+            tokens = importedTokens;  ///
 
-        divisionMarkdownNode.setDivisionClassName(divisionClassName);
+      divisionMarkdownNode.setDivisionClassName(divisionClassName);
 
-        if (!ignored) {
-          push(tokens, importedTokens);
-
-          divisionMarkdownNodes.push(divisionMarkdownNode);
-        }
-
-        divisionMarkdownNode.resolveIncludes(context);
-      }
+      includeDirectiveReplacement = IncludeDirectiveReplacement.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
     }
 
-    return html;
+    return includeDirectiveReplacement;
   }
 
   filePath(context) {

package/src/node/markdown/directive.js

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

package/src/node/markdown/directives.js

@@ -4,75 +4,38 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 
-const { clear, first, push } = arrayUtilities;
+const { first } = arrayUtilities;
 
 export default class DirectivesMarkdownNode extends MarkdownNode {
-  constructor(ruleName, childNodes, opacity, precedence, domElement, domElements) {
-    super(ruleName, childNodes, opacity, precedence, domElement);
-
-    this.domElements = domElements;
-  }
-
   getDOMElement() {
-    let domElement = null;
-
-    const domElementsLength = this.domElements.length;
-
-    if (domElementsLength > 0) {
-      const firstDOMElement = first(this.domElements);
-
-      domElement = firstDOMElement; ///
-    }
+    const directiveMarkdownNode = this.getDirectiveMarkdownNode(),
+          directiveMarkdownNodeDOMElement = directiveMarkdownNode.getDOMElement(),
+          domElement = directiveMarkdownNodeDOMElement; ///
 
     return domElement;
   }
 
-  getDOMElements() {
-    return this.domElements;
-  }
-
   asHTML(indent, context) {
-    const childNodesHTML = this.childNodesAsHTML(indent, context),
-          html = childNodesHTML;  ///
+    const directiveMarkdownNode = this.getDirectiveMarkdownNode(),
+          directiveMarkdownNodeHTML = directiveMarkdownNode.asHTML(indent, context),
+          html = directiveMarkdownNodeHTML;  ///
 
     return html;
   }
 
   createDOMElement(context) {
-    const domElement = null,
-          childNodes = this.getChildNodes();
-
-    clear(this.domElements);
+    const directiveMarkdownNode = this.getDirectiveMarkdownNode();
 
-    childNodes.forEach((childNode) => {
-      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-      if (childNodeNonTerminalNode) {
-        const nonTerminalNode = childNode,  ///
-              markdownNode = nonTerminalNode; ///
-
-        markdownNode.createDOMElement(context);
-
-        const markdownNodeDOMElements = markdownNode.getDOMElements();
-
-        push(this.domElements, markdownNodeDOMElements);
-      }
-    });
-
-    return domElement;
+    directiveMarkdownNode.createDOMElement(context);
   }
 
-  clone() {
-    const domElements = [],
-          directivesMarkdownNode = super.clone(domElements);
+  getDirectiveMarkdownNode() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          directiveMarkdownNode = firstChildNode; ///
 
-    return directivesMarkdownNode;
+    return directiveMarkdownNode;
   }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
-    const domElements = [],
-          directivesMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DirectivesMarkdownNode, ruleName, childNodes, opacity, domElements);
-
-    return directivesMarkdownNode;
-  }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(DirectivesMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/division.js

@@ -14,12 +14,9 @@ import PageNumberDirectiveSubDivisionReplacement from "../../replacement/subDivi
 import { EMPTY_STRING } from "../../constants";
 import { DIVISION_RULE_NAME } from "../../ruleNames";
 import { renumberLinkMarkdownNodes } from "../../utilities/footnotes";
-import { subDivisionMarkdownNodesFromNode,
-         embedDirectiveMarkdownNodesFromNode,
-         ignoreDirectiveMarkdownNodeFromNode,
-         pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
+import { subDivisionMarkdownNodesFromNode, ignoreDirectiveMarkdownNodeFromNode, pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
 
-const { clear } = arrayUtilities;
+const { clear, filter } = arrayUtilities;
 
 export default class DivisionMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, precedence, opacity, domElement, divisionClassName) {
@@ -43,19 +40,30 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   }
 
   isIgnored() {
-    const node = this,
+    const node = this,  ///
           ignoreDirectiveMarkdownNode = ignoreDirectiveMarkdownNodeFromNode(node),
           ignored = (ignoreDirectiveMarkdownNode !== null);
 
     return ignored;
   }
 
-  paginate(context) {
+  paginate(paginatedDivisionMarkdownNodes, context) {
+    const footnotesDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionReplacement, context),
+          pageNumberDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(PageNumberDirectiveSubDivisionReplacement, context),
+          subDivisionReplacements = [
+            footnotesDirectiveSubDivisionReplacement,
+            pageNumberDirectiveSubDivisionReplacement
+          ];
+
+    filter(subDivisionReplacements, (subDivisionReplacement) => {
+      if (subDivisionReplacement !== null) {
+        return true;
+      }
+    });
+
     const { linesPerPage } = context,
-          childNodes = this.getChildNodes(),
           paginatedChildNodes = [],
-          divisionMarkdownNodes = [],
-          pageNumberDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(PageNumberDirectiveSubDivisionReplacement, context);
+          childNodes = this.getChildNodes();
 
     let totalLines = 0;
 
@@ -68,9 +76,10 @@ export default class DivisionMarkdownNode extends MarkdownNode {
       paginatedChildNodes.push(paginatedChildNode);
 
       if (totalLines > linesPerPage) {
-        const divisionMarkdownNode = DivisionMarkdownNode.fromPageNumberDirectiveSubDivisionReplacementPaginatedChildNodesAndDivisionClassName(pageNumberDirectiveSubDivisionReplacement, paginatedChildNodes, this.divisionClassName, context);
+        const divisionMarkdownNode = DivisionMarkdownNode.fromPaginatedChildNodesSubDivisionReplacementsAndDivisionClassName(paginatedChildNodes, subDivisionReplacements, this.divisionClassName, context),
+              paginatedDivisionMarkdownNode = divisionMarkdownNode; ///
 
-        divisionMarkdownNodes.push(divisionMarkdownNode);
+        paginatedDivisionMarkdownNodes.push(paginatedDivisionMarkdownNode);
 
         clear(paginatedChildNodes);
 
@@ -79,21 +88,26 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     });
 
     if (totalLines > 0) {
-      const divisionMarkdownNode = DivisionMarkdownNode.fromPageNumberDirectiveSubDivisionReplacementPaginatedChildNodesAndDivisionClassName(pageNumberDirectiveSubDivisionReplacement, paginatedChildNodes, this.divisionClassName, context);
+      const divisionMarkdownNode = DivisionMarkdownNode.fromPaginatedChildNodesSubDivisionReplacementsAndDivisionClassName(paginatedChildNodes, subDivisionReplacements, this.divisionClassName, context),
+            paginatedDivisionMarkdownNode = divisionMarkdownNode; ///
 
-      divisionMarkdownNodes.push(divisionMarkdownNode);
+      paginatedDivisionMarkdownNodes.push(paginatedDivisionMarkdownNode);
     }
-
-    return divisionMarkdownNodes;
   }
 
   setPageNumber(pageNumber) {
-    const node = this,
-          pageNumberDirective = pageNumberDirectiveMarkdownNodeFromNode(node);
+    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
 
-    if (pageNumberDirective !== null) {
-      pageNumberDirective.setPageNumber(pageNumber);
-    }
+    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
+      const node = subDivisionMarkdownNode, ///
+            pageNumberDirective = pageNumberDirectiveMarkdownNodeFromNode(node);
+
+      if (pageNumberDirective !== null) {
+        pageNumberDirective.setPageNumber(pageNumber);
+
+        return true;
+      }
+    });
   }
 
   createContents(divisionMarkdownNodes, context) {
@@ -115,16 +129,18 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return contentsCreated;
   }
 
-  createFootnotes(footnoteReplacements, context) {
-    if (footnoteReplacements !== null) {
+  createFootnotes(footnoteMap, context) {
+    const footnotesDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionReplacement, context);
+
+    if (footnotesDirectiveSubDivisionReplacement !== null) {
       const divisionMarkdownNode = this,  ///
-            footnotesListReplacement = FootnotesListReplacement.fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context);
+            footnotesListReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteMap(divisionMarkdownNode, footnoteMap, context);
 
       if (footnotesListReplacement !== null) {
-        renumberLinkMarkdownNodes(divisionMarkdownNode, callback, context);
-
         footnotesListReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
       }
+
+      renumberLinkMarkdownNodes(divisionMarkdownNode, footnoteMap, callback, context);
     }
 
     function callback() {
@@ -132,33 +148,32 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     }
   }
 
-  prepareFootnotes(context) {
+  prepareFootnotes(footnoteMap, context) {
     const footnoteSubDivisionReplacements = this.removeSubDivisionMarkdownNodes(FootnoteSubDivisionReplacement, context);
 
-    let footnoteReplacements = footnoteReplacementsFromFootnoteSubDivisionReplacements(footnoteSubDivisionReplacements);
+    footnoteSubDivisionReplacements.forEach((footnoteSubDivisionReplacement) => {
+      const footnoteReplacement = FootnoteReplacement.fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement),
+            identifier = footnoteSubDivisionReplacement.identifier(context);
 
-    const footnotesDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionReplacement, context);
+      footnoteMap[identifier] = footnoteReplacement;
+    })
+  }
 
-    if (footnotesDirectiveSubDivisionReplacement === null) {
-      footnoteReplacements = null;
-    }
+  resolveIncludes(context) {
+    const divisionMarkdownNode = this,  ///
+          subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
 
-    return footnoteReplacements;
+    subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
+      subDivisionMarkdownNode.resolveIncludes(divisionMarkdownNode, context);
+    });
   }
 
   resolveEmbeddings(context) {
-    const node = this,  ///
-          embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodesFromNode(node);
-
-    embedDirectiveMarkdownNodes.map((embedDirectiveMarkdownNode) => {
-      const importedReplacement = embedDirectiveMarkdownNode.import(context);
+    const divisionMarkdownNode = this,  ///
+          subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
 
-      if (importedReplacement !== null) {
-        const childNode = embedDirectiveMarkdownNode,  ///
-              parentNode = this.retrieveParentNode(childNode);
-
-        importedReplacement.replaceEmbedDirectiveMarkdownNode(embedDirectiveMarkdownNode, parentNode, context);
-      }
+    subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
+      subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
     });
   }
 
@@ -205,7 +220,7 @@ export default class DivisionMarkdownNode extends MarkdownNode {
           subDivisionReplacement = this.findSubDivisionReplacement(SubDivisionReplacement, context);
 
     if (subDivisionReplacement !== null) {
-      subDivisionReplacement.removeFromMarkdownNode(divisionMarkdownNode, context);
+      subDivisionReplacement.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
     }
 
     return subDivisionReplacement;
@@ -216,20 +231,20 @@ export default class DivisionMarkdownNode extends MarkdownNode {
           subDivisionReplacements = this.findSubDivisionReplacements(SubDivisionReplacement, context);
 
     subDivisionReplacements.forEach((subDivisionReplacement) => {
-      subDivisionReplacement.removeFromMarkdownNode(divisionMarkdownNode, context);
+      subDivisionReplacement.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
     });
 
     return subDivisionReplacements;
   }
 
-  createFootnotesListReplacement(context) {
-    const footnoteSubDivisionReplacements = this.findSubDivisionReplacements(FootnoteSubDivisionReplacement, context),
-          footnoteReplacements = footnoteReplacementsFromFootnoteSubDivisionReplacements(footnoteSubDivisionReplacements),
-          divisionMarkdownNode = this,  ///
-          footnotesListReplacement = FootnotesListReplacement.fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context);
-
-    return footnotesListReplacement;
-  }
+  // createFootnotesListReplacement(context) {
+  //   const footnoteSubDivisionReplacements = this.findSubDivisionReplacements(FootnoteSubDivisionReplacement, context),
+  //         footnoteReplacements = footnoteReplacementsFromFootnoteSubDivisionReplacements(footnoteSubDivisionReplacements),
+  //         divisionMarkdownNode = this,  ///
+  //         footnotesListReplacement = FootnotesListReplacement.fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context);
+  //
+  //   return footnotesListReplacement;
+  // }
 
   asHTML(context) {
     let html = null;
@@ -258,7 +273,7 @@ ${childNodesHTML}${indent}${closingTag}
     return divisionMarkdownNode;
   }
 
-  static fromPageNumberDirectiveSubDivisionReplacementPaginatedChildNodesAndDivisionClassName(pageNumberDirectiveSubDivisionReplacement, paginatedChildNodes, divisionClassName, context) {
+  static fromPaginatedChildNodesSubDivisionReplacementsAndDivisionClassName(paginatedChildNodes, subDivisionReplacements, divisionClassName, context) {
     const ruleName = DIVISION_RULE_NAME,
           childNodes = [
             ...paginatedChildNodes
@@ -266,22 +281,12 @@ ${childNodesHTML}${indent}${closingTag}
           opacity = null,
           divisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity, divisionClassName);
 
-    if (pageNumberDirectiveSubDivisionReplacement !== null) {
-      pageNumberDirectiveSubDivisionReplacement = pageNumberDirectiveSubDivisionReplacement.clone();  ///
+    subDivisionReplacements.forEach((subDivisionReplacement) => {
+      subDivisionReplacement = subDivisionReplacement.clone();  ///
 
-      pageNumberDirectiveSubDivisionReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
-    }
+      subDivisionReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
+    });
 
     return divisionMarkdownNode;
   }
 }
-
-function footnoteReplacementsFromFootnoteSubDivisionReplacements(footnoteSubDivisionReplacements) {
-  const footnoteReplacements = footnoteSubDivisionReplacements.map((footnoteSubDivisionReplacement) => {
-    const footnoteReplacement = FootnoteReplacement.fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement);
-
-    return footnoteReplacement;
-  });
-
-  return footnoteReplacements;
-}

package/src/node/markdown/emailLink.js

@@ -10,12 +10,6 @@ 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,12 +5,6 @@ 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;
 
@@ -34,5 +28,7 @@ export default class EndOfLineMarkdownNode extends MarkdownNode {
     return domElement;
   }
 
+  static lines = 1;
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(EndOfLineMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/footnotesList.js

@@ -30,12 +30,6 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
 
   clone() { return super.clone(this.start); }
 
-  static fromDivisionMarkdownNode(divisionMarkdownNode, context) {
-    let footnotesListMarkdownNode = null;
-
-    return footnotesListMarkdownNode;
-  }
-
   static fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start) {
     let footnotesListMarkdownNode = null;
 
@@ -44,8 +38,8 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
     if (footnotesItemReplacementsLength > 0) {
       const ruleName = FOOTNOTES_LIST_RULE_NAME,
             childNodes = footnotesItemReplacements.map((footnotesItemReplacement) => {
-              const footnotesItemReplacementMode = footnotesItemReplacement.getNode(),
-                childNode = footnotesItemReplacementMode; ///
+              const footnotesItemReplacementMode = footnotesItemReplacement.getFootnotesItemMarkdownNode(),
+                    childNode = footnotesItemReplacementMode; ///
 
               return childNode;
             }),

package/src/node/markdown/heading.js

@@ -11,12 +11,6 @@ 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;
 
@@ -26,9 +20,9 @@ export default class HeadingMarkdownNode extends MarkdownNode {
   addAnchor(context) {
     const identifier = this.identifier(context),
           anchorMarkdownNode = AnchorMarkdownNode.fromIdentifier(identifier),
-          childNode = anchorMarkdownNode; ///
+          prependedChildNode = anchorMarkdownNode; ///
 
-    this.prependChildNode(childNode);
+    this.prependChildNode(prependedChildNode);
   }
 
   identifier(context) {

package/src/node/markdown/plainText.js

@@ -3,5 +3,11 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class PlainTextMarkdownNode extends MarkdownNode {
+  isPlainTextMarkdownNode() {
+    const plainTextMarkdownNode = true;
+
+    return plainTextMarkdownNode;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(PlainTextMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/subDivision.js

@@ -3,22 +3,39 @@
 import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
+import EmbedDirectivesSubDivisionReplacement from "../../replacement/subDivision/embedDirectives";
+import IncludeDirectivesSubDivisionReplacement from "../../replacement/subDivision/includeDirectives";
 
 const { second } = arrayUtilities;
 
 export default class SubDivisionMarkdownNode extends MarkdownNode {
-  getDOMElement() {
-    const secondMarkdownNode = this.getSecondMarkdownNode(),
-          domElement = secondMarkdownNode.getDOMElement();
+  resolveEmbeddings(divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = this, ///
+          embedDirectivesSubDivisionReplacement = EmbedDirectivesSubDivisionReplacement.fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context);
 
-    return domElement;
+    if (embedDirectivesSubDivisionReplacement !== null) {
+      const subDivisionMarkdownNodes = embedDirectivesSubDivisionReplacement.replaceSubDivisionMarkdownNode(divisionMarkdownNode, context);
+
+      subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
+        subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
+      });
+    }
   }
 
-  getDOMElements() {
+  resolveIncludes(divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = this, ///
+          includeDirectivesSubDivisionReplacement = IncludeDirectivesSubDivisionReplacement.fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context);
+
+    if (includeDirectivesSubDivisionReplacement !== null) {
+      includeDirectivesSubDivisionReplacement.removeSubDivisionMarkdownNode(divisionMarkdownNode, context);
+    }
+  }
+
+  getDOMElement() {
     const secondMarkdownNode = this.getSecondMarkdownNode(),
-          domElements = secondMarkdownNode.getDOMElements();
+          domElement = secondMarkdownNode.getDOMElement();
 
-    return domElements;
+    return domElement;
   }
 
   lines(context) {