highmark-markdown 0.0.383 → 0.0.388

package/src/node/markdown/division.js

@@ -2,24 +2,23 @@
 
 import { arrayUtilities } from "necessary";
 
-import Replacement from "../../replacement";
 import MarkdownNode from "../../node/markdown";
-import ContentsListMarkdownNode from "../../node/markdown/contentsList";
-import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
+import FootnoteReplacement from "../../replacement/footnote";
+import ContentsListReplacement from "../../replacement/contentsList";
+import FootnotesListReplacement from "../../replacement/footnotesList";
+import FootnoteSubDivisionReplacement from "../../replacement/subDivision/footnote";
+import ContentsDirectiveSubDivisionReplacement from "../../replacement/subDivision/contentsDirective";
+import FootnotesDirectiveSubDivisionReplacement from "../../replacement/subDivision/footnotesDirective";
+import PageNumberDirectiveSubDivisionReplacement from "../../replacement/subDivision/pageNumberDirective";
 
 import { EMPTY_STRING } from "../../constants";
 import { DIVISION_RULE_NAME } from "../../ruleNames";
-import { removeNode, removeTokens, replaceNode, replaceNodes, replaceTokens } from "../../utilities/node";
-import { footnoteMarkdownNodsFromNode,
-         headingMarkdownNodesFromNode,
-         subDivisionMarkdownNodesFromNode,
+import { subDivisionMarkdownNodesFromNode,
          embedDirectiveMarkdownNodesFromNode,
          ignoreDirectiveMarkdownNodeFromNode,
-         contentsDirectiveMarkdownNodeFromNode,
-         footnotesDirectiveMarkdownNodeFromNode,
          pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
 
-const { clear, filter } = arrayUtilities;
+const { clear } = arrayUtilities;
 
 export default class DivisionMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, precedence, opacity, domElement, divisionClassName) {
@@ -50,40 +49,12 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return ignored;
   }
 
-  findParentNode(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.findParentNode(childNode, node);
-
-          if (parentNode !== null) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return parentNode;
-  }
-
   paginate(context) {
     const { linesPerPage } = context,
           childNodes = this.getChildNodes(),
           paginatedChildNodes = [],
           divisionMarkdownNodes = [],
-          subDivisionReplacements = this.removeSubdivisionMarkdownNodes(pageNumberDirectiveMarkdownNodeFromNode, context);
+          pageNumberDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(PageNumberDirectiveSubDivisionReplacement, context);
 
     let totalLines = 0;
 
@@ -96,7 +67,7 @@ export default class DivisionMarkdownNode extends MarkdownNode {
       paginatedChildNodes.push(paginatedChildNode);
 
       if (totalLines > linesPerPage) {
-        const divisionMarkdownNode = DivisionMarkdownNode.fromSubdivisionReplacementsPaginatedChildNodesAndDivisionClassName(subDivisionReplacements, paginatedChildNodes, this.divisionClassName, context);
+        const divisionMarkdownNode = DivisionMarkdownNode.fromPageNumberDirectiveSubDivisionReplacementPaginatedChildNodesAndDivisionClassName(pageNumberDirectiveSubDivisionReplacement, paginatedChildNodes, this.divisionClassName, context);
 
         divisionMarkdownNodes.push(divisionMarkdownNode);
 
@@ -107,7 +78,7 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     });
 
     if (totalLines > 0) {
-      const divisionMarkdownNode = DivisionMarkdownNode.fromSubdivisionReplacementsPaginatedChildNodesAndDivisionClassName(subDivisionReplacements, paginatedChildNodes, this.divisionClassName, context);
+      const divisionMarkdownNode = DivisionMarkdownNode.fromPageNumberDirectiveSubDivisionReplacementPaginatedChildNodesAndDivisionClassName(pageNumberDirectiveSubDivisionReplacement, paginatedChildNodes, this.divisionClassName, context);
 
       divisionMarkdownNodes.push(divisionMarkdownNode);
     }
@@ -127,67 +98,45 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   createContents(divisionMarkdownNodes, context) {
     let contentsCreated = false;
 
-    const node = this,  ///
-          contentsDirectiveMarkdownNode = contentsDirectiveMarkdownNodeFromNode(node);
+    const contentsDirectiveSubDivisionReplacement = this.findSubDivisionReplacement(ContentsDirectiveSubDivisionReplacement, context);
 
-    if (contentsDirectiveMarkdownNode !== null) {
+    if (contentsDirectiveSubDivisionReplacement !== null) {
       const divisionMarkdownNode = this,  ///
-            headingMarkdownNodes = headingMarkdownNodesFromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context),
-            headingMarkdownNodesLength = headingMarkdownNodes.length;
-
-      if (headingMarkdownNodesLength === 0) {
-        return;
-      }
+            contentsListReplacement = ContentsListReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
 
-      const { tokens } = context,
-            contentsListMarkdownNode = ContentsListMarkdownNode.fromHeadingMarkdownNodes(headingMarkdownNodes, context),
-            contentsListMarkdownNodeTokens = contentsListMarkdownNode.getTokens(),
-            childNode = contentsDirectiveMarkdownNode,  ///
-            parentNode = this.findParentNode(childNode),
-            replacedNode = contentsDirectiveMarkdownNode, ///
-            replacementNode = contentsListMarkdownNode,  ///
-            replacementTokens = contentsListMarkdownNodeTokens; ///
+      if (contentsListReplacement !== null) {
+        contentsListReplacement.replaceContentsDirectiveSubdivisionReplacement(contentsDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
 
-      replaceNode(replacementNode, replacedNode, parentNode);
-
-      replaceTokens(replacementTokens, replacedNode, tokens);
-
-      contentsCreated = true;
+        contentsCreated = true;
+      }
     }
 
     return contentsCreated;
   }
 
   createFootnotes(footnoteReplacements, context) {
-    if (footnoteReplacements === null) {
-      return;
-    }
-
-    const divisionMarkdownNode = this,  ///
-          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context);
+    if (footnoteReplacements !== null) {
+      const divisionMarkdownNode = this,  ///
+            footnotesListReplacement = FootnotesListReplacement.fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context);
 
-    if (footnotesListMarkdownNode === null) {
-      return;
+      if (footnotesListReplacement !== null) {
+        footnotesListReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
+      }
     }
-
-    const node = footnotesListMarkdownNode, ///
-          replacement = Replacement.fromNode(node, context);
-
-    replacement.appendTo(divisionMarkdownNode, context);
   }
 
   prepareFootnotes(context) {
-    let subdivisionReplacements;
+    const footnoteSubDivisionReplacements = this.removeSubDivisionMarkdownNodes(FootnoteSubDivisionReplacement, context);
 
-    subdivisionReplacements = this.removeSubdivisionMarkdownNodes(footnoteMarkdownNodsFromNode, context);
+    let footnoteReplacements = footnoteSubDivisionReplacements.map((footnoteSubDivisionReplacement) => {
+      const footnoteReplacement = FootnoteReplacement.fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement);
 
-    let footnoteReplacements = footnoteReplacementsFromSubdivisionReplacements(subdivisionReplacements);
-
-    subdivisionReplacements = this.removeSubdivisionMarkdownNodes(footnotesDirectiveMarkdownNodeFromNode, context);
+      return footnoteReplacement;
+    });
 
-    const subdivisionReplacementsLength = subdivisionReplacements.length;
+    const footnotesDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionReplacement, context);
 
-    if (subdivisionReplacementsLength === 0) {
+    if (footnotesDirectiveSubDivisionReplacement === null) {
       footnoteReplacements = null;
     }
 
@@ -199,48 +148,40 @@ export default class DivisionMarkdownNode extends MarkdownNode {
           embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodesFromNode(node);
 
     embedDirectiveMarkdownNodes.map((embedDirectiveMarkdownNode) => {
-      const replacement = embedDirectiveMarkdownNode.replacement(context);
+      const importedReplacement = embedDirectiveMarkdownNode.import(context);
 
-      if (replacement !== null) {
-        let tokens;
-
-        tokens = replacement.getTokens();
+      if (importedReplacement !== null) {
+        const childNode = embedDirectiveMarkdownNode,  ///
+              parentNode = this.findParentNode(childNode);
 
-        const childNodes = replacement.getChildNodes(),
-              replacementNodes = childNodes, ///
-              replacementTokens = tokens; ///
+        importedReplacement.replaceEmbedDirectiveMarkdownNode(embedDirectiveMarkdownNode, parentNode, context);
+      }
+    });
+  }
 
-        ({ tokens } = context);
+  findSubDivisionReplacement(SubDivisionReplacement, context) {
+    let subDivisionReplacement = null;
 
-        const childNode = embedDirectiveMarkdownNode,  ///
-              parentNode = this.findParentNode(childNode),
-              replacedNode = embedDirectiveMarkdownNode; ///
+    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
 
-        replaceNodes(replacementNodes, replacedNode, parentNode);
+    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
+      subDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context);
 
-        replaceTokens(replacementTokens, replacedNode, tokens);
+      if (subDivisionReplacement !== null) {
+        return true;
       }
     });
+
+    return subDivisionReplacement;
   }
 
