highmark-markdown 0.0.405 → 0.0.407

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,80 +102,34 @@ 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; ///
+  isPlainTextMarkdownNode() {
+    const plainTextMarkdownNode = false;
 
-        markdownNode.resolveIncludes(context);
-      }
-    });
+    return plainTextMarkdownNode;
   }
 
-  resolveEmbeddings(context) {
-    const childNodes = this.getChildNodes();
-
-    childNodes.forEach((childNode) => {
-      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-      if (childNodeNonTerminalNode) {
-        const nonTerminalNode = childNode,  ///
-              markdownNode = nonTerminalNode; ///
-
-        markdownNode.resolveEmbeddings(context);
-      }
-    });
-  }
+  lines(context) {
+    let lines;
 
-  retrieveParentNode(childNode, node = this) {
-    let parentNode = null;
+    ({ lines = null } = this.constructor);
 
-    const nodeNonTerminalNode = node.isNonTerminalNode();
+    if (lines === null) {
+      const childNodes = this.getChildNodes();
 
-    if (nodeNonTerminalNode) {
-      const nonTerminalNode = node, ///
-            childNodes = nonTerminalNode.getChildNodes(),
-            index = childNodes.indexOf(childNode);
+      lines = childNodes.reduce((lines, childNode) => {
+        const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
-      if (index !== -1) {
-        parentNode = node;  ///
-      } else {
-        const nodes = childNodes; ///
+        if (childNodeMarkdownNode) {
+          const markdownNode = childNode, ///
+                markdownNodeLines = markdownNode.lines(context);
 
-        nodes.some((node) => {
-          parentNode = this.retrieveParentNode(childNode, node);
+          lines += markdownNodeLines;
+        }
 
-          if (parentNode !== null) {
-            return true;
-          }
-        });
-      }
+        return lines;
+      }, 0);
     }
 
-    return parentNode;
-  }
-
-  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;
   }
 
@@ -214,11 +168,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 +221,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;
   }

package/src/replacement/footnotesItem.js

@@ -1,37 +1,24 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import Replacement from "../replacement";
 
 import FootnotesItemMarkdownNode from "../node/markdown/footnotesItem";
 
-const { extract } = arrayUtilities;
-
 export default class FootnotesItemReplacement extends Replacement {
-  static fromNode(node, context) { return Replacement.fromNode(FootnotesItemReplacement, node, context); }
-
-  static fromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context) {
-    let footnotesItemReplacement = null;
+  getFootnotesItemMarkdownNode() {
+    const node = this.getNode(),
+          footnotesItemMarkdownNode = node; ///
 
-    const footnoteReplacement = extract(footnoteReplacements, (footnoteReplacement) => {
-      const node = footnoteReplacement.getNode(),
-            footnoteMarkdownNode = node,  ///
-            footnoteMarkdownNodeIdentifier = footnoteMarkdownNode.identifier(context);
+    return footnotesItemMarkdownNode;
+  }
 
-      if (footnoteMarkdownNodeIdentifier === identifier) {
-        return true;
-      }
-    }) || null;
+  static fromNode(node, context) { return Replacement.fromNode(FootnotesItemReplacement, node, context); }
 
-    if (footnoteReplacement !== null) {
-      const node = footnoteReplacement.getNode(),
-            footnoteMarkdownNode = node,  ///
+  static fromFootnoteReplacementAndIdentifier(footnoteReplacement, identifier) {
+      const footnoteMarkdownNode = footnoteReplacement.getFootnoteMarkdownNode(),
             footnotesItemMarkdownNode = FootnotesItemMarkdownNode.fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier),
-            ascendantNode = footnotesItemMarkdownNode; ///
-
-      footnotesItemReplacement = footnoteReplacement.expand(FootnotesItemReplacement, ascendantNode);
-    }
+            ascendantNode = footnotesItemMarkdownNode, ///
+            footnotesItemReplacement = footnoteReplacement.expand(FootnotesItemReplacement, ascendantNode);
 
     return footnotesItemReplacement;
   }

package/src/replacement/footnotesList.js

@@ -13,43 +13,36 @@ export default class FootnotesListReplacement extends Replacement {
     super.appendTo(parentNode, context);
   }
 
