highmark-markdown 1.1.22 → 1.1.24

package/src/node/html/division.js

@@ -1,23 +1,22 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import HTMLNode from "../../node/html";
 import PageNumberHTMLNode from "../../node/html/pageNumber";
 import PageNumberHTMLTransform from "../../transform/html/pageNumber";
 import IndexAnchorHTMLTransform from "../../transform/html/indexAnchor";
+import FootnoteItemHTMLTransform from "../../transform/html/item/footnote";
 import FootnotesListHTMLTransform from "../../transform/html/list/footnotes";
 
 import { DIVISION_MARKDOWN_RULE_NAME } from "../../ruleNames/markdown";
-import { groupHTMLNodes,
-         removeHTMLNodes,
-         addFootnoteHTMLNodes,
-         removeFootnoteHTMLNodes,
-         paginateGroupedHTMLNodes,
-         numberFootnoteLinkHTMLNodes,
-         removeFootnotesDirectiveHTMLNode,
-         removePageNumberDirectiveHTMLNode,
-         removeNestedFootnoteLinkHTMLNodes,
-         lineHTMLTransformsFromFootnoteHTMLTransforms,
-         footnoteItemHTMLTransformsFromLineHTMLTransforms } from "../../utilities/division";
+import { groupHTMLNodes, removeHTMLNodes, paginateGroupedHTMLNodes } from "../../utilities/division";
+import { footnotesHTMLNodesFromNode,
+         footnoteLinkHTMLNodesFromNode,
+         footnotesDirectiveHTMLNodeFromNode,
+         pageNumberDirectiveHTMLNodeFromNode } from "../../utilities/html";
+
+const { extract } = arrayUtilities;
 
 export default class DivisionHTMLNode extends HTMLNode {
   constructor(outerNode, parentNode, childNodes, domElement, divisionClassName) {
@@ -42,41 +41,36 @@ export default class DivisionHTMLNode extends HTMLNode {
     return ruleNme;
   }
 
-  fromFirstHTMLNode(callback) {
-    this.fromFirstChildNode((firstChildNode) => {
-      const firstHTMLNode = firstChildNode;  ///
-
-      callback(firstHTMLNode);
-    });
-  }
+  pageNumber() {
+    const pageNumber = this.fromFirstLastChildNode((firstLastChildNode) => {
+      let pageNumber = null;
 
-  resolve(divisionHTMLNodes, context) {
-    const node = this;
+      const firstLastChildNodePageNumberHTMLNode = (firstLastChildNode instanceof PageNumberHTMLNode);
 
-    removeNestedFootnoteLinkHTMLNodes(node);
+      if (firstLastChildNodePageNumberHTMLNode) {
+        const pageNumberHTMLNode = firstLastChildNode;  ///
 
-    const pageNumberDirectiveHTMLTransform = removePageNumberDirectiveHTMLNode(node),
-          footnotesDirectiveHTMLNode = removeFootnotesDirectiveHTMLNode(node),
-          footnoteHTMLTransforms = removeFootnoteHTMLNodes(node);
+        pageNumber = pageNumberHTMLNode.getPageNumber();
+      }
 
-    if (footnotesDirectiveHTMLNode !== null) {
-      addFootnoteHTMLNodes(footnoteHTMLTransforms, node, context);
-    }
+      return pageNumber;
+    });
 
-    this.paginate(pageNumberDirectiveHTMLTransform, divisionHTMLNodes, context);
+    return pageNumber;
   }
 
-  paginate(pageNumberDirectiveHTMLTransform, divisionHTMLNodes, context) {
-    const node = this,  ///
-          outerNode = this.getOuterNode(),
-          pageNumbers = (pageNumberDirectiveHTMLTransform !== null),
-          identifierMap = {},
-          divisionClassName = outerNode.className(context);
+  paginate(divisionHTMLNodes, context) {
+    const node = this,
+          footnotesDirectiveHTMLNode = footnotesDirectiveHTMLNodeFromNode(node),
+          pageNumberDirectiveHTMLNode = pageNumberDirectiveHTMLNodeFromNode(node);
 
     const htmlNodes = removeHTMLNodes(node),
           groupedHTMLNodesArray = groupHTMLNodes(htmlNodes),
           paginatedHTMLNodesArray = paginateGroupedHTMLNodes(groupedHTMLNodesArray, context);
 
+    const outerNode = this.getOuterNode(),
+          divisionClassName = outerNode.className(context);
+
     paginatedHTMLNodesArray.forEach((paginatedHTMLNodes) => {
       let pageNumber;
 
@@ -84,19 +78,12 @@ export default class DivisionHTMLNode extends HTMLNode {
 
       const divisionHTMLNode = DivisionHTMLNode.fromPaginatedHTMLNodesAndDivisionClassName(paginatedHTMLNodes, divisionClassName);
 
-      divisionHTMLNode.resolveFootnotes(identifierMap, context);
-
-      if (pageNumbers) {
-        const pageNumberHTMLTransform = PageNumberHTMLTransform.fromPageNumber(pageNumber);
-
-        pageNumberHTMLTransform.appendToDivisionHTMLNode(divisionHTMLNode);
-
-        this.fromFirstHTMLNode((firstHTMLNode) => {
-          const indexAnchorHTMLTransform = IndexAnchorHTMLTransform.fromPageNumber(pageNumber),
-                htmlNode = firstHTMLNode;  ///
+      if (footnotesDirectiveHTMLNode !== null) {
+        divisionHTMLNode.resolveFootnotes(context);
+      }
 
-          indexAnchorHTMLTransform.appendToHTMLNode(htmlNode);
-        });
+      if (pageNumberDirectiveHTMLNode !== null) {
+        divisionHTMLNode.resolvePageNumber(pageNumber, context);
       }
 
       divisionHTMLNodes.push(divisionHTMLNode);
@@ -109,43 +96,63 @@ export default class DivisionHTMLNode extends HTMLNode {
     });
   }
 
-  pageNumber() {
-    const pageNumber = this.fromFirstLastChildNode((firstLastChildNode) => {
-      let pageNumber = null;
+  resolveFootnotes(context) {
+    const node = this,  ///
+          footnoteHTMLNodes = footnotesHTMLNodesFromNode(node),
+          footnoteLinkHTMLNodes = footnoteLinkHTMLNodesFromNode(node);
 
-      const firstLastChildNodePageNumberHTMLNode = (firstLastChildNode instanceof PageNumberHTMLNode);
+    let start = 0;
 
-      if (firstLastChildNodePageNumberHTMLNode) {
-        const pageNumberHTMLNode = firstLastChildNode;  ///
+    const footnoteItemHTMLTransforms = [];
 
-        pageNumber = pageNumberHTMLNode.getPageNumber();
-      }
+    footnoteLinkHTMLNodes.forEach((footnoteLinkHTMLNode) => {
+      const identifier = footnoteLinkHTMLNode.identifier(context),
+            footnoteHTMLNode = extract(footnoteHTMLNodes, (footnoteHTMLNode) => {
+              const identifierMatches = footnoteHTMLNode.matchIdentifier(identifier);
 
-      return pageNumber;
-    });
+              if (identifierMatches) {
+                return true;
+              }
+            }) || null;
 
-    return pageNumber;
-  }
+      if (footnoteHTMLNode !== null) {
+        const number = start; ///
 
-  resolveFootnotes(identifierMap, context) {
-    let footnotesListHTMLTransform = null;
+        footnoteLinkHTMLNode.setNumber(number);
 
-    const node = this,  ///
-          footnoteHTMLTransforms = removeFootnoteHTMLNodes(node),
-          footnoteHTMLTransformsLength = footnoteHTMLTransforms.length;
+        const paragraphHTMLNode = footnoteHTMLNode.getParagraphHTMLNode(),
+              footnoteItemHTMLTransform = FootnoteItemHTMLTransform.fromParagraphHTMLNOdeAndIdentifier(paragraphHTMLNode, identifier)
 
-    if (footnoteHTMLTransformsLength > 0) {
-      const divisionHTMLNode = node,  ///
-            start = numberFootnoteLinkHTMLNodes(footnoteHTMLTransforms, identifierMap, node, context),
-            lineHTMLTransforms = lineHTMLTransformsFromFootnoteHTMLTransforms(footnoteHTMLTransforms),
-            footnoteItemHTMLTransforms = footnoteItemHTMLTransformsFromLineHTMLTransforms(lineHTMLTransforms, identifierMap, start);
+        footnoteItemHTMLTransforms.push(footnoteItemHTMLTransform);
 
-      footnotesListHTMLTransform = FootnotesListHTMLTransform.fromStartAndFootnoteItemHTMLTransforms(start, footnoteItemHTMLTransforms);
+        start++;
+      } else {
+        footnoteLinkHTMLNode.resetNumber()
+      }
+    });
+
+    const footnoteItemHTMLTransformsLength = footnoteItemHTMLTransforms.length;
+
+    if (footnoteItemHTMLTransformsLength > 0) {
+      const divisionHTMLNode = node,  ///
+            footnotesListHTMLTransform = FootnotesListHTMLTransform.fromStartAndFootnoteItemHTMLTransforms(start, footnoteItemHTMLTransforms);
 
       footnotesListHTMLTransform.appendToDivisionHTMLNode(divisionHTMLNode);
     }
+  }
+
+  resolvePageNumber(pageNumber, context) {
+    const divisionHTMLNode = this,  ///
+          pageNumberHTMLTransform = PageNumberHTMLTransform.fromPageNumber(pageNumber);
+
+    pageNumberHTMLTransform.appendToDivisionHTMLNode(divisionHTMLNode);
 
-    return footnotesListHTMLTransform;
+    this.fromFirstChildNode((firstChildNode) => {
+      const indexAnchorHTMLTransform = IndexAnchorHTMLTransform.fromPageNumber(pageNumber),
+            htmlNode = firstChildNode;  ///
+
+      indexAnchorHTMLTransform.appendToHTMLNode(htmlNode);
+    });
   }
 
   asString() {

package/src/node/html/footnote.js

@@ -4,6 +4,27 @@ import HTMLNode from "../../node/html";
 import {EMPTY_STRING} from "../../constants";
 
 export default class FootnoteHTMLNode extends HTMLNode {
+  getParagraphHTMLNode() {
+    const paragraphHTMLNode = this.fromSecondChildNode((secondChildNode) => {
+      const paragraphHTMLNode = secondChildNode;  ///
+
+      return paragraphHTMLNode;
+    });
+
+    return paragraphHTMLNode;
+  }
+
+  matchIdentifier(identifier, context) {
+    const identifierA = identifier; ///
+
+    identifier = this.identifier(context);
+
+    const identifierB = identifier, ///
+          identifierMatches = (identifierA === identifierB);
+
+    return identifierMatches;
+  }
+
   identifier(context) {
     const markdownNode = this.getMarkdownNode(),
           identifier = markdownNode.identifier(context);

package/src/node/html/heading/index.js

@@ -56,7 +56,7 @@ export default class IndexHeadingHTMLNode extends HTMLNode {
       domElement = this.getDOMElement();
 
       const parentDOMElement = domElement,  ///
-            firstChild = domElement.firstChild
+            firstChild = domElement.firstChild;
 
       domElement = firstChild;  ///
 

package/src/node/html/item/footnote.js

@@ -24,13 +24,12 @@ export default class FootnoteItemHTMLNode extends HTMLNode {
 
   static className = "footnote";
 
-  static fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier) {
+  static fromParagraphTMLNodeAndIdentifier(paragraphHTMLNode, identifier) {
     const prepend = FOOTNOTE_PREPEND,
           anchorHTMLNode = AnchorHTMLNode.fromPrependAndIdentifier(prepend, identifier),
-          lineHTMLNode = lineHTMLTransform.getLineHTMLNode(),
           childHTMLNodes = [
             anchorHTMLNode,
-            lineHTMLNode
+            paragraphHTMLNode
           ],
           footnoteItemHTMLNode = HTMLNode.fromChildHTMLNodes(FootnoteItemHTMLNode, childHTMLNodes);
 

package/src/node/html/link/email.js

@@ -88,7 +88,7 @@ export default class EmailLinkHTMLNode extends HTMLNode {
       domElement = this.getDOMElement();
 
       const parentDOMElement = domElement,  ///
-            firstChild = domElement.firstChild
+            firstChild = domElement.firstChild;
 
       domElement = firstChild;  ///
 

package/src/node/html/link/footnote.js

@@ -22,10 +22,12 @@ export default class FootnoteLinkHTMLNode extends HTMLNode {
     this.number = number;
   }
 
+  resetNumber() {
+    this.number = null;
+  }
+
   content(context) {
-    const content = (this.number !== null) ?
-                       this.number :
-                         EMPTY_STRING;
+    const content = this.number;  ///
 
     return content;
   }
@@ -52,68 +54,82 @@ export default class FootnoteLinkHTMLNode extends HTMLNode {
   }
 
   mount(parentDOMElement, siblingDOMElement, context) {
-    let domElement;
+    if (this.number !== null) {
+      let domElement;
 
-    domElement = this.createDOMElement(context);
+      domElement = this.createDOMElement(context);
 
-    this.setDOMElement(domElement);
+      this.setDOMElement(domElement);
 
-    (siblingDOMElement !== null) ?
-      insertAfter(domElement, parentDOMElement, siblingDOMElement) :
-        insertBeforehand(domElement, parentDOMElement);
+      (siblingDOMElement !== null) ?
+        insertAfter(domElement, parentDOMElement, siblingDOMElement) :
+          insertBeforehand(domElement, parentDOMElement);
 
-    parentDOMElement = domElement; ///
+      parentDOMElement = domElement; ///
 
-    const content = this.content(context),
-          textNode = document.createTextNode(content);
+      const content = this.content(context),
+            textNode = document.createTextNode(content);
 
-    domElement = textNode;  ///
+      domElement = textNode;  ///
 
-    insertAfterwards(domElement, parentDOMElement);
+      insertAfterwards(domElement, parentDOMElement);
 
-    domElement = this.getDOMElement();
+      domElement = this.getDOMElement();
 
-    siblingDOMElement = domElement; ///
+      siblingDOMElement = domElement; ///
+    }
 
     return siblingDOMElement;
   }
 
   unmount(parentDOMElement) {
-    let domElement;
+    if (this.number !== null) {
+      let domElement;
 
-    {
-      domElement = this.getDOMElement();
+      {
+        domElement = this.getDOMElement();
 
-      const parentDOMElement = domElement,  ///
-            firstChild = domElement.firstChild
+        const parentDOMElement = domElement,  ///
+              firstChild = domElement.firstChild;
 
-      domElement = firstChild;  ///
+        domElement = firstChild;  ///
 
-      remove(domElement, parentDOMElement);
-    }
+        remove(domElement, parentDOMElement);
+      }
 
-    domElement = this.getDOMElement();
+      domElement = this.getDOMElement();
 
-    remove(domElement, parentDOMElement);
+      remove(domElement, parentDOMElement);
 
-    this.resetDOMElement();
+      this.resetDOMElement();
+    }
   }
 
   asHTML(indent, context) {
     let html;
 
-    indent = this.adjustIndent(indent);
+    if (this.number === null) {
+      html = EMPTY_STRING;
+    } else {
+      indent = this.adjustIndent(indent);
 
-    const childNodesHTML = this.childNodesAsHTML(indent, context),
-          startingTag = this.startingTag(context),
-          closingTag = this.closingTag(context);
+      const childNodesHTML = this.childNodesAsHTML(indent, context),
+            startingTag = this.startingTag(context),
+            closingTag = this.closingTag(context);
 
-    html = `${indent}${startingTag}${childNodesHTML}${closingTag}
+      html = `${indent}${startingTag}${childNodesHTML}${closingTag}
 `;
+    }
 
     return html;
   }
 
+  asPlainText(context) {
+    const plainText = EMPTY_STRING;
+
+    return plainText;
+  }
+
   childNodesAsHTML(indent, context) {
     const content = this.content(context),
           childNodesHTML = content; ///

package/src/node/html/topmost.js

@@ -4,8 +4,6 @@ import HTMLNode from "../../node/html";
 import IndexHTMLTransform from "../../transform/html/index";
 import DivisionHTMLTransform from "../../transform/html/division";
 import ContentsListHTMLTransform from "../../transform/html/list/contents";
-import IndexDirectiveHTMLTransform from "../../transform/html/directive/index";
-import ContentsDirectiveHTMLTransform from "../../transform/html/directive/contents";
 
 import { HTML_MARKDOWN_RULE_NAME } from "../../ruleNames/markdown";
 import { divisionHTMLNodesFromNode, indexDirectiveHTMLNodeFromNode, contentsDirectiveHTMLNodeFromNode } from "../../utilities/html";
@@ -54,7 +52,7 @@ export default class TopmostHTMLNode extends HTMLNode {
     divisionHTMLTransforms.forEach((divisionHTMLTransform) => {
       divisionHTMLTransform.remove();
 
-      divisionHTMLTransform.resolve(divisionHTMLNodes, context);
+      divisionHTMLTransform.paginate(divisionHTMLNodes, context);
     });
 
     delete context.pageNumber;
@@ -77,12 +75,11 @@ export default class TopmostHTMLNode extends HTMLNode {
     }
 
     const divisionHTMLNodes = this.getDivisionHTMLNodes(),
-          indexDirectiveHTMLTransform = IndexDirectiveHTMLTransform.fromIndexDirectiveHTMLNode(indexDirectiveHTMLNode),
-          indexHTMLTransform = IndexHTMLTransform.fromIndexDirectiveHTMLTransformAndDivisionHTMLNodes(indexDirectiveHTMLTransform, divisionHTMLNodes, context);
+          indexHTMLTransform = IndexHTMLTransform.fromIndexDirectiveHTMLNodeAndDivisionHTMLNodes(indexDirectiveHTMLNode, divisionHTMLNodes, context);
 
-    (indexHTMLTransform !== null) ?
-      indexHTMLTransform.replaceIndexDirectiveHTMLTransform(indexDirectiveHTMLTransform) :
-        indexDirectiveHTMLTransform.remove();
+    if (indexHTMLTransform !== null) {
+      indexHTMLTransform.addAfterIndexDirectiveHTMLNode(indexDirectiveHTMLNode);
+    }
   }
 
   addContents(context) {
@@ -94,12 +91,11 @@ export default class TopmostHTMLNode extends HTMLNode {
     }
 
     const topmostHTMLNode = this, ///
-          contentsDirectiveHTMLTransform = ContentsDirectiveHTMLTransform.fromContentsDirectiveHTMLNode(contentsDirectiveHTMLNode),
-          contentsListHTMLTransform = ContentsListHTMLTransform.fromContentsDirectiveHTMLTransformAndTopmostHTMLNode(contentsDirectiveHTMLTransform, topmostHTMLNode, context);
+          contentsListHTMLTransform = ContentsListHTMLTransform.fromContentsDirectiveHTMLNodeAndTopmostHTMLNode(contentsDirectiveHTMLNode, topmostHTMLNode, context);
 
-    (contentsListHTMLTransform !== null) ?
-      contentsListHTMLTransform.replaceContentsDirectiveHTMLTransform(contentsDirectiveHTMLTransform) :
-        contentsDirectiveHTMLTransform.remove();
+    if (contentsListHTMLTransform !== null) {
+      contentsListHTMLTransform.addAfterContentsDirectiveHTMLNode(contentsDirectiveHTMLNode);
+    }
   }
 
   adjustIndent(indent) {

package/src/transform/html/division.js

@@ -18,10 +18,10 @@ export default class DivisionHTMLTransform extends HTMLTransform {
     parentNode.appendChildNode(childNode);
   }
 
-  resolve(divisionHTMLNodes, context) {
+  paginate(divisionHTMLNodes, context) {
     const divisionHTMLNode = this.getDivisionHTMLNode();
 
-    divisionHTMLNode.resolve(divisionHTMLNodes, context);
+    divisionHTMLNode.paginate(divisionHTMLNodes, context);
   }
 
   static fromDivisionHTMLNode(divisionHTMLNode) {

package/src/transform/html/footnote.js

@@ -10,17 +10,6 @@ export default class FootnoteHTMLTransform extends HTMLTransform {
     return identifier;
   }
 
-  getLineHTMLNode() {
-    const paragraphHTMLNode = this.getParagraphHTMLNode(),
-          lineHTMLNode = paragraphHTMLNode.fromFirstChildNode((firstChildNode) => {
-            const lineHTMLNode = firstChildNode;  ///
-
-            return lineHTMLNode;
-          });
-
-    return lineHTMLNode;
-  }
-
   getFootnoteHTMLNode() {
     const htmlNode = this.getHTMLNode(),
           footnoteHTMLNode = htmlNode;  ///
@@ -39,22 +28,11 @@ export default class FootnoteHTMLTransform extends HTMLTransform {
     return paragraphHTMLNode;
   }
 
-  matchIdentifier(identifier, context) {
-    const identifierA = identifier; ///
-
-    identifier = this.identifier(context);
-
-    const identifierB = identifier, ///
-          identifierMatches = (identifierA === identifierB);
-
-    return identifierMatches;
-  }
-
   addAfterFootnoteLinkHTMLTransform(footnoteLinkHTMLTransform) {
     const containingHTMLNode = footnoteLinkHTMLTransform.getContainingHTMLNode(),
-          existingHTMLNode = containingHTMLNode;  ///
+          siblingHTMLNode = containingHTMLNode;  ///
 
-    this.addAfter(existingHTMLNode);
+    this.addAfter(siblingHTMLNode);
   }
 
   static fromFootnoteHTMLNode(footnoteHTMLNde) {

package/src/transform/html/index.js

@@ -17,26 +17,26 @@ export default class IndexHTMLTransform extends HTMLTransform {
     return this.htmlNodes;
   }
 
-  replace(replacedHTMLNode) {
-    const parentNode = replacedHTMLNode.getParentNode(),
-          replacedChildNode = replacedHTMLNode, ///
-          replacementChildNodes = this.htmlNodes; ///
-
-    parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);
+  addAfter(siblingHTMLNode) {
+    const childNode = siblingHTMLNode,  ///
+          parentNode = childNode.getParentNode(),
+          index = parentNode.indexOfChildNode(childNode),
+          startIndex = index + 1,
+          addedChildNodes = this.htmlNodes;  ///
+
+    parentNode.addChildNodes(addedChildNodes, startIndex);
   }
 
-  replaceIndexDirectiveHTMLTransform(indexDirectiveHTMLTransform) {
-    const indexDirectiveHTMLNode = indexDirectiveHTMLTransform.getIndexDirectiveHTMLNode(),
-          replacedHTMLNode = indexDirectiveHTMLNode;  ///
+  addAfterIndexDirectiveHTMLNode(indexDirectiveHTMLNode) {
+    const siblingHTMLNode = indexDirectiveHTMLNode;  ///
 
-    this.replace(replacedHTMLNode)
+    this.addAfter(siblingHTMLNode);
   }
 
-  static fromIndexDirectiveHTMLTransformAndDivisionHTMLNodes(indexDirectiveHTMLTransform, divisionHTMLNodes, context) {
+  static fromIndexDirectiveHTMLNodeAndDivisionHTMLNodes(indexDirectiveHTMLNode, divisionHTMLNodes, context) {
     let indexHTMLTransform = null;
 
-    const indexDirectiveHTMLNode = indexDirectiveHTMLTransform.getIndexDirectiveHTMLNode(),
-          indexList = IndexList.fromIndexDirectiveHTMLNodeAndDivisionHTMLNodes(indexDirectiveHTMLNode, divisionHTMLNodes, context),
+    const indexList = IndexList.fromIndexDirectiveHTMLNodeAndDivisionHTMLNodes(indexDirectiveHTMLNode, divisionHTMLNodes, context),
           indexHTMLTransforms = [];
 
     letters.forEach((letter) => {

package/src/transform/html/indexAnchor.js

@@ -9,7 +9,7 @@ export default class IndexAnchorTMLTransform extends HTMLTransform {
   appendToHTMLNode(htmlNode) {
     const parentHTMLNode = htmlNode;  ///
 
-    this.appendTo(parentHTMLNode);
+    this.prependTo(parentHTMLNode);
   }
 
   static fromPageNumber(pageNumber) {

package/src/transform/html/item/footnote.js

@@ -11,10 +11,10 @@ export default class FootnoteItemHTMLTransform extends HTMLTransform {
     return footnoteItemHTMLNode;
   }
 
-  static fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier) {
-    const footnoteItemHTMLNode = FootnoteItemHTMLNode.fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier),
-          ascendantNode = footnoteItemHTMLNode, ///
-          footnoteItemTransform = lineHTMLTransform.expand(FootnoteItemHTMLTransform, ascendantNode);
+  static fromParagraphHTMLNOdeAndIdentifier(paragraphHTMLNode, identifier) {
+    const footnoteItemHTMLNode = FootnoteItemHTMLNode.fromParagraphTMLNodeAndIdentifier(paragraphHTMLNode, identifier),
+          htmlNode = footnoteItemHTMLNode, ///
+          footnoteItemTransform = HTMLTransform.fromHTMLNode(FootnoteItemHTMLTransform, htmlNode);
 
     return footnoteItemTransform;
   }

package/src/transform/html/line.js

@@ -16,12 +16,4 @@ export default class LineHTMLTransform extends HTMLTransform {
 
     return paragraphHTMLTransform;
   }
-
-  static fromFootnoteHTMLTransform(footnoteHTMLTransform) {
-    const lineHTMLNode = footnoteHTMLTransform.getLineHTMLNode(),
-          htmlNode = lineHTMLNode, ///
-          paragraphHTMLTransform = HTMLTransform.fromHTMLNode(LineHTMLTransform, htmlNode);
-
-    return paragraphHTMLTransform;
-  }
 }

package/src/transform/html/list/contents.js

@@ -14,19 +14,17 @@ const { filter } = arrayUtilities,
       { isLessThan } = nodeUtilities;
 
 class ContentsListHTMLTransform extends HTMLTransform {
-  replaceContentsDirectiveHTMLTransform(contentsDirectiveHTMLTransform) {
-    const contentsDirectiveHTMLNode = contentsDirectiveHTMLTransform.getContentsDirectiveHTMLNode(),
-          replacedHTMLNode = contentsDirectiveHTMLNode;  ///
+  addAfterContentsDirectiveHTMLNode(contentsDirectiveHTMLNode) {
+    const siblingHTMLNode = contentsDirectiveHTMLNode;  ///
 
-    super.replace(replacedHTMLNode);
+    super.addAfter(siblingHTMLNode);
   }
 
-  static fromContentsDirectiveHTMLTransformAndTopmostHTMLNode(contentsDirectiveHTMLTransform, topmostHTMLNode, context) {
+  static fromContentsDirectiveHTMLNodeAndTopmostHTMLNode(contentsDirectiveHTMLNode, topmostHTMLNode, context) {
     let contentsListHTMLTransform = null;
 
     const node = topmostHTMLNode, ///
-          headingHTMLNodes = headingHTMLNodesFromNode(node),
-          contentsDirectiveHTMLNode = contentsDirectiveHTMLTransform.getContentsDirectiveHTMLNode();
+          headingHTMLNodes = headingHTMLNodesFromNode(node);
 
     filter(headingHTMLNodes, (headingHTMLNode) => {
       const contentsDirectiveHTMLNodeLessThanHeadingHTMLNode = isLessThan(contentsDirectiveHTMLNode, headingHTMLNode);