-  removeSubdivisionMarkdownNodes(markdownNodeFromNode, context) {
-    const { tokens } = context,
-          node = this,  ///
-          parentNode = this,  ///
-          subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node),
+  findSubDivisionReplacements(SubDivisionReplacement, context) {
+    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes(),
           subDivisionReplacements = subDivisionMarkdownNodes.reduce((subDivisionReplacements, subDivisionMarkdownNode) => {
-            const node = subDivisionMarkdownNode, ///
-                  markdownNode = markdownNodeFromNode(node);
-
-            if (markdownNode !== null) {
-              const removedNode = subDivisionMarkdownNode,  ///
-                    subDivisionReplacement = Replacement.fromNode(subDivisionMarkdownNode, context);
+            const subDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context);
 
+            if (subDivisionReplacement !== null) {
               subDivisionReplacements.push(subDivisionReplacement);
-
-              removeTokens(removedNode, tokens);
-
-              removeNode(removedNode, parentNode);
             }
 
             return subDivisionReplacements;
@@ -249,11 +190,40 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return subDivisionReplacements;
   }
 
-  createFootnotesListMarkdownNode(context) {
+  findSubDivisionMarkdownNodes() {
+    const node = this,  ///
+          subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node);
+
+    return subDivisionMarkdownNodes;
+  }
+
+  removeSubDivisionMarkdownNode(SubDivisionReplacement, context) {
     const divisionMarkdownNode = this,  ///
-          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+          subDivisionReplacement = this.findSubDivisionReplacement(SubDivisionReplacement, context);
+
+    if (subDivisionReplacement !== null) {
+      subDivisionReplacement.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+    }
 
-    return footnotesListMarkdownNode;
+    return subDivisionReplacement;
+  }
+
+  removeSubDivisionMarkdownNodes(SubDivisionReplacement, context) {
+    const divisionMarkdownNode = this,  ///
+          subDivisionReplacements = this.findSubDivisionReplacements(SubDivisionReplacement, context);
+
+    subDivisionReplacements.forEach((subDivisionReplacement) => {
+      subDivisionReplacement.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+    });
+
+    return subDivisionReplacements;
+  }
+
+  createFootnotesListMarkdownNode(context) {
+    // const divisionMarkdownNode = this,  ///
+    //       footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+    //
+    // return footnotesListMarkdownNode;
   }
 
   asHTML(context) {
@@ -283,7 +253,7 @@ ${childNodesHTML}${indent}${closingTag}
     return divisionMarkdownNode;
   }
 
-  static fromSubdivisionReplacementsPaginatedChildNodesAndDivisionClassName(subDivisionReplacements, paginatedChildNodes, divisionClassName, context) {
+  static fromPageNumberDirectiveSubDivisionReplacementPaginatedChildNodesAndDivisionClassName(pageNumberDirectiveSubDivisionReplacement, paginatedChildNodes, divisionClassName, context) {
     const ruleName = DIVISION_RULE_NAME,
           childNodes = [
             ...paginatedChildNodes
@@ -291,50 +261,12 @@ ${childNodesHTML}${indent}${closingTag}
           opacity = null,
           divisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity, divisionClassName);
 
-    subDivisionReplacements.some((subDivisionReplacement) => {
-      subDivisionReplacement.appendTo(divisionMarkdownNode, context);
+    if (pageNumberDirectiveSubDivisionReplacement !== null) {
+      pageNumberDirectiveSubDivisionReplacement = pageNumberDirectiveSubDivisionReplacement.clone();  ///
 
-      return true;  ///
-    });
+      pageNumberDirectiveSubDivisionReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
+    }
 
     return divisionMarkdownNode;
   }
 }
-
-function footnoteReplacementsFromSubdivisionReplacements(subdivisionReplacements) {
-  const footnoteReplacements = subdivisionReplacements.map((subdivisionReplacement) => {
-    const node = subdivisionReplacement.getNode(),
-          footnoteMarkdownNode = footnoteMarkdownNodsFromNode(node),
-          descendentNode = footnoteMarkdownNode,  ///
-          footnoteReplacement = subdivisionReplacement.contract(descendentNode);
-
-    return footnoteReplacement;
-  });
-
-  return footnoteReplacements;
-}
-
-function headingMarkdownNodesFromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
-  const headingMarkdownNodes = [],
-        index = divisionMarkdownNodes.indexOf(divisionMarkdownNode),
-        start = index + 1;
-
-  divisionMarkdownNodes = divisionMarkdownNodes.slice(start); ///
-
-  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
-    const node = divisionMarkdownNode;  ///
-
-    headingMarkdownNodesFromNode(node, headingMarkdownNodes);
-  });
-
-  filter(headingMarkdownNodes, (headingMarkdownNode) => {
-    const { contentsDepth } = context,
-          depth = headingMarkdownNode.getDepth();
-
-    if (depth <= contentsDepth) {
-      return true;
-    }
-  });
-
-  return headingMarkdownNodes;
-}

