highmark-markdown 1.0.177 → 1.0.178

package/src/index.js

@@ -5,9 +5,11 @@ export { default as MarkdownParser } from "./markdown/parser";
 export { default as MarkdownStyleLexer } from "./markdownStyle/lexer";
 export { default as MarkdownStyleParser } from "./markdownStyle/parser";
 
+export { default as domUtilities } from "./utilities/dom";
 export { default as cssUtilities } from "./utilities/css";
 export { default as htmlUtilities } from "./utilities/html";
 export { default as queryUtilities } from "./utilities/query";
+export { default as markdownUtilities } from "./utilities/markdown";
 export { default as footnotesUtilities } from "./utilities/footnotes";
 
 export { default as ruleNames } from "./ruleNames";

package/src/map/className.js

@@ -1,14 +1,11 @@
 "use strict";
 
-import htmlNodeMap from "../map/node/html";
-
-import { ruleNames } from "../map/node/html";
+import { forEachHTMLNode } from "../map/node/html";
 
 const classNameMap = {};
 
-ruleNames.forEach((ruleName) => {
-  const Class = htmlNodeMap[ruleName],
-        { className } = Class;
+forEachHTMLNode((Class, ruleName) => {
+  const { className } = Class;
 
   classNameMap[ruleName] = className;
 });

package/src/map/node/html.js

@@ -5,6 +5,7 @@ import ErrorHTMLNode from "../../node/html/error";
 import ImageHTMLNode from "../../node/html/image";
 import TableHTMLNode from "../../node/html/table";
 import AnchorHTMLNode from "../../node/html/anchor";
+import TopmostHTMLNode from "../../node/html/topmost";
 import DivisionHTMLNode from "../../node/html/division";
 import ParagraphHTMLNode from "../../node/html/paragraph";
 import TableHeadHTMLNode from "../../node/html/tableHead";
@@ -43,7 +44,8 @@ import SecondaryHeadingHTMLNode from "../../node/html/heading/secondary";
 import QuaternaryHeadingHTMLNode from "../../node/html/heading/quaternary";
 import StronglyEmphasisedTextHTMLNode from "../../node/html/text/stronglyEmphasised";
 
-import { LINE_RULE_NAME,
+import { HTML_RULE_NAME,
+         LINE_RULE_NAME,
          ERROR_RULE_NAME,
          IMAGE_RULE_NAME,
          TABLE_RULE_NAME,
@@ -87,6 +89,7 @@ import { LINE_RULE_NAME,
          STRONGLY_EMPHASISED_TEXT_RULE_NAME } from "../../ruleNames";
 
 const htmlNodeMap = {
+  [HTML_RULE_NAME]: TopmostHTMLNode,  ///
   [LINE_RULE_NAME]: LineHTMLNode,
   [ERROR_RULE_NAME]: ErrorHTMLNode,
   [IMAGE_RULE_NAME]: ImageHTMLNode,
@@ -131,6 +134,15 @@ const htmlNodeMap = {
   [STRONGLY_EMPHASISED_TEXT_RULE_NAME]: StronglyEmphasisedTextHTMLNode
 }
 
-export const ruleNames = Object.keys(htmlNodeMap);
+export function forEachHTMLNode(callback) {
+  const ruleNames = Object.keys(htmlNodeMap);
+
+  ruleNames.forEach((ruleName) => {
+    const HTMLNode = htmlNodeMap[ruleName],
+          Class = HTMLNode;
+
+    callback(Class, ruleName);
+  });
+}
 
 export default htmlNodeMap;

package/src/map/node/markdown.js

@@ -46,7 +46,7 @@ import { LINE_RULE_NAME,
          IMAGE_RULE_NAME,
          ERROR_RULE_NAME,
          ANCHOR_RULE_NAME,
-         TOPMOST_RULE_NAME,
+         MARKDOWN_RULE_NAME,
          DIVISION_RULE_NAME,
          FOOTNOTE_RULE_NAME,
          BLOCK_END_RULE_NAME,
@@ -88,7 +88,7 @@ const markdownNodeMap = {
   [IMAGE_RULE_NAME]: ImageMarkdownNode,
   [ERROR_RULE_NAME]: ErrorMarkdownNode,
   [ANCHOR_RULE_NAME]: AnchorMarkdownNode,
-  [TOPMOST_RULE_NAME]: TopmostMarkdownNode,
+  [MARKDOWN_RULE_NAME]: TopmostMarkdownNode,
   [DIVISION_RULE_NAME]: DivisionMarkdownNode,
   [FOOTNOTE_RULE_NAME]: FootnoteMarkdownNode,
   [BLOCK_END_RULE_NAME]: BlockEndMarkdownNode,

package/src/map/tagName.js

@@ -1,14 +1,11 @@
 "use strict";
 
-import htmlNodeMap from "../map/node/html";
-
-import { ruleNames } from "../map/node/html";
+import { forEachHTMLNode } from "../map/node/html";
 
 const tagNameMap = {};
 
-ruleNames.forEach((ruleName) => {
-  const Class = htmlNodeMap[ruleName],
-        { tagName } = Class;
+forEachHTMLNode((Class, ruleName) => {
+  const { tagName } = Class;
 
   tagNameMap[ruleName] = tagName;
 });

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,9 +2,9 @@
 
 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/query";
+import { divisionMarkdownNodeFromNode, subDivisionMarkdownNodeFromNode } from "../../../utilities/markdown";
 
 export default class EmbedDirectiveMarkdownNode extends MarkdownNode {
   filePath(context) {
@@ -27,7 +27,7 @@ export default class EmbedDirectiveMarkdownNode extends MarkdownNode {
   }
 
   resolveEmbedding(context) {
-    let embedDirectiveTransform = null;
+    let embedDirectiveMarkdownTransform = null;
 
     const filePath = this.filePath(context);
 
@@ -54,13 +54,13 @@ export default class EmbedDirectiveMarkdownNode extends MarkdownNode {
           if (subDivisionMarkdownNode !== null) {
             divisionMarkdownNode.removeSubDivisionMarkdownNode(subDivisionMarkdownNode);
 
-            embedDirectiveTransform = EmbedDirectiveTransform.fromSubDivisionMarkdownNodeAndTokens(subDivisionMarkdownNode, tokens);
+            embedDirectiveMarkdownTransform = EmbedDirectiveMarkdownTransform.fromSubDivisionMarkdownNodeAndTokens(subDivisionMarkdownNode, tokens);
           }
         }
       }
     }
 
-    return embedDirectiveTransform;
+    return embedDirectiveMarkdownTransform;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(EmbedDirectiveMarkdownNode, ruleName, childNodes, opacity); }

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

@@ -2,9 +2,9 @@
 
 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/query";
+import { divisionMarkdownNodeFromNode } from "../../../utilities/markdown";
 
 export default class IncludeDirectiveMarkdownNode extends MarkdownNode {
   filePath(context) {
@@ -27,7 +27,7 @@ export default class IncludeDirectiveMarkdownNode extends MarkdownNode {
   }
 
   resolveInclude(context) {
-    let includeDirectiveTransform = null;
+    let includeDirectiveMarkdownTransform = null;
 
     const filePath = this.filePath(context);
 
@@ -57,12 +57,12 @@ export default class IncludeDirectiveMarkdownNode extends MarkdownNode {
 
           divisionMarkdownNode.setDivisionClassName(divisionClassName);
 
-          includeDirectiveTransform = IncludeDirectiveTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
+          includeDirectiveMarkdownTransform = IncludeDirectiveMarkdownTransform.fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens);
         }
       }
     }
 
-    return includeDirectiveTransform;
+    return includeDirectiveMarkdownTransform;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IncludeDirectiveMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/division.js

@@ -1,93 +1,11 @@
 "use strict";
 
 import MarkdownNode from "../../node/markdown";
-import FootnoteTransform from "../../transform/footnote";
-import SubDivisionTransform from "../../transform/subDivision";
-import FootnotesListTransform from "../../transform/footnotesList";
-import IgnoreDirectiveTransform from "../../transform/ignoreDirective";
-import FootnoteDivisionTransform from "../../transform/subDivision/footnote";
+import IgnoreDirectiveMarkdownTransform from "../../transform/markdown/directive/ignore";
 
-import { subDivisionMarkdownNodesFromNode,
-         ignoreDirectiveMarkdownNodeFromNode,
-         includeDirectiveMarkdownNodesFromNode,
-         pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
+import { ignoreDirectiveMarkdownNodeFromNode, subDivisionMarkdownNodesFromNode, includeDirectiveMarkdownNodesFromNode } from "../../utilities/markdown";
 
 export default class DivisionMarkdownNode extends MarkdownNode {
-  constructor(ruleName, parentNode, childNodes, opacity, precedence, divisionClassName) {
-    super(ruleName, parentNode, childNodes, opacity, precedence);
-
-    this.divisionClassName = divisionClassName;
-  }
-
-  getDivisionClassName() {
-    return this.divisionClassName;
-  }
-
-  setDivisionClassName(divisionClassName) {
-    this.divisionClassName = divisionClassName;
-  }
-
-  className(context) {
-    const className = this.divisionClassName; ///
-
-    return className;
-  }
-
-  isIgnored() {
-    const node = this,  ///
-          ignoreDirectiveMarkdownNode = ignoreDirectiveMarkdownNodeFromNode(node),
-          ignored = (ignoreDirectiveMarkdownNode !== null);
-
-    return ignored;
-  }
-
-  resolveIgnored(topmostMarkdownNode, context) {
-    const ignored = this.isIgnored();
-
-    if (!ignored) {
-      return;
-    }
-
-    const divisionMarkdownNode = this,  ///
-          ignoreDirectiveTransform = IgnoreDirectiveTransform.fromDivisionMarkdownNode(divisionMarkdownNode);
-
-    ignoreDirectiveTransform.removeFromTopmostMarkdownNode(topmostMarkdownNode, context);
-  }
-
-  resolveIncludes(topmostMarkdownNode, context) {
-    const node = this,  ///
-          includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodesFromNode(node),
-          includeDirectiveTransforms = includeDirectiveMarkdownNodes.reduce((includeDirectiveTransforms, includeDirectiveMarkdownNode) => {
-            const includeDirectiveTransform = includeDirectiveMarkdownNode.resolveInclude(context);
-
-            if (includeDirectiveTransform !== null) {
-              includeDirectiveTransforms.push(includeDirectiveTransform);
-            }
-
-            return includeDirectiveTransforms;
-          }, []);
-
-    includeDirectiveTransforms.forEach((includeDirectiveTransform) => {
-      const divisionMarkdownNode = includeDirectiveTransform.appendToTopmostMarkdownNode(topmostMarkdownNode, context);
-
-      divisionMarkdownNode.resolveIncludes(topmostMarkdownNode, context);
-    });
-  }
-
-  resolveEmbeddings(context) {
-    const divisionMarkdownNode = this;  ///
-
-    this.forEachSubDivisionMarkdownNode((subDivisionMarkdownNode) => {
-      const embeddingsResolved = subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
-
-      if (embeddingsResolved) {
-        const subDivisionTransform = SubDivisionTransform.fromSubDivisionMarkdownNode(subDivisionMarkdownNode)
-
-        subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
-      }
-    });
-  }
-
   // getPageNumber() {
   //   let pageNumber = null;
   //
@@ -222,54 +140,151 @@ 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;
+  constructor(ruleName, parentNode, childNodes, opacity, precedence, divisionClassName) {
+    super(ruleName, parentNode, childNodes, opacity, precedence);
 
-    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
+    this.divisionClassName = divisionClassName;
+  }
 
-    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
-      subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
+  getDivisionClassName() {
+    return this.divisionClassName;
+  }
 
-      if (subDivisionTransform !== null) {
-        return true;
-      }
-    });
+  setDivisionClassName(divisionClassName) {
+    this.divisionClassName = divisionClassName;
+  }
+
+  isIgnored() {
+    const node = this,  ///
+          ignoreDirectiveMarkdownNode = ignoreDirectiveMarkdownNodeFromNode(node),
+          ignored = (ignoreDirectiveMarkdownNode !== null);
 
-    return subDivisionTransform;
+    return ignored;
   }
 
-  findDivisionTransforms(DivisionTransform, context) {
-    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes(),
-          subDivisionTransforms = subDivisionMarkdownNodes.reduce((subDivisionTransforms, subDivisionMarkdownNode) => {
-            const subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
+  className(context) {
+    const className = this.divisionClassName; ///
 
-            if (subDivisionTransform !== null) {
-              subDivisionTransforms.push(subDivisionTransform);
+    return className;
+  }
+
+  resolveIgnored(topmostMarkdownNode, context) {
+    const ignored = this.isIgnored();
+
+    if (!ignored) {
+      return;
+    }
+
+    const divisionMarkdownNode = this,  ///
+          ignoreDirectiveMarkdownTransform = IgnoreDirectiveMarkdownTransform.fromDivisionMarkdownNode(divisionMarkdownNode);
+
+    ignoreDirectiveMarkdownTransform.removeFromTopmostMarkdownNode(topmostMarkdownNode, context);
+  }
+
+  resolveIncludes(topmostMarkdownNode, context) {
+    const node = this,  ///
+          includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodesFromNode(node),
+          includeDirectiveMarkdownTransforms = includeDirectiveMarkdownNodes.reduce((includeDirectiveMarkdownTransforms, includeDirectiveMarkdownNode) => {
+            const includeDirectiveMarkdownTransform = includeDirectiveMarkdownNode.resolveInclude(context);
+
+            if (includeDirectiveMarkdownTransform !== null) {
+              includeDirectiveMarkdownTransforms.push(includeDirectiveMarkdownTransform);
             }
 
-            return subDivisionTransforms;
+            return includeDirectiveMarkdownTransforms;
           }, []);
 
-    return subDivisionTransforms;
-  }
+    includeDirectiveMarkdownTransforms.forEach((includeDirectiveMarkdownTransform) => {
+      const divisionMarkdownNode = includeDirectiveMarkdownTransform.appendToTopmostMarkdownNode(topmostMarkdownNode, context);
 
-  findPageNumberDirectiveMarkdownNode() {
-    let pageNumberDirectiveMarkdownNode = null;
+      divisionMarkdownNode.resolveIncludes(topmostMarkdownNode, context);
+    });
+  }
 
-    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
+  resolveEmbeddings(context) {
+    const divisionMarkdownNode = this;  ///
 
-    subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
-      const node = subDivisionMarkdownNode; ///
+    this.forEachSubDivisionMarkdownNode((subDivisionMarkdownNode) => {
+      const embeddingsResolved = subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
 
-      pageNumberDirectiveMarkdownNode = pageNumberDirectiveMarkdownNodeFromNode(node);
+      if (embeddingsResolved) {
+        const subDivisionTransform = SubDivisionTransform.fromSubDivisionMarkdownNode(subDivisionMarkdownNode)
 
-      if (pageNumberDirectiveMarkdownNode !== null) {
-        return true;
+        subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
       }
     });
-
-    return pageNumberDirectiveMarkdownNode;
   }
 
   getSubDivisionMarkdownNodes() {
@@ -285,28 +300,6 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     subDivisionMarkdownNodes.forEach(callback);
   }
 
-  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;
-  }
-
   clone() { return super.clone(this.divisionClassName); }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {

package/src/node/markdown/subDivision.js

@@ -3,11 +3,8 @@
 import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
-import FootnoteTransform from "../../transform/footnote";
-import FootnotesListTransform from "../../transform/footnotesList";
-import FootnoteDivisionTransform from "../../transform/subDivision/footnote";
 
-import { embedDirectiveMarkdownNodesFromNode } from "../../utilities/query";
+import { embedDirectiveMarkdownNodesFromNode } from "../../utilities/markdown";
 
 const { backwardsForEach } = arrayUtilities;
 
@@ -17,21 +14,21 @@ export default class SubDivisionMarkdownNode extends MarkdownNode {
 
     const node = this,  ///
           embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodesFromNode(node),
-          embedDirectiveTransforms = embedDirectiveMarkdownNodes.reduce((embedDirectiveTransforms, embedDirectiveMarkdownNode) => {
+          embedDirectiveMarkdownTransforms = embedDirectiveMarkdownNodes.reduce((embedDirectiveMarkdownTransforms, embedDirectiveMarkdownNode) => {
             const embedDirectiveTransform = embedDirectiveMarkdownNode.resolveEmbedding(context);
 
             if (embedDirectiveTransform !== null) {
-              embedDirectiveTransforms.push(embedDirectiveTransform);
+              embedDirectiveMarkdownTransforms.push(embedDirectiveTransform);
             }
 
-            return embedDirectiveTransforms;
+            return embedDirectiveMarkdownTransforms;
           }, []),
-          embedDirectiveTransformsLength = embedDirectiveTransforms.length;
+          embedDirectiveMarkdownTransformsLength = embedDirectiveMarkdownTransforms.length;
 
-    if (embedDirectiveTransformsLength > 0) {
+    if (embedDirectiveMarkdownTransformsLength > 0) {
       const subDivisionMarkdownNode = this; ///
 
-      backwardsForEach(embedDirectiveTransforms, (embedDirectiveTransform) => {
+      backwardsForEach(embedDirectiveMarkdownTransforms, (embedDirectiveTransform) => {
         embedDirectiveTransform.addAfterSubDivisionMarkdownNode(subDivisionMarkdownNode, divisionMarkdownNode, context);
       });
 

package/src/node/markdown/topmost.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 
-import { divisionMarkdownNodesFromNode } from "../../utilities/query";
+import { divisionMarkdownNodesFromNode } from "../../utilities/markdown";
 
 const { first } = arrayUtilities;
 

package/src/queries.js

@@ -2,13 +2,15 @@
 
 import { Query } from "occam-query";
 
-import { ruleNames } from "./map/node//html";
+import { forEachHTMLNode } from "./map/node//html";
 
-const queries = ruleNames.map((ruleName) => {
+const queries = [];
+
+forEachHTMLNode((Class, ruleName) => {
   const expressionString = `//${ruleName}`,
         query = Query.fromExpressionString(expressionString);
 
-  return query;
+  queries.push(query);
 });
 
 export default queries;