highmark-markdown 1.0.176 → 1.0.178

package/src/node/html/listing/inline.js

@@ -3,6 +3,8 @@
 import HTMLNode from "../../../node/html";
 
 export default class InlineListingHTMLNode extends HTMLNode {
+  content(context) { return this.outerNode.content(context); }
+
   createDOMElement(context) {
     let domElement;
 

package/src/node/html/topmost.js

@@ -1,69 +1,38 @@
 "use strict";
 
-import { nodeUtilities} from "occam-dom";
-import { arrayUtilities } from "necessary";
-
-import queries from "../../queries";
 import HTMLNode from "../../node/html";
-import htmlNodeMap from "../../map/node/html";
 
-const { push } = arrayUtilities,
-      { topmostNodeFromOuterNodes } = nodeUtilities;
+import { HTML_RULE_NAME } from "../../ruleNames";
+import { divisionHTMLNodesFromNode } from "../../utilities/html";
 
 export default class TopmostHTMLNode extends HTMLNode {
   adjustIndent(indent) {
     return indent;
   }
 
-  asString() {
-    const { tagName } = this.constructor,
-          string = tagName; ///
-
-    return string;
-  }
-
-  static tagName = "html";
-
-  static className = null;
-
-  static fromNothing() { return HTMLNode.fromNothing(TopmostHTMLNode); }
-
-  static fromTopmostMarkdownNode(topmostMarkdownNode) {
+  getRuleName() {
+    const ruleName = HTML_RULE_NAME;
 
+    return ruleName;
   }
 
-  static fromDivisionMarkdownNode(divisionMarkdownNode) {
-    const node = divisionMarkdownNode,  ///
-          nodes = nodesFromNodeAndQueries(node, queries),
-          topmostHTMLNode = topmostNodeFromOuterNodes(ClassFromOuterNode, nodes);
+  getDivisionHTMLNodes() {
+    const node = this,  ///
+          divisionHTMLNodes = divisionHTMLNodesFromNode(node);
 
-    return topmostHTMLNode;
+    return divisionHTMLNodes;
   }
-}
-
-function ClassFromOuterNode(outerNode) {
-  let Class;
 
-  if (outerNode === null) {
-    Class = TopmostHTMLNode;  ///
-  } else {
-    const nonTerminalNode = outerNode,  ///
-      ruleName = nonTerminalNode.getRuleName();
+  getDivisionHTMLNodeAt(index) {
+    const divisionHTMLNodes = this.getDivisionHTMLNodes(),
+          divisionHTMLNode = divisionHTMLNodes[index] || null;
 
-    Class = htmlNodeMap[ruleName] || HTMLNode;
+    return divisionHTMLNode;
   }
 
-  return Class;
-}
-
-function nodesFromNodeAndQueries(node, queries) {
-  const nodes = [];
-
-  queries.forEach((query) => {
-    const queryNodes = query.execute(node);
+  static tagName = "html";
 
-    push(nodes, queryNodes);
-  });
+  static className = null;
 
-  return nodes;
+  static fromNothing() { return HTMLNode.fromNothing(TopmostHTMLNode); }
 }

package/src/node/html.js

@@ -30,6 +30,18 @@ class HTMLNode extends Node {
 
   getRuleName() { return this.outerNode.getRuleName(); }
 
+  isTerminalNode() {
+    const terminalNode = false;
+
+    return terminalNode;
+  }
+
+  isNonTerminalNode() {
+    const nonTerminalNode = true;
+
+    return nonTerminalNode;
+  }
+
   adjustIndent(indent) {
     indent = (indent === null) ?
                EMPTY_STRING :

package/src/node/markdown/directive/embee.js

@@ -2,11 +2,32 @@
 
 import MarkdownNode from "../../../node/markdown";
 import PathMarkdownNode from "../../../node/markdown/path";
-import EmbedDirectiveTransform from "../../../transform/embedDirective";
+import EmbedDirectiveMarkdownTransform from "../../../transform/markdown/directive/embed";
+
+import { divisionMarkdownNodeFromNode, subDivisionMarkdownNodeFromNode } from "../../../utilities/markdown";
 
 export default class EmbedDirectiveMarkdownNode extends MarkdownNode {
-  resolve(context) {
-    let embedDirectiveTransform = null;
+  filePath(context) {
+    const filePath = this.fromFirstLastChildNode((firstLastChildNode) => {
+      let filePath = null;
+
+      const firstLastChildNodePathMarkdownNode = (firstLastChildNode instanceof PathMarkdownNode);
+
+      if (firstLastChildNodePathMarkdownNode) {
+        const pathMarkdownNode = firstLastChildNode, ///
+              pathMarkdownNodePath = pathMarkdownNode.path(context);
+
+        filePath = pathMarkdownNodePath; ///
+      }
+
+      return filePath;
+    });
+
+    return filePath;
+  }
+
+  resolveEmbedding(context) {
+    let embedDirectiveMarkdownTransform = null;
 
     const filePath = this.filePath(context);
 
@@ -22,33 +43,24 @@ export default class EmbedDirectiveMarkdownNode extends MarkdownNode {
         delete context.importedNode;
         delete context.importedTokens;
 
-        const divisionMarkdownNode = importedNode,  ///
-              tokens = importedTokens;  ///
+        const node = importedNode,  ///
+              divisionMarkdownNode = divisionMarkdownNodeFromNode(node);
 
-        embedDirectiveTransform = EmbedDirectiveTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
-      }
-    }
-
-    return embedDirectiveTransform;
-  }
-
-  filePath(context) {
-    const filePath = this.fromFirstLastChildNode((firstLastChildNode) => {
-      let filePath = null;
+        if (divisionMarkdownNode !== null) {
+          const node = divisionMarkdownNode,  ///
+                tokens = importedTokens,  ///
+                subDivisionMarkdownNode = subDivisionMarkdownNodeFromNode(node);
 
-      const firstLastChildNodePathMarkdownNode = (firstLastChildNode instanceof PathMarkdownNode);
+          if (subDivisionMarkdownNode !== null) {
+            divisionMarkdownNode.removeSubDivisionMarkdownNode(subDivisionMarkdownNode);
 
-      if (firstLastChildNodePathMarkdownNode) {
-        const pathMarkdownNode = firstLastChildNode, ///
-              pathMarkdownNodePath = pathMarkdownNode.path(context);
-
-        filePath = pathMarkdownNodePath; ///
+            embedDirectiveMarkdownTransform = EmbedDirectiveMarkdownTransform.fromSubDivisionMarkdownNodeAndTokens(subDivisionMarkdownNode, tokens);
+          }
+        }
       }
+    }
 
-      return filePath;
-    });
-
-    return filePath;
+    return embedDirectiveMarkdownTransform;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(EmbedDirectiveMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/directive/include.js

@@ -2,11 +2,32 @@
 
 import MarkdownNode from "../../../node/markdown";
 import PathMarkdownNode from "../../../node/markdown/path";
-import IncludeDirectiveTransform from "../../../transform/includeDirective";
+import IncludeDirectiveMarkdownTransform from "../../../transform/markdown/directive/include";
+
+import { divisionMarkdownNodeFromNode } from "../../../utilities/markdown";
 
 export default class IncludeDirectiveMarkdownNode extends MarkdownNode {
-  resolve(context) {
-    let includeDirectiveTransform = null;
+  filePath(context) {
+    const filePath = this.fromFirstLastChildNode((firstLastChildNode) => {
+      let filePath = null;
+
+      const firstLastChildNodePathMarkdownNode = (firstLastChildNode instanceof PathMarkdownNode);
+
+      if (firstLastChildNodePathMarkdownNode) {
+        const pathMarkdownNode = firstLastChildNode, ///
+              pathMarkdownNodePath = pathMarkdownNode.path(context);
+
+        filePath = pathMarkdownNodePath; ///
+      }
+
+      return filePath;
+    });
+
+    return filePath;
+  }
+
+  resolveInclude(context) {
+    let includeDirectiveMarkdownTransform = null;
 
     const filePath = this.filePath(context);
 
@@ -24,36 +45,24 @@ export default class IncludeDirectiveMarkdownNode extends MarkdownNode {
         delete context.importedTokens;
         delete context.importedClassName;
 
-        const divisionMarkdownNode = importedNode,  ///
-              divisionClassName = importedClassName,  ///
-              tokens = importedTokens;  ///
+        const node = importedNode,  ///
+              divisionMarkdownNode = divisionMarkdownNodeFromNode(node);
 
-        divisionMarkdownNode.setDivisionClassName(divisionClassName);
+        if (divisionMarkdownNode !== null) {
+          const topmostMarkdownNode = node, ///
+                divisionClassName = importedClassName,  ///
+                tokens = importedTokens;  ///
 
-        includeDirectiveTransform = IncludeDirectiveTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
-      }
-    }
-
-    return includeDirectiveTransform;
-  }
-
-  filePath(context) {
-    const filePath = this.fromFirstLastChildNode((firstLastChildNode) => {
-      let filePath = null;
+          topmostMarkdownNode.removeDivisionMarkdownNode(divisionMarkdownNode);
 
-      const firstLastChildNodePathMarkdownNode = (firstLastChildNode instanceof PathMarkdownNode);
+          divisionMarkdownNode.setDivisionClassName(divisionClassName);
 
-      if (firstLastChildNodePathMarkdownNode) {
-        const pathMarkdownNode = firstLastChildNode, ///
-              pathMarkdownNodePath = pathMarkdownNode.path(context);
-
-        filePath = pathMarkdownNodePath; ///
+          includeDirectiveMarkdownTransform = IncludeDirectiveMarkdownTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
+        }
       }
+    }
 
-      return filePath;
-    });
-
-    return filePath;
+    return includeDirectiveMarkdownTransform;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IncludeDirectiveMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/division.js

@@ -1,64 +1,11 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
-import IndexTransform from "../../transform/index";
-import FootnoteTransform from "../../transform/footnote";
-import IndexAnchorTransform from "../../transform/indexAnchor";
-import ContentsListTransform from "../../transform/contentsList";
-import FootnotesListTransform from "../../transform/footnotesList";
-import FootnoteDivisionTransform from "../../transform/subDivision/footnote";
-import EmbedDirectivesDivisionTransform from "../../transform/subDivision/embedDirectives";
-import IncludeDirectivesDivisionTransform from "../../transform/subDivision/includeDirectives";
-import IndexDirectiveDivisionTransform from "../../transform/subDivision/indexDirective";
-import ContentsDirectiveDivisionTransform from "../../transform/subDivision/contentsDirective";
-import FootnotesDirectiveDivisionTransform from "../../transform/subDivision/footnotesDirective";
-import PageNumberDirectiveDivisionTransform from "../../transform/subDivision/pageNumberDirective";
-
-import { DIVISION_RULE_NAME } from "../../ruleNames";
-import { renumberFootnoteLinkMarkdownNodes } from "../../utilities/footnotes";
-import { subDivisionMarkdownNodesFromNode, ignoreDirectiveMarkdownNodeFromNode, pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
-
-const { clear, filter } = arrayUtilities;
-
-export default class DivisionMarkdownNode extends MarkdownNode {
-  resolveIncludes(context) {
-    const divisionMarkdownNode = this, ///
-          includeDirectivesDivisionTransform = IncludeDirectivesDivisionTransform.fromDivisionMarkdownNode(divisionMarkdownNode, context);
-
-    if (includeDirectivesDivisionTransform !== null) {
-      includeDirectivesDivisionTransform.removeDivisionMarkdownNode(divisionMarkdownNode, context);
-    }
-  }
-
-  resolveEmbeddings(divisionMarkdownNode, context) {
-    const divisionMarkdownNode = this, ///
-          embedDirectivesDivisionTransform = EmbedDirectivesDivisionTransform.fromDivisionMarkdownNode(divisionMarkdownNode, context);
-
-    if (embedDirectivesDivisionTransform !== null) {
-      const subDivisionMarkdownNodes = embedDirectivesDivisionTransform.replaceDivisionMarkdownNode(divisionMarkdownNode, context);
-
-      subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
-        subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
-      });
-    }
-  }
-
-  className(context) {
-    const className = this.divisionClassName; ///
+import IgnoreDirectiveMarkdownTransform from "../../transform/markdown/directive/ignore";
 
-    return className;
-  }
-
-  isIgnored() {
-    const node = this,  ///
-          ignoreDirectiveMarkdownNode = ignoreDirectiveMarkdownNodeFromNode(node),
-          ignored = (ignoreDirectiveMarkdownNode !== null);
-
-    return ignored;
-  }
+import { ignoreDirectiveMarkdownNodeFromNode, subDivisionMarkdownNodesFromNode, includeDirectiveMarkdownNodesFromNode } from "../../utilities/markdown";
 
+export default class DivisionMarkdownNode extends MarkdownNode {
   // getPageNumber() {
   //   let pageNumber = null;
   //
@@ -193,120 +140,190 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   //     footnoteTransformMap[identifier] = footnoteTransform;
   //   });
   // }
+  //
+  // findDivisionTransform(DivisionTransform, context) {
+  //   let subDivisionTransform = null;
+  //
+  //   const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
+  //
+  //   subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
+  //     subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
+  //
+  //     if (subDivisionTransform !== null) {
+  //       return true;
+  //     }
+  //   });
+  //
+  //   return subDivisionTransform;
+  // }
+  //
+  // findDivisionTransforms(DivisionTransform, context) {
+  //   const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes(),
+  //         subDivisionTransforms = subDivisionMarkdownNodes.reduce((subDivisionTransforms, subDivisionMarkdownNode) => {
+  //           const subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
+  //
+  //           if (subDivisionTransform !== null) {
+  //             subDivisionTransforms.push(subDivisionTransform);
+  //           }
+  //
+  //           return subDivisionTransforms;
+  //         }, []);
+  //
+  //   return subDivisionTransforms;
+  // }
+  //
+  // findPageNumberDirectiveMarkdownNode() {
+  //   let pageNumberDirectiveMarkdownNode = null;
+  //
+  //   const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
+  //
+  //   subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
+  //     const node = subDivisionMarkdownNode; ///
+  //
+  //     pageNumberDirectiveMarkdownNode = pageNumberDirectiveMarkdownNodeFromNode(node);
+  //
+  //     if (pageNumberDirectiveMarkdownNode !== null) {
+  //       return true;
+  //     }
+  //   });
+  //
+  //   return pageNumberDirectiveMarkdownNode;
+  // }
+  //
+  // removeSubDivisionMarkdownNode(subDivisionMarkdownNode) {
+  //   const childNode = subDivisionMarkdownNode;  ///
+  //
+  //   this.removeChildNode(childNode);
+  // }
+  //
+  // createFootnotesListTransform(footnoteTransformMap, context) {
+  //   const footnoteDivisionTransforms = this.findDivisionTransforms(FootnoteDivisionTransform, context);
+  //
+  //   footnoteDivisionTransforms.forEach((footnoteDivisionTransform) => {
+  //     const footnoteTransform = FootnoteTransform.fromFootnoteDivisionTransform(footnoteDivisionTransform),
+  //           identifier = footnoteDivisionTransform.identifier(context);
+  //
+  //     footnoteTransformMap[identifier] = footnoteTransform;
+  //   });
+  //
+  //   const divisionMarkdownNode = this,  ///
+  //         footnotesListDivisionTransform = FootnotesListTransform.fromDivisionMarkdownNodeAndFootnoteTransformMap(divisionMarkdownNode, footnoteTransformMap, context);
+  //
+  //   return footnotesListDivisionTransform;
+  // }
 
-  findDivisionTransform(DivisionTransform, context) {
-    let subDivisionTransform = null;
-
-    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
-
-    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
-      subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
-
-      if (subDivisionTransform !== null) {
-        return true;
-      }
-    });
+  constructor(ruleName, parentNode, childNodes, opacity, precedence, divisionClassName) {
+    super(ruleName, parentNode, childNodes, opacity, precedence);
 
-    return subDivisionTransform;
+    this.divisionClassName = divisionClassName;
   }
 
-  findDivisionTransforms(DivisionTransform, context) {
-    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes(),
-          subDivisionTransforms = subDivisionMarkdownNodes.reduce((subDivisionTransforms, subDivisionMarkdownNode) => {
-            const subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
-
-            if (subDivisionTransform !== null) {
-              subDivisionTransforms.push(subDivisionTransform);
-            }
-
-            return subDivisionTransforms;
-          }, []);
+  getDivisionClassName() {
+    return this.divisionClassName;
+  }
 
-    return subDivisionTransforms;
+  setDivisionClassName(divisionClassName) {
+    this.divisionClassName = divisionClassName;
   }
 
-  findDivisionMarkdownNodes() {
+  isIgnored() {
     const node = this,  ///
-          subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node);
+          ignoreDirectiveMarkdownNode = ignoreDirectiveMarkdownNodeFromNode(node),
+          ignored = (ignoreDirectiveMarkdownNode !== null);
 
-    return subDivisionMarkdownNodes;
+    return ignored;
   }
 
-  findPageNumberDirectiveMarkdownNode() {
-    let pageNumberDirectiveMarkdownNode = null;
+  className(context) {
+    const className = this.divisionClassName; ///
 
-    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
+    return className;
+  }
 
-    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
-      const node = subDivisionMarkdownNode; ///
+  resolveIgnored(topmostMarkdownNode, context) {
+    const ignored = this.isIgnored();
 
-      pageNumberDirectiveMarkdownNode = pageNumberDirectiveMarkdownNodeFromNode(node);
+    if (!ignored) {
+      return;
+    }
 
-      if (pageNumberDirectiveMarkdownNode !== null) {
-        return true;
-      }
-    });
+    const divisionMarkdownNode = this,  ///
+          ignoreDirectiveMarkdownTransform = IgnoreDirectiveMarkdownTransform.fromDivisionMarkdownNode(divisionMarkdownNode);
 
-    return pageNumberDirectiveMarkdownNode;
+    ignoreDirectiveMarkdownTransform.removeFromTopmostMarkdownNode(topmostMarkdownNode, context);
   }
 
-  removeDivisionMarkdownNode(DivisionTransform, context) {
-    const divisionMarkdownNode = this,  //
-          subDivisionTransform = this.findDivisionTransform(DivisionTransform, context);
+  resolveIncludes(topmostMarkdownNode, context) {
+    const node = this,  ///
+          includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodesFromNode(node),
+          includeDirectiveMarkdownTransforms = includeDirectiveMarkdownNodes.reduce((includeDirectiveMarkdownTransforms, includeDirectiveMarkdownNode) => {
+            const includeDirectiveMarkdownTransform = includeDirectiveMarkdownNode.resolveInclude(context);
 
-    if (subDivisionTransform !== null) {
-      subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
-    }
+            if (includeDirectiveMarkdownTransform !== null) {
+              includeDirectiveMarkdownTransforms.push(includeDirectiveMarkdownTransform);
+            }
 
-    return subDivisionTransform;
-  }
+            return includeDirectiveMarkdownTransforms;
+          }, []);
 
-  removeDivisionMarkdownNodes(DivisionTransform, context) {
-    const divisionMarkdownNode = this,  //
-          subDivisionTransforms = this.findDivisionTransforms(DivisionTransform, context);
+    includeDirectiveMarkdownTransforms.forEach((includeDirectiveMarkdownTransform) => {
+      const divisionMarkdownNode = includeDirectiveMarkdownTransform.appendToTopmostMarkdownNode(topmostMarkdownNode, context);
 
-    subDivisionTransforms.forEach((subDivisionTransform) => {
-      subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+      divisionMarkdownNode.resolveIncludes(topmostMarkdownNode, context);
     });
-
-    return subDivisionTransforms;
   }
 
-  createFootnotesListTransform(footnoteTransformMap, context) {
-    const footnoteDivisionTransforms = this.findDivisionTransforms(FootnoteDivisionTransform, context);
+  resolveEmbeddings(context) {
+    const divisionMarkdownNode = this;  ///
 
-    footnoteDivisionTransforms.forEach((footnoteDivisionTransform) => {
-      const footnoteTransform = FootnoteTransform.fromFootnoteDivisionTransform(footnoteDivisionTransform),
-            identifier = footnoteDivisionTransform.identifier(context);
+    this.forEachSubDivisionMarkdownNode((subDivisionMarkdownNode) => {
+      const embeddingsResolved = subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
 
-      footnoteTransformMap[identifier] = footnoteTransform;
-    });
+      if (embeddingsResolved) {
+        const subDivisionTransform = SubDivisionTransform.fromSubDivisionMarkdownNode(subDivisionMarkdownNode)
 
-    const divisionMarkdownNode = this,  ///
-          footnotesListDivisionTransform = FootnotesListTransform.fromDivisionMarkdownNodeAndFootnoteTransformMap(divisionMarkdownNode, footnoteTransformMap, context);
-
-    return footnotesListDivisionTransform;
+        subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+      }
+    });
   }
 
-  clone() { return super.clone(this.divisionClassName); }
-
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity); }
-}
+  getSubDivisionMarkdownNodes() {
+    const node = this,
+          subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node);
 
-function paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionTransforms, divisionClassName, markdownNodes, pageNumber, context) {
-  let markdownNode;
+    return subDivisionMarkdownNodes;
+  }
 
-  const indexAnchorTransform = IndexAnchorTransform.fromPageNumber(pageNumber, context),
-        divisionMarkdownNode = DivisionMarkdownNode.fromPaginatedChildNodesDivisionTransformsAndDivisionClassName(paginatedChildNodes, subDivisionTransforms, divisionClassName, context),
-        anchorMarkdownNode = indexAnchorTransform.getAnchorMarkdownNode();
+  forEachSubDivisionMarkdownNode(callback) {
+    const subDivisionMarkdownNodes = this.getSubDivisionMarkdownNodes();
 
-  divisionMarkdownNode.setPageNumber(pageNumber);
+    subDivisionMarkdownNodes.forEach(callback);
+  }
 
-  markdownNode = anchorMarkdownNode;  ///
+  clone() { return super.clone(this.divisionClassName); }
 
-  markdownNodes.push(markdownNode);
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
+    const divisionClassName = null,
+          divisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity, divisionClassName);
 
-  markdownNode = divisionMarkdownNode; ///
+    return divisionMarkdownNode;
+  }
+}
 
-  markdownNodes.push(markdownNode);
-}
+// function paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionTransforms, divisionClassName, markdownNodes, pageNumber, context) {
+//   let markdownNode;
+//
+//   const indexAnchorTransform = IndexAnchorTransform.fromPageNumber(pageNumber, context),
+//         divisionMarkdownNode = DivisionMarkdownNode.fromPaginatedChildNodesDivisionTransformsAndDivisionClassName(paginatedChildNodes, subDivisionTransforms, divisionClassName, context),
+//         anchorMarkdownNode = indexAnchorTransform.getAnchorMarkdownNode();
+//
+//   divisionMarkdownNode.setPageNumber(pageNumber);
+//
+//   markdownNode = anchorMarkdownNode;  ///
+//
+//   markdownNodes.push(markdownNode);
+//
+//   markdownNode = divisionMarkdownNode; ///
+//
+//   markdownNodes.push(markdownNode);
+// }

package/src/node/markdown/{footnotesItem.js → item/footnotes.js}

@@ -2,11 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
-import MarkdownNode from "../../node/markdown";
-import AnchorMarkdownNode from "../../node/markdown/anchor";
+import MarkdownNode from "../../../node/markdown";
+import AnchorMarkdownNode from "../../../node/markdown/anchor";
 
-import { FOOTNOTE_PREPEND } from "../../prepends";
-import { FOOTNOTES_ITEM_RULE_NAME } from "../../ruleNames";
+import { FOOTNOTE_PREPEND } from "../../../prepends";
+import { FOOTNOTES_ITEM_RULE_NAME } from "../../../ruleNames";
 
 const { first } = arrayUtilities;
 

package/src/node/markdown/{contentsLink.js → link/contents.js}

@@ -1,8 +1,8 @@
 "use strict";
 
-import MarkdownNode from "../../node/markdown";
+import MarkdownNode from "../../../node/markdown";
 
-import { CONTENTS_LINK_RULE_NAME } from "../../ruleNames";
+import { CONTENTS_LINK_RULE_NAME } from "../../../ruleNames";
 
 export default class ContentsLinkMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, opacity, precedence, domElement, identifier) {

package/src/node/markdown/{emailLink.js → link/email.js}

@@ -1,8 +1,8 @@
 "use strict";
 
-import MarkdownNode from "../../node/markdown";
+import MarkdownNode from "../../../node/markdown";
 
-import { EMAIL_ADDRESS_TOKEN_TYPE } from "../../tokenTypes";
+import { EMAIL_ADDRESS_TOKEN_TYPE } from "../../../tokenTypes";
 
 export default class EmailLinkMarkdownNode extends MarkdownNode {
   emailAddressFromSecondLastChildNode(context) {