package/src/node/markdown/{footnoteItem.js → footnotesItem.js}

@@ -5,11 +5,11 @@ import { arrayUtilities } from "necessary";
 import MarkdownNode from "../../node/markdown";
 import AnchorMarkdownNode from "../../node/markdown/anchor";
 
-import { FOOTNOTE_ITEM_RULE_NAME } from "../../ruleNames";
+import { FOOTNOTES_ITEM_RULE_NAME } from "../../ruleNames";
 
 const { first, second } = arrayUtilities;
 
-export default class FootnoteItemMarkdownNode extends MarkdownNode {
+export default class FootnotesItemMarkdownNode extends MarkdownNode {
   identifier(context) {
     const childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
@@ -24,14 +24,14 @@ export default class FootnoteItemMarkdownNode extends MarkdownNode {
           footnoteMarkdownNodeChildNodes = footnoteMarkdownNode.getChildNodes(),
           secondFootnoteMarkdownNodeChildNode = second(footnoteMarkdownNodeChildNodes),
           paragraphMarkdownNode = secondFootnoteMarkdownNodeChildNode,  ///
-          ruleName = FOOTNOTE_ITEM_RULE_NAME,
+          ruleName = FOOTNOTES_ITEM_RULE_NAME,
           childNodes = [
             anchorMarkdownNode,
             paragraphMarkdownNode
           ],
           opacity = null,
-          footnoteItemMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnoteItemMarkdownNode, ruleName, childNodes, opacity);
+          footnotesItemMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesItemMarkdownNode, ruleName, childNodes, opacity);
 
-    return footnoteItemMarkdownNode;
+    return footnotesItemMarkdownNode;
   }
 }