-  static fromNodeAndTokens(node, tokens) { return Replacement.fromNodeAndTokens(FootnotesListReplacement, node, tokens); }
-
-  static fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context) {
+  static fromDivisionMarkdownNodeAndFootnoteMap(divisionMarkdownNode, footnoteMap, context) {
     let footnotesListReplacement = null;
 
-    const { footnoteNumberMap } = context;
-
     const node = divisionMarkdownNode,  ///
-          footnoteNumbers = Object.values(footnoteNumberMap),
+          start = startFromFootnoteMap(footnoteMap),
           linkMarkdownNodes = linkMarkdownNodesFromNode(node),
-          footnoteNumbersLength = footnoteNumbers.length,
           footnotesItemReplacements = [];
 
-    let count = 0;
+    let number = start;
 
     linkMarkdownNodes.forEach((linkMarkdownNode) => {
-      const identifier = linkMarkdownNode.identifier(context);
+      const identifier = linkMarkdownNode.identifier(context),
+            footnoteReplacement = footnoteMap[identifier] || null;
 
-      let footnoteNumber = footnoteNumberMap[identifier] || null;
+      if (footnoteReplacement !== null) {
+        const footnoteReplacementUnnumbered = footnoteReplacement.isUnnumbered();
 
-      if (footnoteNumber === null) {
-        const footnotesItemReplacement = FootnotesItemReplacement.fromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context);
+        if (footnoteReplacementUnnumbered) {
+          const footnotesItemReplacement = FootnotesItemReplacement.fromFootnoteReplacementAndIdentifier(footnoteReplacement, identifier, context);
 
-        if (footnotesItemReplacement !== null) {
           footnotesItemReplacements.push(footnotesItemReplacement);
 
-          count++;
+          footnoteReplacement.setNumber(number);
 
-          footnoteNumber = footnoteNumbersLength + count;
-
-          footnoteNumberMap[identifier] = footnoteNumber;
+          number++;
         }
       }
     });
 
-    const start = footnoteNumbersLength + 1,
-          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start);
+    const footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start);
 
     if (footnotesListMarkdownNode !== null) {
       const node = footnotesListMarkdownNode, ///
@@ -59,9 +52,24 @@ export default class FootnotesListReplacement extends Replacement {
         footnotesItemReplacement.getTokens(tokens);
       });
 
-      footnotesListReplacement = FootnotesListReplacement.fromNodeAndTokens(node, tokens);
+      footnotesListReplacement = Replacement.fromNodeAndTokens(FootnotesListReplacement, node, tokens);
     }
 
     return footnotesListReplacement;
   }
 }
+
+function startFromFootnoteMap(footnoteMap) {
+  const footnoteReplacements = Object.values(footnoteMap),  ///
+        numberedFootnoteReplacements = footnoteReplacements.filter((footnoteReplacement) => {
+          const footnoteReplacementNumbered = footnoteReplacement.isNumbered();
+
+          if (footnoteReplacementNumbered) {
+            return true;
+          }
+        }),
+        numberedFootnoteReplacementsLength = numberedFootnoteReplacements.length,
+        start = numberedFootnoteReplacementsLength + 1;
+
+  return start;
+}

package/src/replacement/includeDirective.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import { subDivisionMarkdownNodesFromNode } from "../utilities/query";
+
+export default class IncludeDirectiveReplacement extends Replacement {
+  addDivisionMarkdownNode(context) {
+    const divisionMarkdownNode = this.getDivisionMarkdownNode(),
+          ignored = divisionMarkdownNode.isIgnored();
+
+    if (!ignored) {
+      const { divisionMarkdownNodes } = context;
+
+      divisionMarkdownNodes.push(divisionMarkdownNode);
+
+      let tokens = this.getTokens();
+
+      const includedTokens = tokens; ///
+
+      ({ tokens } = context);
+
+      const tokensLength = tokens.length,
+            start = tokensLength, ///
+            deleteCount = 0;
+
+      tokens.splice(start, deleteCount, ...includedTokens);
+    }
+
+    const node = divisionMarkdownNode,  ///
+          subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node);
+
+    return subDivisionMarkdownNodes;
+  }
+
+  getDivisionMarkdownNode() {
+    const node = this.getNode(),
+          divisionMarkdownNode = node;  ///
+
+    return divisionMarkdownNode;
+  }
+
+  static fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens) {
+    const node = divisionMarkdownNode,  ///
+          includeDirectiveReplacement = Replacement.fromNodeAndTokens(IncludeDirectiveReplacement, node, tokens);
+
+    return includeDirectiveReplacement;
+  }
+}

package/src/replacement/line.js

