highmark-markdown 0.0.153 → 0.0.155

package/src/node/markdown/division.js

@@ -1,9 +1,18 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import MarkdownNode from "../../node/markdown";
-import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
+import ContentsListMarkdownNode from "../../node/markdown/contentsList";
+
+const { filter } = arrayUtilities;
+
+import { nestNodes } from "../../utilities/tree";
+import { replaceTokens } from "../../utilities/tokens";
+import { headingMarkdownNodesFromNode, contentsMarkdownNodeFromNode } from "../../utilities/query";
+// import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
 
-import { renumberLinkMarkdownNodes, renumberLinkMarkdownNodesHTML } from "../../utilities/link";
+// import { renumberLinkMarkdownNodes, renumberLinkMarkdownNodesHTML, appendFootnotesListMarkdownNodeHTML } from "../../utilities/footnotes";
 
 export default class DivisionMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, precedence, opacity, domElement, divisionClassName) {
@@ -16,8 +25,8 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return this.divisionClassName;
   }
 
-  adjustIndent(indent) {
-    return indent;
+  setDivisionClassName(divisionClassName) {
+    this.divisionClassName = divisionClassName;
   }
 
   className(context) {
@@ -26,57 +35,90 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return className;
   }
 
-  asHTML(indent, context) {
-    const { divisionClassName = null } = context;
-
-    this.divisionClassName = divisionClassName; ///
+  createContents(context) {
+    const node = this,  ///
+          contentsMarkdownNode = contentsMarkdownNodeFromNode(node);
 
-    const html = super.asHTML(indent, context);
-
-    return html;
-  }
-
-  createDOMElement(context) {
-    const { divisionClassName = null } = context;
+    if (contentsMarkdownNode === null) {
+      return;
+    }
 
-    this.divisionClassName = divisionClassName; ///
+    const maximumLevel = contentsMarkdownNode.maximumLevel(context);
 
-    const domElement = super.createDOMElement(context);
+    const headingMarkdownNodes = headingMarkdownNodesFromNodeAndMaximumLevel(node, maximumLevel, context),
+          headingMarkdownNodesLength = headingMarkdownNodes.length;
 
-    return domElement;
-  }
+    if (headingMarkdownNodesLength === 0) {
+      return;
+    }
 
-  childNodesAsHTML(indent, context) {
-    const divisionMarkdownNode = this,  ///
-          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+    const nodes = headingMarkdownNodes, ///
+          nestedNode = nestNodes(nodes),
+          childNestedNodes = nestedNode.getChildNestedNodes(),
+          replacementTokens = [];
 
-    let childNodesHTML = super.childNodesAsHTML(indent, context);
+    Object.assign(context, {
+      replacementTokens
+    });
 
-    if (footnotesListMarkdownNode !== null) {
-      const footnotesListMarkdownNodeHTML = footnotesListMarkdownNode.asHTML(indent, context);
+    const nestedHeadingMarkdownNodes = childNestedNodes,  ///
+          contentsListMarkdownNode = ContentsListMarkdownNode.fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+          replacementChildNode = contentsListMarkdownNode,
+          replacedChildNode = contentsMarkdownNode; ///
 
-      childNodesHTML = `${childNodesHTML}${footnotesListMarkdownNodeHTML}`;
+    this.replaceChildNode(replacedChildNode, replacementChildNode);
 
-      childNodesHTML = renumberLinkMarkdownNodesHTML(childNodesHTML, divisionMarkdownNode, footnotesListMarkdownNode, context);
-    }
+    // replaceTokens(replacedChildNode, replacementTokens, context);
 
-    return childNodesHTML;
+    delete context.replacementTokens;
   }
 
-  createChildNodeDOMElements(context) {
-    const divisionMarkdownNode = this,  ///
-          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+  createFootnotes(context) {
 
-    super.createChildNodeDOMElements(context);
+  }
 
-    if (footnotesListMarkdownNode !== null) {
-      const footnotesListMarkdownNodeDOMElement = footnotesListMarkdownNode.createDOMElement(context),
-            childNodeDOMElement = footnotesListMarkdownNodeDOMElement;  ///
+  recreateFootnotes(context) {
 
-      this.insertDOMElement(childNodeDOMElement);
+  }
 
-      renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context);
-    }
+  // childNodesAsHTML(indent, context) {
+  //   const divisionMarkdownNode = this,  ///
+  //         contentsListMarkdownNode = ContentsListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context),
+  //         footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+  //
+  //   let childNodesHTML = super.childNodesAsHTML(indent, context);
+  //
+  //   if (contentsListMarkdownNode !== null) {
+  //     childNodesHTML = replaceContentsMarkdownNodeHTML(childNodesHTML, divisionMarkdownNode, contentsListMarkdownNode, context);
+  //   }
+  //
+  //   if (footnotesListMarkdownNode !== null) {
+  //     childNodesHTML = renumberLinkMarkdownNodesHTML(childNodesHTML, divisionMarkdownNode, footnotesListMarkdownNode, context);
+  //
+  //     childNodesHTML = appendFootnotesListMarkdownNodeHTML(childNodesHTML, footnotesListMarkdownNode, indent, context);
+  //   }
+  //
+  //   return childNodesHTML;
+  // }
+
+  // createChildNodeDOMElements(context) {
+  //   const divisionMarkdownNode = this,  ///
+  //         footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+  //
+  //   super.createChildNodeDOMElements(context);
+  //
+  //   if (footnotesListMarkdownNode !== null) {
+  //     const footnotesListMarkdownNodeDOMElement = footnotesListMarkdownNode.createDOMElement(context),
+  //           childNodeDOMElement = footnotesListMarkdownNodeDOMElement;  ///
+  //
+  //     this.insertDOMElement(childNodeDOMElement);
+  //
+  //     renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context);
+  //   }
+  // }
+
+  clone() {
+    debugger
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
@@ -87,3 +129,16 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   }
 }
 
+function headingMarkdownNodesFromNodeAndMaximumLevel(node, maximumLevel) {
+  const  headingMarkdownNodes = headingMarkdownNodesFromNode(node);
+
+  filter(headingMarkdownNodes, (headingMarkdownNode) => {
+    const level = headingMarkdownNode.getLevel();
+
+    if (level <= maximumLevel) {
+      return true;
+    }
+  });
+
+  return headingMarkdownNodes;
+}

package/src/node/markdown/heading/primary.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import HeadingMarkdownNode from "../../../node/markdown/heading";
+
+export default class PrimaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static level = 1;
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(PrimaryHeadingMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/heading/quaternary.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import HeadingMarkdownNode from "../../../node/markdown/heading";
+
+export default class QuaternaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static level = 4;
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(QuaternaryHeadingMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/heading/secondary.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import HeadingMarkdownNode from "../../../node/markdown/heading";
+
+export default class SecondaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static level = 2;
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(SecondaryHeadingMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/heading/tertiary.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import HeadingMarkdownNode from "../../../node/markdown/heading";
+
+export default class TertiaryHeadingMarkdownNode extends HeadingMarkdownNode {
+  static level = 3;
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return HeadingMarkdownNode.fromRuleNameChildNodesAndOpacity(TertiaryHeadingMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/heading.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class HeadingMarkdownNode extends MarkdownNode {
+  getLevel() {
+    const { level } = this.constructor;
+
+    return level;
+  }
+
+  static fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/import.js

@@ -4,10 +4,12 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 
+import { replaceTokens } from "../../utilities/tokens";
+
 const { fourth } = arrayUtilities;
 
 export default class ImportMarkdownNode extends MarkdownNode {
-  asHTML(indent, context) {
+  resolveImports(parentNode, context) {
     let html = null;
 
     const { importer = null } = context;
@@ -15,15 +17,28 @@ export default class ImportMarkdownNode extends MarkdownNode {
     if (importer !== null) {
       const filePath = this.filePath(context);
 
-      indent = this.adjustIndent(indent);
+      importer(filePath, context);
+
+      const { importedNode = null, importedTokens = null } = context;
+
+      if (importedNode !== null) {
+        const replacedChildNode = this, ///
+              replacementTokens = importedTokens, ///
+              replacementChildNode = importedNode;  ///
+
+        parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+
+        replaceTokens(replacedChildNode, replacementTokens, context);
+
+        delete context.importedNode;
+        delete context.importedTokens;
 
-      const { tokens } = context;
+        parentNode = this;  ///
 
-      html = importer(filePath, indent, context);
+        const divisionMarkdownNode = importedNode;  ///
 
-      Object.assign(context, {
-        tokens
-      });
+        divisionMarkdownNode.resolveImports(parentNode, context);
+      }
     }
 
     return html;

package/src/node/markdown/line.js

@@ -8,22 +8,24 @@ const { first } = arrayUtilities;
 
 export default class LineMarkdownNode extends MarkdownNode {
   childNodesAsHTML(indent, context) {
-    const childNodes = this.getChildNodes(),
+    const trimmed = true,
+          childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           markedTextChildNode = firstChildNode, ///
-          markedTextChildNodeChildNodesHTML = markedTextChildNode.childNodesAsHTML(indent, context),
+          markedTextChildNodeChildNodesHTML = markedTextChildNode.childNodesAsHTML(indent, context, trimmed),
           childNodesHTML = `${markedTextChildNodeChildNodesHTML}\n`;
 
     return childNodesHTML;
   }
 
   createChildNodeDOMElements(context) {
-    const domElement = this.getDOMElement(),
+    const trimmed = true,
+          domElement = this.getDOMElement(),
           childNodes = this.getChildNodes(),
           firstChildNode = first(childNodes),
           markedTextChildNode = firstChildNode; ///
 
-    markedTextChildNode.createChildNodeDOMElements(domElement, context);
+    markedTextChildNode.createChildNodeDOMElements(domElement, context, trimmed);
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(LineMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/markedText.js

@@ -5,19 +5,19 @@ import MarkdownNode from "../../node/markdown";
 import { htmlFromChildNodes, domElementsFromChildNodes } from "../../utilities/childNodes";
 
 export default class MarkedTextMarkdownNode extends MarkdownNode {
-  childNodesAsHTML(indent, context) {
+  childNodesAsHTML(indent, context, trimmed = false) {
     const childNodes = this.getChildNodes(),
-          html = htmlFromChildNodes(childNodes, context);
+          html = htmlFromChildNodes(childNodes, context, trimmed);
 
     return html;
   }
 
-  createChildNodeDOMElements(domElement, context) {
+  createChildNodeDOMElements(domElement, context, trimmed = false) {
     const parentDOMElement = domElement,  ///
           siblingDOMElement = null;
 
     const childNodes = this.getChildNodes(),
-          domElements = domElementsFromChildNodes(childNodes, context),
+          domElements = domElementsFromChildNodes(childNodes, context, trimmed),
           childNodeDOMElements = domElements; ///
 
     childNodeDOMElements.forEach((childNodeDOMElement) => {

package/src/node/markdown.js

@@ -23,6 +23,15 @@ class MarkdownNode extends NonTerminalNode {
     this.domElement = domElement;
   }
 
+  replaceChildNode(replacedChildNode, replacementChildNode) {
+    const childNodes = this.getChildNodes(),
+          index = childNodes.indexOf(replacedChildNode),
+          start = index,  ///
+          deleteCount = 1;
+
+    childNodes.splice(start, deleteCount, replacementChildNode);
+  }
+
   tagName(context) {
     const { tagName } = ruleNameToHTMLMap[this.ruleName];
 
@@ -94,25 +103,21 @@ class MarkdownNode extends NonTerminalNode {
     return attributeValue;
   }
 
-  childNodesAsHTML(indent, context) {
-    const childNodes = this.getChildNodes(),
-          childNodesHTML = childNodes.reduce((childNodesHTML, childNode) => {
-            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+  resolveImports(parentNode, context) {
+    parentNode = this;  ///\
 
-            if (childNodeNonTerminalNode) {
-              const childNodeHTML = childNode.asHTML(indent, context);
+    const childNodes = this.getChildNodes();
 
-              if (childNodeHTML !== null) {
-                childNodesHTML = (childNodesHTML === null) ?
-                                   childNodeHTML :  ///
-                                    `${childNodesHTML}${childNodeHTML}`;
-              }
-            }
+    childNodes.forEach((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
-            return childNodesHTML;
-          }, null);
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode,  ///
+              markdownNode = nonTerminalNode; ///
 
-    return childNodesHTML;
+        markdownNode.resolveImports(parentNode, context);
+      }
+    });
   }
 
   asHTML(indent, context) {
@@ -181,6 +186,29 @@ ${childNodesHTML}${indent}${closingTag}
     return domElement;
   }
 
+  childNodesAsHTML(indent, context) {
+    const childNodes = this.getChildNodes(),
+          childNodesHTML = childNodes.reduce((childNodesHTML, childNode) => {
+            const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+            if (childNodeNonTerminalNode) {
+              const nonTerminalNode = childNode,  ///
+                    markdownNode = nonTerminalNode, ///
+                    markdownNodeHTML = markdownNode.asHTML(indent, context);
+
+              if (markdownNodeHTML !== null) {
+                childNodesHTML = (childNodesHTML === null) ?
+                                   markdownNodeHTML :  ///
+                                    `${childNodesHTML}${markdownNodeHTML}`;
+              }
+            }
+
+            return childNodesHTML;
+          }, null);
+
+    return childNodesHTML;
+  }
+
   createChildNodeDOMElements(context) {
     const childNodes = this.getChildNodes();
 
@@ -188,10 +216,12 @@ ${childNodesHTML}${indent}${closingTag}
       const childNodeNonTerminalNode = childNode.isNonTerminalNode();
 
       if (childNodeNonTerminalNode) {
-        const childNodeDOMElement = childNode.createDOMElement(context);
+        const nonTerminalNode = childNode,  ///
+              markdownNode = nonTerminalNode, ///
+              markdownNodeDOMElement = markdownNode.createDOMElement(context);
 
-        if (childNodeDOMElement !== null) {
-          this.insertDOMElement(childNodeDOMElement);
+        if (markdownNodeDOMElement !== null) {
+          this.insertDOMElement(markdownNodeDOMElement);
         }
       }
     });

package/src/nodeMap.js

@@ -6,8 +6,8 @@ import ImageMarkdownNode from "./node/markdown/image";
 import TableMarkdownNode from "./node/markdown/table";
 import ErrorMarkdownNode from "./node/markdown/error";
 import AnchorMarkdownNode from "./node/markdown/anchor";
-import HeaderMarkdownNode from "./node/markdown/header";
 import ImportMarkdownNode from "./node/markdown/import";
+import ContentsMarkdownNode from "./node/markdown/contents";
 import DivisionMarkdownNode from "./node/markdown/division";
 import FootnoteMarkdownNode from "./node/markdown/footnote";
 import ReferenceMarkdownNode from "./node/markdown/reference";
@@ -38,13 +38,13 @@ import TableHeadCellMarkdownNode from "./node/markdown/tableHeadCell";
 import TableBodyCellMarkdownNode from "./node/markdown/tableBodyCell";
 import TableSeparatorMarkdownNode from "./node/markdown/tableSeparator";
 import EmphasisedTextMarkdownNode from "./node/markdown/emphasisedText";
-import PrimaryHeadingMarkdownNode from "./node/markdown/primaryHeading";
+import PrimaryHeadingMarkdownNode from "./node/markdown/heading/primary";
 import EmptyTableCellMarkdownNode from "./node/markdown/emptyTableCell";
-import TertiaryHeadingMarkdownNode from "./node/markdown/tertiaryHeading";
+import TertiaryHeadingMarkdownNode from "./node/markdown/heading/tertiary";
 import OrderedListItemMarkdownNode from "./node/markdown/orderedListItem";
 import BlockListingEndMarkdownNode from "./node/markdown/blockListingEnd";
-import SecondaryHeadingMarkdownNode from "./node/markdown/secondaryHeading";
-import QuaternaryHeadingMarkdownNode from "./node/markdown/quaternaryHeading";
+import SecondaryHeadingMarkdownNode from "./node/markdown/heading/secondary";
+import QuaternaryHeadingMarkdownNode from "./node/markdown/heading/quaternary";
 import BlockListingStartMarkdownNode from "./node/markdown/blockListingStart";
 import UnorderedListItemMarkdownNode from "./node/markdown/unorderedListItem";
 import StronglyEmphasisedTextMarkdownNode from "./node/markdown/stronglyEmphasisedText";
@@ -55,8 +55,8 @@ import { LINK_RULE_NAME,
          TABLE_RULE_NAME,
          ERROR_RULE_NAME,
          ANCHOR_RULE_NAME,
-         HEADER_RULE_NAME,
          IMPORT_RULE_NAME,
+         CONTENTS_RULE_NAME,
          FOOTNOTE_RULE_NAME,
          DIVISION_RULE_NAME,
          REFERENCE_RULE_NAME,
@@ -105,8 +105,8 @@ const nodeMap = {
   [TABLE_RULE_NAME]: TableMarkdownNode,
   [ERROR_RULE_NAME]: ErrorMarkdownNode,
   [ANCHOR_RULE_NAME]: AnchorMarkdownNode,
-  [HEADER_RULE_NAME]: HeaderMarkdownNode,
   [IMPORT_RULE_NAME]: ImportMarkdownNode,
+  [CONTENTS_RULE_NAME]: ContentsMarkdownNode,
   [FOOTNOTE_RULE_NAME]: FootnoteMarkdownNode,
   [DIVISION_RULE_NAME]: DivisionMarkdownNode,
   [REFERENCE_RULE_NAME]: ReferenceMarkdownNode,

package/src/ruleNameToHTMLMap.js

@@ -6,8 +6,8 @@ import { LINK_RULE_NAME,
          TABLE_RULE_NAME,
          ERROR_RULE_NAME,
          ANCHOR_RULE_NAME,
-         HEADER_RULE_NAME,
          IMPORT_RULE_NAME,
+         CONTENTS_RULE_NAME,
          FOOTNOTE_RULE_NAME,
          DIVISION_RULE_NAME,
          REFERENCE_RULE_NAME,
@@ -28,6 +28,8 @@ import { LINK_RULE_NAME,
          SUB_DIVISION_RULE_NAME,
          ORDERED_LIST_RULE_NAME,
          BLOCK_LISTING_RULE_NAME,
+         CONTENTS_ITEM_RULE_NAME,
+         CONTENTS_LIST_RULE_NAME,
          FOOTNOTE_ITEM_RULE_NAME,
          TABLE_HEAD_ROW_RULE_NAME,
          TABLE_BODY_ROW_RULE_NAME,
@@ -73,14 +75,14 @@ const ruleNameToHTMLMap = {
     tagName: "a",
     className: "anchor"
   },
-  [HEADER_RULE_NAME]: {
-    tagName: null,
-    className: null
-  },
   [IMPORT_RULE_NAME]: {
     tagName: null,
     className: null
   },
+  [CONTENTS_RULE_NAME]: {
+    tagName: "a",
+    className: "contents"
+  },
   [FOOTNOTE_RULE_NAME]: {
     tagName: null,
     className: null
@@ -161,6 +163,14 @@ const ruleNameToHTMLMap = {
     tagName: "pre",
     className: "block"
   },
+  [CONTENTS_ITEM_RULE_NAME]: {
+    tagName: "li",
+    className: "contents"
+  },
+  [CONTENTS_LIST_RULE_NAME]: {
+    tagName: "ul",
+    className: "contents"
+  },
   [FOOTNOTE_ITEM_RULE_NAME]: {
     tagName: "li",
     className: "footnote"

package/src/ruleNames.js

@@ -6,8 +6,8 @@ export const IMAGE_RULE_NAME = "image";
 export const TABLE_RULE_NAME = "table";
 export const ERROR_RULE_NAME = "error";
 export const ANCHOR_RULE_NAME = "anchor";
-export const HEADER_RULE_NAME = "header";
 export const IMPORT_RULE_NAME = "import";
+export const CONTENTS_RULE_NAME = "contents";
 export const FOOTNOTE_RULE_NAME = "footnote";
 export const DIVISION_RULE_NAME = "division";
 export const REFERENCE_RULE_NAME = "reference";
@@ -28,6 +28,8 @@ export const STRONG_TEXT_RULE_NAME = "strongText";
 export const SUB_DIVISION_RULE_NAME = "subDivision";
 export const ORDERED_LIST_RULE_NAME = "orderedList";
 export const BLOCK_LISTING_RULE_NAME = "blockListing";
+export const CONTENTS_ITEM_RULE_NAME = "contentsItem";
+export const CONTENTS_LIST_RULE_NAME = "contentsList";
 export const FOOTNOTE_ITEM_RULE_NAME = "footnoteItem";
 export const TABLE_HEAD_ROW_RULE_NAME = "tableHeadRow";
 export const TABLE_BODY_ROW_RULE_NAME = "tableBodyRow";
@@ -56,8 +58,8 @@ const ruleNames = {
   TABLE_RULE_NAME,
   ERROR_RULE_NAME,
   ANCHOR_RULE_NAME,
-  HEADER_RULE_NAME,
   IMPORT_RULE_NAME,
+  CONTENTS_RULE_NAME,
   FOOTNOTE_RULE_NAME,
   DIVISION_RULE_NAME,
   REFERENCE_RULE_NAME,
@@ -78,6 +80,8 @@ const ruleNames = {
   SUB_DIVISION_RULE_NAME,
   ORDERED_LIST_RULE_NAME,
   BLOCK_LISTING_RULE_NAME,
+  CONTENTS_ITEM_RULE_NAME,
+  CONTENTS_LIST_RULE_NAME,
   FOOTNOTE_ITEM_RULE_NAME,
   TABLE_HEAD_ROW_RULE_NAME,
   TABLE_BODY_ROW_RULE_NAME,