package/src/node/markdown/footnotesList.js

@@ -1,15 +1,9 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
-import FootnoteItemMarkdownNode from "./footnoteItem";
 
 import { START_ATTRIBUTE_NAME } from "../../attributeNames";
 import { FOOTNOTES_LIST_RULE_NAME } from "../../ruleNames";
-import { linkMarkdownNodesFromNode } from "../../utilities/query";
-
-const { extract } = arrayUtilities;
 
 export default class FootnotesListMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, opacity, precedence, domElement, start) {
@@ -36,86 +30,24 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
 
   clone() { return super.clone(this.start); }
 
-  static fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context) {
+  static fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start) {
     let footnotesListMarkdownNode = null;
 
-    const { footnoteNumberMap } = context;
-
-    const node = divisionMarkdownNode,  ///
-          footnoteNumbers = Object.values(footnoteNumberMap),
-          linkMarkdownNodes = linkMarkdownNodesFromNode(node),
-          footnoteNumbersLength = footnoteNumbers.length,
-          footnoteItemReplacements = [];
-
-    let count = 0;
-
-    linkMarkdownNodes.forEach((linkMarkdownNode) => {
-      const identifier = linkMarkdownNode.identifier(context);
-
-      let footnoteNumber = footnoteNumberMap[identifier] || null;
-
-      if (footnoteNumber === null) {
-        const footnoteReplacement = footnoteReplacementFromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context);
-
-        if (footnoteReplacement !== null) {
-          const footnoteItemReplacement = footnoteItemReplacementFromFootnoteReplacementAndIdentifier(footnoteReplacement, identifier);
-
-          footnoteItemReplacements.push(footnoteItemReplacement);
-
-          count++;
-
-          footnoteNumber = footnoteNumbersLength + count;
-
-          footnoteNumberMap[identifier] = footnoteNumber;
-        }
-      }
+    const footnotesItemReplacementsLength = footnotesItemReplacements.length;
 
-      if (footnoteNumber !== null) {
-        const number = footnoteNumber;  ///
-
-        linkMarkdownNode.setNumber(number);
-      }
-    });
-
-    const footnoteItemReplacementsLength = footnoteItemReplacements.length;
-
-    if (footnoteItemReplacementsLength > 0) {
+    if (footnotesItemReplacementsLength > 0) {
       const ruleName = FOOTNOTES_LIST_RULE_NAME,
-            childNodes = [], ///
-            opacity = null,
-            start = footnoteNumbersLength + 1;
+            childNodes = footnotesItemReplacements.map((footnotesItemReplacement) => {
+              const footnotesItemReplacementMode = footnotesItemReplacement.getNode(),
+                childNode = footnotesItemReplacementMode; ///
 
-      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
+              return childNode;
+            }),
+            opacity = null;
 
-      footnoteItemReplacements.forEach((footnotesItemReplacement) => {
-        footnotesItemReplacement.appendTo(footnotesListMarkdownNode, context);
-      });
+      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
     }
 
     return footnotesListMarkdownNode;
   }
 }
