highmark-markdown 0.0.404 → 0.0.406

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/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

@@ -26,9 +26,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) {

package/src/node/markdown/tableCell.js

@@ -24,12 +24,11 @@ export default class TableCellMarkdownNode extends MarkdownNode {
 
     lineMarkdownNode.createDOMElement(context);
 
-    const domElements = lineMarkdownNode.getDOMElements(),
-          parentDOMElement = domElement;  ///
+    const parentDOMElement = domElement;  ///
 
-    domElements.forEach((domElement) => {
-      parentDOMElement.appendChild(domElement)
-    });
+    domElement = lineMarkdownNode.getDOMElement();
+
+    parentDOMElement.appendChild(domElement)
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(TableCellMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown.js

@@ -102,72 +102,19 @@ class MarkdownNode extends NonTerminalNode {
     return attributeValue;
   }
 
-  resolveIncludes(context) {
-    const childNodes = this.getChildNodes();
-
-    childNodes.forEach((childNode) => {
-      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-      if (childNodeNonTerminalNode) {
-        const nonTerminalNode = childNode,  ///
-              markdownNode = nonTerminalNode; ///
-
-        markdownNode.resolveIncludes(context);
-      }
-    });
-  }
-
-  resolveEmbeddings(context) {
-    const childNodes = this.getChildNodes();
-
-    childNodes.forEach((childNode) => {
-      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-      if (childNodeNonTerminalNode) {
-        const nonTerminalNode = childNode,  ///
-              markdownNode = nonTerminalNode; ///
-
-        markdownNode.resolveEmbeddings(context);
-      }
-    });
-  }
-
-  retrieveParentNode(childNode, node = this) {
-    let parentNode = null;
-
-    const nodeNonTerminalNode = node.isNonTerminalNode();
-
-    if (nodeNonTerminalNode) {
-      const nonTerminalNode = node, ///
-            childNodes = nonTerminalNode.getChildNodes(),
-            index = childNodes.indexOf(childNode);
-
-      if (index !== -1) {
-        parentNode = node;  ///
-      } else {
-        const nodes = childNodes; ///
-
-        nodes.some((node) => {
-          parentNode = this.retrieveParentNode(childNode, node);
+  isPlainTextMarkdownNode() {
+    const plainTextMarkdownNode = false;
 
-          if (parentNode !== null) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return parentNode;
+    return plainTextMarkdownNode;
   }
 
   lines(context) {
     const childNodes = this.getChildNodes(),
           lines = childNodes.reduce((lines, childNode) => {
-            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+            const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
-            if (childNodeNonTerminalNode) {
-              const nonTerminalNode = childNode,  ///
-                    markdownNode = nonTerminalNode, ///
+            if (childNodeMarkdownNode) {
+              const markdownNode = childNode, ///
                     markdownNodeLines = markdownNode.lines(context);
 
               lines += markdownNodeLines;
@@ -214,11 +161,10 @@ ${childNodesHTML}${indent}${closingTag}
   childNodesAsHTML(indent, context) {
     const childNodes = this.getChildNodes(),
           childNodesHTML = childNodes.reduce((childNodesHTML, childNode) => {
-            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+            const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
-            if (childNodeNonTerminalNode) {
-              const nonTerminalNode = childNode,  ///
-                    markdownNode = nonTerminalNode, ///
+            if (childNodeMarkdownNode) {
+              const markdownNode = childNode, ///
                     markdownNodeHTML = markdownNode.asHTML(indent, context);
 
               if (markdownNodeHTML !== null) {
@@ -268,19 +214,18 @@ ${childNodesHTML}${indent}${closingTag}
     const childNodes = this.getChildNodes();
 
     childNodes.forEach((childNode) => {
-      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+      const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
-      if (childNodeNonTerminalNode) {
-        const nonTerminalNode = childNode,  ///
-              markdownNode = nonTerminalNode; ///
+      if (childNodeMarkdownNode) {
+        const markdownNode = childNode; ///
 
         markdownNode.createDOMElement(context);
 
-        const domElements = markdownNode.getDOMElements();
+        const domElement = markdownNode.getDOMElement();
 
-        domElements.forEach((domElement) => {
+        if (domElement !== null) {
           this.addDOMElement(domElement);
-        });
+        }
       }
     });
   }

package/src/replacement/contentsItem.js

@@ -5,7 +5,12 @@ import ContentsLinkReplacement from "../replacement/contentsLink";
 import ContentsItemMarkdownNode from "../node/markdown/contentsItem";
 
 export default class ContentsItemReplacement extends Replacement {
-  static fromNodeAndTokens(node, tokens) { return Replacement.fromNodeAndTokens(ContentsItemReplacement, node, tokens); }
+  getContentsItemMarkdownNode() {
+    const node = this.getNode(),
+          contentsItemMarkdownNode = node;  ///
+
+    return contentsItemMarkdownNode;
+  }
 
   static fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context) {
     const replacements = [],
@@ -42,7 +47,7 @@ export default class ContentsItemReplacement extends Replacement {
       replacement.getTokens(tokens);
     });
 
-    const contentsItemReplacement = ContentsItemReplacement.fromNodeAndTokens(node, tokens);
+    const contentsItemReplacement = Replacement.fromNodeAndTokens(ContentsItemReplacement, node, tokens);
 
     return contentsItemReplacement;
   }

package/src/replacement/contentsLink.js

@@ -5,8 +5,6 @@ import LineReplacement from "../replacement/line";
 import ContentsLinkMarkdownNode from "../node/markdown/contentsLink";
 
 export default class ContentsLinkReplacement extends Replacement {
-  static fromNodeAndTokens(node, tokens) { return super.fromNodeAndTokens(ContentsLinkReplacement, node, tokens); }
-
   static fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context) {
     let contentsLinkReplacement = null;
 
@@ -21,7 +19,7 @@ export default class ContentsLinkReplacement extends Replacement {
             node = contentsLinkMarkdownNode,  ///
             tokens = lineReplacement.getTokens();
 
-      contentsLinkReplacement = ContentsLinkReplacement.fromNodeAndTokens(node, tokens);
+      contentsLinkReplacement = Replacement.fromNodeAndTokens(ContentsLinkReplacement, node, tokens);
     }
 
     return contentsLinkReplacement;

package/src/replacement/contentsList.js

@@ -13,15 +13,13 @@ const { filter } = arrayUtilities;
 
 export default class ContentsListReplacement extends Replacement {
   replaceContentsDirectiveSubdivisionReplacement(contentsDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
-    const contentsDirectiveSubDivisionReplacementRemovedNode = contentsDirectiveSubDivisionReplacement.getRemovedNode(),
-          replacedNode = contentsDirectiveSubDivisionReplacementRemovedNode, ///
+    const subDivisionMarkdownNode = contentsDirectiveSubDivisionReplacement.getSubDivisionMarkdownNode(),
+          replacedNode = subDivisionMarkdownNode, ///
           parentNode = divisionMarkdownNode;  ///
 
     super.replace(replacedNode, parentNode, context)
   }
 
-  static fromNodeAndTokens(node, tokens) { return Replacement.fromNodeAndTokens(ContentsListReplacement, node, tokens); }
-
   static fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
     const contentsItemReplacements = contentsItemReplacementsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
           contentsListMarkdownNode = ContentsListMarkdownNode.fromContentsItemReplacements(contentsItemReplacements),
@@ -32,7 +30,7 @@ export default class ContentsListReplacement extends Replacement {
       contentsItemReplacement.getTokens(tokens);
     });
 
-    const contentsListReplacement = ContentsListReplacement.fromNodeAndTokens(node, tokens);
+    const contentsListReplacement = Replacement.fromNodeAndTokens(ContentsListReplacement, node, tokens);
 
     return contentsListReplacement;
   }
@@ -54,7 +52,7 @@ export default class ContentsListReplacement extends Replacement {
         contentsItemReplacement.getTokens(tokens);
       });
 
-      contentsListReplacement = ContentsListReplacement.fromNodeAndTokens(node, tokens);
+      contentsListReplacement = Replacement.fromNodeAndTokens(ContentsListReplacement, node, tokens);
     }
 
     return contentsListReplacement;

package/src/replacement/embedDirective.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import { subDivisionMarkdownNodesFromNode } from "../utilities/query";
+
+export default class EmbedDirectiveReplacement extends Replacement {
+  addAfterSubDivisionMarkdownNode(subDivisionMarkdownNode, divisionMarkdownNode, subDivisionMarkdownNodes, context) {
+    const existingNode = subDivisionMarkdownNode, ///
+          parentNode = divisionMarkdownNode;  ///
+
+    super.addAfter(existingNode, parentNode, context);
+
+    divisionMarkdownNode = this.getDivisionMarkdownNode();  ///
+
+    const node = divisionMarkdownNode;  ///
+
+    subDivisionMarkdownNodesFromNode(node, subDivisionMarkdownNodes);
+  }
+
+  getDivisionMarkdownNode() {
+    const node = this.getNode(),
+          divisionMarkdownNode = node;  ///
+
+    return divisionMarkdownNode;
+  }
+
+  static fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens) {
+    const node = divisionMarkdownNode,  ///
+          embedDirectiveReplacement = Replacement.fromNodeAndTokens(EmbedDirectiveReplacement, node, tokens);
+
+    return embedDirectiveReplacement;
+  }
+}

package/src/replacement/footnote.js

@@ -5,11 +5,48 @@ import Replacement from "../replacement";
 import { footnoteMarkdownNodeFromNode } from "../utilities/query";
 
 export default class FootnoteReplacement extends Replacement {
+  constructor(node, tokens, number) {
+    super(node, tokens);
+
+    this.number = number;
+  }
+
+  getNumber() {
+    return this.number;
+  }
+
+  setNumber(number) {
+    this.number = number;
+  }
+
+  isNumbered() {
+    const numbered = (this.number !== null);
+
+    return numbered;
+  }
+
+  isUnnumbered() {
+    const numbered = this.isNumbered(),
+          unnumbered = !numbered;
+
+    return unnumbered;
+  }
+
+  getFootnoteMarkdownNode() {
+    const node = this.getNode(),
+          footnoteMarkdownNode = node;  ///
+
+    return footnoteMarkdownNode;
+  }
+
+  static fromNode(node, context, ...remainingArguments) { return Replacement.fromNode(FootnoteReplacement, node, context, ...remainingArguments); }
+
   static fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement) {
     const node = footnoteSubDivisionReplacement.getNode(),
           footnoteMarkdownNode = footnoteMarkdownNodeFromNode(node),
           descendentNode = footnoteMarkdownNode,  ///
-          footnoteReplacement = footnoteSubDivisionReplacement.contract(FootnoteReplacement, descendentNode);
+          number = null,
+          footnoteReplacement = footnoteSubDivisionReplacement.contract(FootnoteReplacement, descendentNode, number);
 
     return footnoteReplacement;
   }