@@ -3,11 +3,16 @@
 import Replacement from "../replacement";
 
 export default class LineReplacement extends Replacement {
-  static fromNode(node, context) { return Replacement.fromNode(LineReplacement, node, context); }
+  getLineMarkdownNode() {
+    const node = this.getNode(),
+          lineMarkdownNode = node;  ///
+
+    return lineMarkdownNode;
+  }
 
   static fromLineMarkdownNode(lineMarkdownNode, context) {
     const node = lineMarkdownNode,  ///
-          lineReplacement = LineReplacement.fromNode(node, context);
+          lineReplacement = Replacement.fromNode(LineReplacement, node, context);
 
     return lineReplacement;
   }

package/src/replacement/subDivision/embedDirectives.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import SubDivisionReplacement from "../../replacement/subDivision";
+
+import { embedDirectiveMarkdownNodesFromNode } from "../../utilities/query";
+
+const { backwardsForEach } = arrayUtilities;
+
+export default class EmbedDirectivesSubDivisionReplacement extends SubDivisionReplacement {
+  constructor(node, tokens, subDivisionMarkdownNode, embedDirectiveMarkdownNodes) {
+    super(node, tokens, subDivisionMarkdownNode);
+
+    this.embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodes;
+  }
+
+  getEmbedDirectiveMarkdownNodes() {
+    return this.embedDirectiveMarkdownNodes;
+  }
+
+  replaceSubDivisionMarkdownNode(divisionMarkdownNode, context) {
+    const subDivisionMarkdownNodes = [],
+          subDivisionMarkdownNode = this.getSubDivisionMarkdownNode();
+
+    backwardsForEach(this.embedDirectiveMarkdownNodes, (embedDirectiveMarkdownNode) => {
+      const embedDirectiveReplacement = embedDirectiveMarkdownNode.resolve(context);
+
+      if (embedDirectiveReplacement !== null) {
+        embedDirectiveReplacement.addAfterSubDivisionMarkdownNode(subDivisionMarkdownNode, divisionMarkdownNode, subDivisionMarkdownNodes, context);
+      }
+    });
+
+    this.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+
+    return subDivisionMarkdownNodes;
+  }
+
+  static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
+    let embedDirectivesSubDivisionReplacement = null;
+
+    const node = subDivisionMarkdownNode, ///
+          embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodesFromNode(node),
+          embedDirectiveMarkdownNodesLength = embedDirectiveMarkdownNodes.length;
+
+    if (embedDirectiveMarkdownNodesLength > 0) {
+      embedDirectivesSubDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(EmbedDirectivesSubDivisionReplacement, subDivisionMarkdownNode, context, embedDirectiveMarkdownNodes);
+    }
+
+    return embedDirectivesSubDivisionReplacement;
+  }
+}

package/src/replacement/subDivision/footnote.js

@@ -5,6 +5,15 @@ import SubDivisionReplacement from "../../replacement/subDivision";
 import { footnoteMarkdownNodeFromNode } from "../../utilities/query";
 
 export default class FootnoteSubDivisionReplacement extends SubDivisionReplacement {
+  identifier(context) {
+    const subDivisionMarkdownNode = this.getSubDivisionMarkdownNode(),
+          node = subDivisionMarkdownNode, ///
+          footnoteMarkdownNode = footnoteMarkdownNodeFromNode(node),
+          identifier = footnoteMarkdownNode.identifier(context);
+
+    return identifier;
+  }
+
   static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
     let footnoteSubDivisionReplacement = null;
 

package/src/replacement/subDivision/footnotesDirective.js

@@ -5,6 +5,12 @@ import SubDivisionReplacement from "../../replacement/subDivision";
 import { footnotesDirectiveMarkdownNodeFromNode } from "../../utilities/query";
 
 export default class FootnotesDirectiveSubDivisionReplacement extends SubDivisionReplacement {
+  appendToDivisionMarkdownNode(divisionMarkdownNode, context) {
+    const parentNode = divisionMarkdownNode;  ///
+
+    super.appendTo(parentNode, context);
+  }
+
   static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
     let footnotesDirectiveSubDivisionReplacement = null;
 

package/src/replacement/subDivision/includeDirectives.js

@@ -0,0 +1,58 @@
+"use strict";
+
+import SubDivisionReplacement from "../../replacement/subDivision";
+
+import { includeDirectiveMarkdownNodesFromNode } from "../../utilities/query";
+
+export default class IncludeDirectivesSubDivisionReplacement extends SubDivisionReplacement {
+  constructor(node, tokens, subDivisionMarkdownNode, includeDirectiveMarkdownNodes) {
+    super(node, tokens, subDivisionMarkdownNode);
+
+    this.includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodes;
+  }
+
+  getIncludeDirectiveMarkdownNodes() {
+    return this.includeDirectiveMarkdownNodes;
+  }
+
+  removeFromDivisionMarkdownNode(divisionMarkdownNode, context) {
+    const ignored = divisionMarkdownNode.isIgnored();
+
+    if (ignored) {
+      return;
+    }
+
+    super.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+  }
+
+  removeSubDivisionMarkdownNode(divisionMarkdownNode, context) {
+    this.includeDirectiveMarkdownNodes.forEach((includeDirectiveMarkdownNode) => {
+      const includeDirectiveReplacement = includeDirectiveMarkdownNode.resolve(context);
+
+      if (includeDirectiveReplacement !== null) {
+        const divisionMarkdownNode = includeDirectiveReplacement.getDivisionMarkdownNode(),
+              subDivisionMarkdownNodes = includeDirectiveReplacement.addDivisionMarkdownNode(context);
+
+        subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
+          subDivisionMarkdownNode.resolveIncludes(divisionMarkdownNode, context);
+        });
+      }
+    });
+
+    this.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+  }
+
+  static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
+    let includeDirectivesSubDivisionReplacement = null;
+
+    const node = subDivisionMarkdownNode, ///
+          includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodesFromNode(node),
+          includeDirectiveMarkdownNodesLength = includeDirectiveMarkdownNodes.length;
+
+    if (includeDirectiveMarkdownNodesLength > 0) {
+      includeDirectivesSubDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(IncludeDirectivesSubDivisionReplacement, subDivisionMarkdownNode, context, includeDirectiveMarkdownNodes);
+    }
+
+    return includeDirectivesSubDivisionReplacement;
+  }
+}