-
-function footnoteReplacementFromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context) {
-  const footnoteReplacement = extract(footnoteReplacements, (footnoteReplacement) => {
-          const node = footnoteReplacement.getNode(),
-            footnoteMarkdownNode = node,  ///
-            footnoteMarkdownNodeIdentifier = footnoteMarkdownNode.identifier(context);
-
-          if (footnoteMarkdownNodeIdentifier === identifier) {
-            return true;
-          }
-        }) || null;
-
-  return footnoteReplacement;
-}
-
-function footnoteItemReplacementFromFootnoteReplacementAndIdentifier(footnoteReplacement, identifier) {
-  const node = footnoteReplacement.getNode(),
-        footnoteMarkdownNode = node,  ///
-        footnoteItemMarkdownNode = FootnoteItemMarkdownNode.fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier),
-        ascendantNode = footnoteItemMarkdownNode, ///
-        footnoteItemReplacement = footnoteReplacement.expand(ascendantNode);
-
-  return footnoteItemReplacement;
-}

package/src/node/markdown/subDivision.js

@@ -52,9 +52,5 @@ export default class SubDivisionMarkdownNode extends MarkdownNode {
     return secondMarkdownNode;
   }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
-    const subDivisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(SubDivisionMarkdownNode, ruleName, childNodes, opacity);
-
-    return subDivisionMarkdownNode;
-  }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(SubDivisionMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown.js

@@ -132,6 +132,34 @@ class MarkdownNode extends NonTerminalNode {
     });
   }
 
