highmark-markdown 0.0.404 → 0.0.406

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;
+  }
+}

package/src/replacement/subDivision.js

@@ -3,34 +3,33 @@
 import Replacement from "../replacement";
 
 export default class SubDivisionReplacement extends Replacement {
-  constructor(node, tokens, removedNode) {
+  constructor(node, tokens, subDivisionMarkdownNode) {
     super(node, tokens);
 
-    this.removedNode = removedNode;
+    this.subDivisionMarkdownNode = subDivisionMarkdownNode;
   }
 
-  getRemovedNode() {
-    return this.removedNode;
+  getSubDivisionMarkdownNode() {
+    return this.subDivisionMarkdownNode;
   }
 
-  removeFromMarkdownNode(divisionMarkdownNode, context) {
-    const childNode = this.removedNode, ///
-          parentNode = divisionMarkdownNode.retrieveParentNode(childNode);
+  removeFromDivisionMarkdownNode(divisionMarkdownNode, context) {
+    const removedNode = this.subDivisionMarkdownNode, ///
+          parentNode = divisionMarkdownNode;
 
-    super.removeFrom(this.removedNode, parentNode, context);
+    super.removeFrom(removedNode, parentNode, context);
   }
 
-  static fromNodeAndTokens(Class, node, tokens) {
-    const removedNode = null,
-          subDivisionReplacement = Replacement.fromNodeAndTokens(Class, node, tokens, removedNode);
+  static fromNodeAndTokens(Class, node, tokens, ...remainingArguments) {
+    const subDivisionMarkdownNode = null,
+          subDivisionReplacement = Replacement.fromNodeAndTokens(Class, node, tokens, subDivisionMarkdownNode, ...remainingArguments);
 
     return subDivisionReplacement;
   }
 
-  static fromSubDivisionMarkdownNode(Class, subDivisionMarkdownNode, context) {
+  static fromSubDivisionMarkdownNode(Class, subDivisionMarkdownNode, context, ...remainingArguments) {
     const node = subDivisionMarkdownNode, ///
-          removedNode = subDivisionMarkdownNode, ///
-          subDivisionReplacement = Replacement.fromNode(Class, node, context, removedNode);
+          subDivisionReplacement = Replacement.fromNode(Class, node, context, subDivisionMarkdownNode, ...remainingArguments);
 
     return subDivisionReplacement;
   }

package/src/replacement.js

@@ -3,7 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import { leadingIndexFromNodeAndTokens, trailingIndexFromNodeAndTokens } from "./utilities/node";
-import { removeNode, appendNode, removeTokens, appendTokens, replaceNode, replaceNodes, replaceTokens } from "./utilities/replacement";
+import { removeNode, appendNode, removeTokens, appendTokens, replaceNode, replaceNodes, replaceTokens, addNodesAfter, addTokensAfter } from "./utilities/replacement";
 
 const { push } = arrayUtilities;
 
@@ -25,7 +25,7 @@ export default class Replacement {
 
   getChildNodes() { return this.node.getChildNodes(); }
 
-  contract(Class, descendentNode) {
+  contract(Class, descendentNode, ...remainingArguments) {
     if (descendentNode === undefined) {
       descendentNode = Class; ///
 
@@ -37,12 +37,12 @@ export default class Replacement {
           context = { ///
             tokens
           },
-          replacement = Class.fromNode(node, context);  ///
+          replacement = Class.fromNode(node, context, ...remainingArguments);
 
     return replacement;
   }
 
-  expand(Class, ascendantNode) {
+  expand(Class, ascendantNode, ...remainingArguments) {
     if (ascendantNode === undefined) {
       ascendantNode = Class;
 
@@ -54,19 +54,29 @@ export default class Replacement {
           context = {
             tokens
           },
-          replacement = Class.fromNode(node, context);  ///
+          replacement = Class.fromNode(node, context, ...remainingArguments);
 
     return replacement;
   }
 
   appendTo(parentNode, context) {
     const { tokens } = context,
-          replacementNode = this.node,  ///
-          replacementTokens = this.tokens;  ///
+          appendedNode = this.node,  ///
+          appendedTokens = this.tokens;  ///
 
-    appendNode(replacementNode, parentNode);
+    appendNode(appendedNode, parentNode);
 
-    appendTokens(replacementTokens, parentNode, tokens);
+    appendTokens(appendedTokens, parentNode, tokens);
+  }
+
+  addAfter(existingNode, parentNode, context) {
+    const { tokens } = context,
+          addedNodes = this.getChildNodes(), ///
+          addedTokens = this.tokens;  ///
+
+    addNodesAfter(existingNode, addedNodes, parentNode);
+
+    addTokensAfter(existingNode, addedTokens, tokens);
   }
 
   replace(replacedNode, parentNode, context) {

package/src/utilities/childNodes.js

@@ -2,8 +2,6 @@
 
 import { arrayUtilities } from "necessary";
 
-import PlainTextMarkdownNode from "../node/markdown/plainText";
-
 import { EMPTY_STRING } from "../constants";
 import { contentFromNodes } from "../utilities/content";
 
@@ -19,7 +17,7 @@ export function htmlFromChildNodes(childNodes, context) {
     if (childNodeNonTerminalNode) {
       const nonTerminalNode = childNode,  ///
             markdownNode = nonTerminalNode, ///
-            markdownNodePlainTextMarkdownNode = (markdownNode instanceof PlainTextMarkdownNode);
+            markdownNodePlainTextMarkdownNode = markdownNode.isPlainTextMarkdownNode();
 
       if (markdownNodePlainTextMarkdownNode) {
         const plainTextMarkdownNode = markdownNode; ///
@@ -67,7 +65,7 @@ export function plainTextFromChildNodes(childNodes, context) {
     if (childNodeNonTerminalNode) {
       const nonTerminalNode = childNode,  ///
             markdownNode = nonTerminalNode, ///
-            markdownNodePlainTextMarkdownNode = (markdownNode instanceof PlainTextMarkdownNode);
+            markdownNodePlainTextMarkdownNode = markdownNode.isPlainTextMarkdownNode();
 
       if (markdownNodePlainTextMarkdownNode) {
         const plainTextMarkdownNode = markdownNode; ///
@@ -117,7 +115,7 @@ export function domElementsFromChildNodes(childNodes, context) {
     if (childNodeNonTerminalNode) {
       const nonTerminalNode = childNode,  ///
             markdownNode = nonTerminalNode, ///
-            markdownNodePlainTextMarkdownNode = (markdownNode instanceof PlainTextMarkdownNode);
+            markdownNodePlainTextMarkdownNode = markdownNode.isPlainTextMarkdownNode();
 
       if (markdownNodePlainTextMarkdownNode) {
         const plainTextMarkdownNode = markdownNode; ///

package/src/utilities/footnotes.js

@@ -2,19 +2,21 @@
 
 import { linkMarkdownNodesFromNode } from "../utilities/query";
 
-export function renumberLinkMarkdownNodes(divisionMarkdownNode, callback, context) {
-  const { footnoteNumberMap } = context,
-        node = divisionMarkdownNode,  ///
+export function renumberLinkMarkdownNodes(divisionMarkdownNode, footnoteMap, callback, context) {
+  const node = divisionMarkdownNode,  ///
         linkMarkdownNodes = linkMarkdownNodesFromNode(node);
 
   linkMarkdownNodes.forEach((linkMarkdownNode) => {
     const identifier = linkMarkdownNode.identifier(context),
-          footnoteNumber = footnoteNumberMap[identifier] || null,
-          number = footnoteNumber;  ///
+          footnoteReplacement = footnoteMap[identifier] || null;
 
-    linkMarkdownNode.setNumber(number);
+    if (footnoteReplacement !== null) {
+      const number = footnoteReplacement.getNumber();
 
-    callback(linkMarkdownNode);
+      linkMarkdownNode.setNumber(number);
+
+      callback(linkMarkdownNode);
+    }
   });
 }
 

package/src/utilities/processing.js

@@ -0,0 +1,93 @@
+"use strict";
+
+export function postprocess(divisionMarkdownNode, context) {
+  let divisionMarkdownNodes;
+
+  divisionMarkdownNodes = resolveIncludes(divisionMarkdownNode, context);
+
+  resolveEmbeddings(divisionMarkdownNodes, context);
+
+  const footnoteMap = prepareFootnotes(divisionMarkdownNodes, context);
+
+  divisionMarkdownNodes = paginate(divisionMarkdownNodes, context);
+
+  createFootnotes(divisionMarkdownNodes, footnoteMap, context);
+
+  createContents(divisionMarkdownNodes, context);
+
+  return divisionMarkdownNodes;
+}
+
+function paginate(divisionMarkdownNodes, context) {
+  const paginatedDivisionMarkdownNodes = [];
+
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.paginate(paginatedDivisionMarkdownNodes, context);
+  });
+
+  paginatedDivisionMarkdownNodes.forEach((paginatedDivisionMarkdownNode, index) => {
+    const pageNumber = index + 1;
+
+    paginatedDivisionMarkdownNode.setPageNumber(pageNumber);
+  });
+
+  divisionMarkdownNodes = paginatedDivisionMarkdownNodes; ///
+
+  return divisionMarkdownNodes;
+}
+
+function createContents(divisionMarkdownNodes, context) {
+  divisionMarkdownNodes.some((divisionMarkdownNode) => {
+    const contentsCreated = divisionMarkdownNode.createContents(divisionMarkdownNodes, context);
+
+    if (contentsCreated) {
+      return true;
+    }
+  });
+}
+
+function createFootnotes(divisionMarkdownNodes, footnoteMap, context) {
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.createFootnotes(footnoteMap, context);
+  });
+}
+
+function resolveIncludes(divisionMarkdownNode, context) {
+  const divisionMarkdownNodes = [];
+
+  Object.assign(context, {
+    divisionMarkdownNodes
+  });
+
+  const divisionMarkdownNodeIgnored = divisionMarkdownNode.isIgnored();
+
+  if (!divisionMarkdownNodeIgnored) {
+    divisionMarkdownNodes.push(divisionMarkdownNode);
+  }
+
+  divisionMarkdownNode.resolveIncludes(context);
+
+  delete context.divisionMarkdownNodes;
+
+  return divisionMarkdownNodes;
+}
+
+function prepareFootnotes(divisionMarkdownNodes, context) {
+  const footnoteMap = {};
+
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.prepareFootnotes(footnoteMap, context);
+  });
+
+  return footnoteMap;
+}
+
+function resolveEmbeddings(divisionMarkdownNodes, context) {
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.resolveEmbeddings(context);
+  });
+}
+
+export default {
+  postprocess
+};

package/src/utilities/query.js

@@ -5,16 +5,16 @@ import { arrayUtilities } from "necessary";
 
 const { first, push } = arrayUtilities;
 
-const footnoteMarkdownNodeQuery = Query.fromExpression("/*/footnote"),
-      ignoreDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/ignoreDirective"),
-      contentsDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/contentsDirective"),
-      footnotesDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/footnotesDirective"),
-      pageNumberDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/pageNumber"),
+const footnoteMarkdownNodeQuery = Query.fromExpression("/subDivision/footnote"),
+      ignoreDirectiveMarkdownNodeQuery = Query.fromExpression("/division/subDivision/directives/ignoreDirective"),
+      contentsDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/contentsDirective"),
+      footnotesDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/footnotesDirective"),
+      pageNumberDirectiveMarkdownNodeQuery = Query.fromExpression("/subDivision/directives/pageNumber"),  ///
       linkMarkdownNodesQuery = Query.fromExpression("//link"),
-      headingMarkdownNodesQuery = Query.fromExpression("//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"),
-      subDivisionMarkdownNodesQuery = Query.fromExpression("//subDivision"),
-      embedDirectiveMarkdownNodesQuery = Query.fromExpression("//directives/embedDirective"),
-      includeDirectiveMarkdownNodesQuery = Query.fromExpression("//directives/includeDirective"),
+      headingMarkdownNodesQuery = Query.fromExpression("/division/subDivision/primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"),
+      subDivisionMarkdownNodesQuery = Query.fromExpression("/division/subDivision"),
+      embedDirectiveMarkdownNodesQuery = Query.fromExpression("/subDivision/directives/embedDirective"),
+      includeDirectiveMarkdownNodesQuery = Query.fromExpression("/subDivision/directives/includeDirective"),
       linkFootnoteOrFootnotesDirectiveMarkdownNodesQuery = Query.fromExpression("//link|footnote|footnotesDirective");
 
 export function nodeQuery(expression) {