+  findParentNode(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.findParentNode(childNode, node);
+
+          if (parentNode !== null) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return parentNode;
+  }
+
   lines(context) {
     const childNodes = this.getChildNodes(),
           lines = childNodes.reduce((lines, childNode) => {

package/src/nodeMap.js

@@ -25,11 +25,14 @@ import StrongTextMarkdownNode from "./node/markdown/strongText";
 import SubDivisionMarkdownNode from "./node/markdown/subDivision";
 import OrderedListMarkdownNode from "./node/markdown/orderedList";
 import BlockListingMarkdownNode from "./node/markdown/blockListing";
-import FootnoteItemMarkdownNode from "./node/markdown/footnoteItem";
 import TableHeadRowMarkdownNode from "./node/markdown/tableHeadRow";
 import TableBodyRowMarkdownNode from "./node/markdown/tableBodyRow";
+import ContentsLinkMarkdownNode from "./node/markdown/contentsLink";
+import ContentsItemMarkdownNode from "./node/markdown/contentsItem";
+import ContentsListMarkdownNode from "./node/markdown/contentsList";
 import InlineListingMarkdownNode from "./node/markdown/inlineListing";
 import UnorderedListMarkdownNode from "./node/markdown/unorderedList";
+import FootnotesItemMarkdownNode from "./node/markdown/footnotesItem";
 import FootnotesListMarkdownNode from "./node/markdown/footnotesList";
 import VerticalSpaceMarkdownNode from "./node/markdown/verticalSpace";
 import TableHeadCellMarkdownNode from "./node/markdown/tableHeadCell";
@@ -77,11 +80,14 @@ import { LINE_RULE_NAME,
          SUB_DIVISION_RULE_NAME,
          ORDERED_LIST_RULE_NAME,
          BLOCK_LISTING_RULE_NAME,
-         FOOTNOTE_ITEM_RULE_NAME,
+         CONTENTS_LINK_RULE_NAME,
+         CONTENTS_ITEM_RULE_NAME,
+         CONTENTS_LIST_RULE_NAME,
          TABLE_HEAD_ROW_RULE_NAME,
          TABLE_BODY_ROW_RULE_NAME,
          INLINE_LISTING_RULE_NAME,
          UNORDERED_LIST_RULE_NAME,
+         FOOTNOTES_ITEM_RULE_NAME,
          FOOTNOTES_LIST_RULE_NAME,
          VERTICAL_SPACE_RULE_NAME,
          TABLE_HEAD_CELL_RULE_NAME,
@@ -130,11 +136,14 @@ const nodeMap = {
   [SUB_DIVISION_RULE_NAME]: SubDivisionMarkdownNode,
   [ORDERED_LIST_RULE_NAME]: OrderedListMarkdownNode,
   [BLOCK_LISTING_RULE_NAME]: BlockListingMarkdownNode,
-  [FOOTNOTE_ITEM_RULE_NAME]: FootnoteItemMarkdownNode,
+  [CONTENTS_LINK_RULE_NAME]: ContentsLinkMarkdownNode,
+  [CONTENTS_ITEM_RULE_NAME]: ContentsItemMarkdownNode,
+  [CONTENTS_LIST_RULE_NAME]: ContentsListMarkdownNode,
   [TABLE_HEAD_ROW_RULE_NAME]: TableHeadRowMarkdownNode,
   [TABLE_BODY_ROW_RULE_NAME]: TableBodyRowMarkdownNode,
   [INLINE_LISTING_RULE_NAME]: InlineListingMarkdownNode,
   [UNORDERED_LIST_RULE_NAME]: UnorderedListMarkdownNode,
+  [FOOTNOTES_ITEM_RULE_NAME]: FootnotesItemMarkdownNode,
   [FOOTNOTES_LIST_RULE_NAME]: FootnotesListMarkdownNode,
   [VERTICAL_SPACE_RULE_NAME]: VerticalSpaceMarkdownNode,
   [TABLE_HEAD_CELL_RULE_NAME]: TableHeadCellMarkdownNode,

package/src/replacement/contentsItem.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import Replacement from "../replacement";
+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); }
+
+  static fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context) {
+    const replacements = [],
+          contentsLinkReplacement = ContentsLinkReplacement.fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context);
+
+    if (contentsLinkReplacement !== null) {
+      const node = nestedHeadingMarkdownNode.getNode(),
+            headingMarkdownNode = node;  ///
+
+      headingMarkdownNode.addAnchor(context);
+
+      const replacement = contentsLinkReplacement;
+
+      replacements.push(replacement);
+    }
+
+    const childNestedNodes = nestedHeadingMarkdownNode.getChildNestedNodes(),
+          nestedHeadingMarkdownNodes = childNestedNodes,  ///
+          nestedHeadingMarkdownNodesLength = nestedHeadingMarkdownNodes.length;
+
+    if (nestedHeadingMarkdownNodesLength > 0) {
+      const { ContentsListReplacement } = ContentsItemReplacement,
+            contentsListReplacement = ContentsListReplacement.fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+            replacement = contentsListReplacement; ///
+
+      replacements.push(replacement);
+    }
+
+    const contentsItemMarkdownNode = ContentsItemMarkdownNode.fromReplacements(replacements),
+          node = contentsItemMarkdownNode,  ///
+          tokens = [];
+
+    replacements.forEach((replacement) => {
+      replacement.getTokens(tokens);
+    });
+
+    const contentsItemReplacement = ContentsItemReplacement.fromNodeAndTokens(node, tokens);
+
+    return contentsItemReplacement;
+  }
+}