highmark-markdown 1.0.173 → 1.0.174

package/src/node/markdown/division.js

@@ -3,18 +3,19 @@
 import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
-import IndexReplacement from "../../replacement/index";
-import FootnoteReplacement from "../../replacement/footnote";
-import IndexAnchorReplacement from "../../replacement/indexAnchor";
-import ContentsListReplacement from "../../replacement/contentsList";
-import FootnotesListReplacement from "../../replacement/footnotesList";
-import FootnoteSubDivisionReplacement from "../../replacement/subDivision/footnote";
-import IndexDirectiveSubDivisionReplacement from "../../replacement/subDivision/indexDirective";
-import ContentsDirectiveSubDivisionReplacement from "../../replacement/subDivision/contentsDirective";
-import FootnotesDirectiveSubDivisionReplacement from "../../replacement/subDivision/footnotesDirective";
-import PageNumberDirectiveSubDivisionReplacement from "../../replacement/subDivision/pageNumberDirective";
-
-import { EMPTY_STRING } from "../../constants";
+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";
@@ -22,24 +23,26 @@ import { subDivisionMarkdownNodesFromNode, ignoreDirectiveMarkdownNodeFromNode,
 const { clear, filter } = arrayUtilities;
 
 export default class DivisionMarkdownNode extends MarkdownNode {
-  constructor(ruleName, childNodes, precedence, opacity, domElement, divisionClassName) {
-    super(ruleName, childNodes, precedence, opacity, domElement);
-
-    this.divisionClassName = divisionClassName;
-  }
+  resolveIncludes(context) {
+    const divisionMarkdownNode = this, ///
+          includeDirectivesDivisionTransform = IncludeDirectivesDivisionTransform.fromDivisionMarkdownNode(divisionMarkdownNode, context);
 
-  getDivisionClassName() {
-    return this.divisionClassName;
+    if (includeDirectivesDivisionTransform !== null) {
+      includeDirectivesDivisionTransform.removeDivisionMarkdownNode(divisionMarkdownNode, context);
+    }
   }
 
-  setDivisionClassName(divisionClassName) {
-    this.divisionClassName = divisionClassName;
-  }
+  resolveEmbeddings(divisionMarkdownNode, context) {
+    const divisionMarkdownNode = this, ///
+          embedDirectivesDivisionTransform = EmbedDirectivesDivisionTransform.fromDivisionMarkdownNode(divisionMarkdownNode, context);
 
-  isDivisionMarkdownNode() {
-    const divisionMarkdownNode = true;
+    if (embedDirectivesDivisionTransform !== null) {
+      const subDivisionMarkdownNodes = embedDirectivesDivisionTransform.replaceDivisionMarkdownNode(divisionMarkdownNode, context);
 
-    return divisionMarkdownNode;
+      subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
+        subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
+      });
+    }
   }
 
   className(context) {
@@ -56,191 +59,173 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return ignored;
   }
 
-  getPageNumber() {
-    let pageNumber = null;
-
-    const pageNumberDirectiveMarkdownNode = this.findPageNumberDirectiveMarkdownNode();
-
-    if (pageNumberDirectiveMarkdownNode !== null) {
-      pageNumber = pageNumberDirectiveMarkdownNode.getPageNumber();
-    }
-
-    return pageNumber;
-  }
-
-  setPageNumber(pageNumber) {
-    const pageNumberDirectiveMarkdownNode = this.findPageNumberDirectiveMarkdownNode();
-
-    if (pageNumberDirectiveMarkdownNode !== null) {
-      pageNumberDirectiveMarkdownNode.setPageNumber(pageNumber);
-    }
-  }
-
-  paginate(markdownNodes, context) {
-    const footnotesDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionReplacement, context),
-          pageNumberDirectiveSubDivisionReplacement = this.removeSubDivisionMarkdownNode(PageNumberDirectiveSubDivisionReplacement, context),
-          subDivisionReplacements = [
-            footnotesDirectiveSubDivisionReplacement,
-            pageNumberDirectiveSubDivisionReplacement
-          ];
-
-    filter(subDivisionReplacements, (subDivisionReplacement) => {
-      if (subDivisionReplacement !== null) {
-        return true;
-      }
-    });
-
-    const { linesPerPage } = context,
-          paginatedChildNodes = [];
-
-    let { pageNumber } = context,
-        totalLines = 0;
-
-    this.forEachChildNode((childNode) => {
-      const lines = childNode.lines(context);
-
-      if ((totalLines + lines) > linesPerPage) {
-        paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionReplacements, this.divisionClassName, markdownNodes, pageNumber, context);
-
-        pageNumber++;
-
-        totalLines = 0;
-
-        clear(paginatedChildNodes);
-      }
-
-      const paginatedChildNode = childNode;  ///
-
-      paginatedChildNodes.push(paginatedChildNode);
-
-      totalLines += lines;
-    });
-
-    if (totalLines > 0) {
-      paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionReplacements, this.divisionClassName, markdownNodes, pageNumber, context);
-
-      pageNumber++;
-    }
-
-    Object.assign(context, {
-      pageNumber
-    });
-  }
-
-  createIndex(divisionMarkdownNodes, context) {
-    let indexCreated = false;
-
-    const indexDirectiveSubDivisionReplacement = this.findSubDivisionReplacement(IndexDirectiveSubDivisionReplacement, context);
-
-    if (indexDirectiveSubDivisionReplacement !== null) {
-      const divisionMarkdownNode = this,  ///
-            indexReplacement = IndexReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
-
-      if (indexReplacement !== null) {
-        indexReplacement.replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
-
-        indexCreated = true;
-      }
-    }
-
-    return indexCreated;
-  }
-
-  createContents(divisionMarkdownNodes, context) {
-    let contentsCreated = false;
-
-    const contentsDirectiveSubDivisionReplacement = this.findSubDivisionReplacement(ContentsDirectiveSubDivisionReplacement, context);
-
-    if (contentsDirectiveSubDivisionReplacement !== null) {
-      const divisionMarkdownNode = this,  ///
-            contentsListReplacement = ContentsListReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
-
-      if (contentsListReplacement !== null) {
-        contentsListReplacement.replaceContentsDirectiveSubdivisionReplacement(contentsDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
-
-        contentsCreated = true;
-      }
-    }
-
-    return contentsCreated;
-  }
-
-  createFootnotes(footnoteReplacementMap, context) {
-    const footnotesDirectiveSubDivisionReplacement = this.findSubDivisionReplacement(FootnotesDirectiveSubDivisionReplacement, context);
-
-    if (footnotesDirectiveSubDivisionReplacement !== null) {
-      const divisionMarkdownNode = this,  ///
-            footnotesListSubDivisionReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteReplacementMap(divisionMarkdownNode, footnoteReplacementMap, context);
-
-      if (footnotesListSubDivisionReplacement !== null) {
-        footnotesListSubDivisionReplacement.replaceFootnotesDirectiveSubDivisionReplacement(footnotesDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
-      }
-
-      renumberFootnoteLinkMarkdownNodes(divisionMarkdownNode, footnoteReplacementMap, context);
-    }
-  }
-
-  prepareFootnotes(footnoteReplacementMap, context) {
-    const footnoteSubDivisionReplacements = this.removeSubDivisionMarkdownNodes(FootnoteSubDivisionReplacement, context);
-
-    footnoteSubDivisionReplacements.forEach((footnoteSubDivisionReplacement) => {
-      const footnoteReplacement = FootnoteReplacement.fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement),
-            identifier = footnoteSubDivisionReplacement.identifier(context);
-
-      footnoteReplacementMap[identifier] = footnoteReplacement;
-    });
-  }
-
-  resolveIncludes(context) {
-    const divisionMarkdownNode = this,  ///
-          subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
-
-    subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
-      subDivisionMarkdownNode.resolveIncludes(divisionMarkdownNode, context);
-    });
-  }
-
-  resolveEmbeddings(context) {
-    const divisionMarkdownNode = this,  ///
-          subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
-
-    subDivisionMarkdownNodes.forEach((subDivisionMarkdownNode) => {
-      subDivisionMarkdownNode.resolveEmbeddings(divisionMarkdownNode, context);
-    });
-  }
-
-  findSubDivisionReplacement(SubDivisionReplacement, context) {
-    let subDivisionReplacement = null;
-
-    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
+  // getPageNumber() {
+  //   let pageNumber = null;
+  //
+  //   const pageNumberDirectiveMarkdownNode = this.findPageNumberDirectiveMarkdownNode();
+  //
+  //   if (pageNumberDirectiveMarkdownNode !== null) {
+  //     pageNumber = pageNumberDirectiveMarkdownNode.getPageNumber();
+  //   }
+  //
+  //   return pageNumber;
+  // }
+  //
+  // setPageNumber(pageNumber) {
+  //   const pageNumberDirectiveMarkdownNode = this.findPageNumberDirectiveMarkdownNode();
+  //
+  //   if (pageNumberDirectiveMarkdownNode !== null) {
+  //     pageNumberDirectiveMarkdownNode.setPageNumber(pageNumber);
+  //   }
+  // }
+  //
+  // paginate(markdownNodes, context) {
+  //   const footnotesDirectiveDivisionTransform = this.removeDivisionMarkdownNode(FootnotesDirectiveDivisionTransform, context),
+  //         pageNumberDirectiveDivisionTransform = this.removeDivisionMarkdownNode(PageNumberDirectiveDivisionTransform, context),
+  //         subDivisionTransforms = [
+  //           footnotesDirectiveDivisionTransform,
+  //           pageNumberDirectiveDivisionTransform
+  //         ];
+  //
+  //   filter(subDivisionTransforms, (subDivisionTransform) => {
+  //     if (subDivisionTransform !== null) {
+  //       return true;
+  //     }
+  //   });
+  //
+  //   const { linesPerPage } = context,
+  //         paginatedChildNodes = [];
+  //
+  //   let { pageNumber } = context,
+  //       totalLines = 0;
+  //
+  //   this.forEachChildNode((childNode) => {
+  //     const lines = childNode.lines(context);
+  //
+  //     if ((totalLines + lines) > linesPerPage) {
+  //       paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionTransforms, this.divisionClassName, markdownNodes, pageNumber, context);
+  //
+  //       pageNumber++;
+  //
+  //       totalLines = 0;
+  //
+  //       clear(paginatedChildNodes);
+  //     }
+  //
+  //     const paginatedChildNode = childNode;  ///
+  //
+  //     paginatedChildNodes.push(paginatedChildNode);
+  //
+  //     totalLines += lines;
+  //   });
+  //
+  //   if (totalLines > 0) {
+  //     paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionTransforms, this.divisionClassName, markdownNodes, pageNumber, context);
+  //
+  //     pageNumber++;
+  //   }
+  //
+  //   Object.assign(context, {
+  //     pageNumber
+  //   });
+  // }
+  //
+  // createIndex(divisionMarkdownNodes, context) {
+  //   let indexCreated = false;
+  //
+  //   const indexDirectiveDivisionTransform = this.findDivisionTransform(IndexDirectiveDivisionTransform, context);
+  //
+  //   if (indexDirectiveDivisionTransform !== null) {
+  //     const divisionMarkdownNode = this,  ///
+  //           indexTransform = IndexTransform.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
+  //
+  //     if (indexTransform !== null) {
+  //       indexTransform.replaceIndexDirectiveSubdivisionTransform(indexDirectiveDivisionTransform, divisionMarkdownNode, context);
+  //
+  //       indexCreated = true;
+  //     }
+  //   }
+  //
+  //   return indexCreated;
+  // }
+  //
+  // createContents(divisionMarkdownNodes, context) {
+  //   let contentsCreated = false;
+  //
+  //   const contentsDirectiveDivisionTransform = this.findDivisionTransform(ContentsDirectiveDivisionTransform, context);
+  //
+  //   if (contentsDirectiveDivisionTransform !== null) {
+  //     const divisionMarkdownNode = this,  ///
+  //           contentsListTransform = ContentsListTransform.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
+  //
+  //     if (contentsListTransform !== null) {
+  //       contentsListTransform.replaceContentsDirectiveSubdivisionTransform(contentsDirectiveDivisionTransform, divisionMarkdownNode, context);
+  //
+  //       contentsCreated = true;
+  //     }
+  //   }
+  //
+  //   return contentsCreated;
+  // }
+  //
+  // createFootnotes(footnoteTransformMap, context) {
+  //   const footnotesDirectiveDivisionTransform = this.findDivisionTransform(FootnotesDirectiveDivisionTransform, context);
+  //
+  //   if (footnotesDirectiveDivisionTransform !== null) {
+  //     const divisionMarkdownNode = this,  ///
+  //           footnotesListDivisionTransform = FootnotesListTransform.fromDivisionMarkdownNodeAndFootnoteTransformMap(divisionMarkdownNode, footnoteTransformMap, context);
+  //
+  //     if (footnotesListDivisionTransform !== null) {
+  //       footnotesListDivisionTransform.replaceFootnotesDirectiveDivisionTransform(footnotesDirectiveDivisionTransform, divisionMarkdownNode, context);
+  //     }
+  //
+  //     renumberFootnoteLinkMarkdownNodes(divisionMarkdownNode, footnoteTransformMap, context);
+  //   }
+  // }
+  //
+  // prepareFootnotes(footnoteTransformMap, context) {
+  //   const footnoteDivisionTransforms = this.removeDivisionMarkdownNodes(FootnoteDivisionTransform, context);
+  //
+  //   footnoteDivisionTransforms.forEach((footnoteDivisionTransform) => {
+  //     const footnoteTransform = FootnoteTransform.fromFootnoteDivisionTransform(footnoteDivisionTransform),
+  //           identifier = footnoteDivisionTransform.identifier(context);
+  //
+  //     footnoteTransformMap[identifier] = footnoteTransform;
+  //   });
+  // }
+
+  findDivisionTransform(DivisionTransform, context) {
+    let subDivisionTransform = null;
+
+    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
 
     subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
-      subDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context);
+      subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
 
-      if (subDivisionReplacement !== null) {
+      if (subDivisionTransform !== null) {
         return true;
       }
     });
 
-    return subDivisionReplacement;
+    return subDivisionTransform;
   }
 
-  findSubDivisionReplacements(SubDivisionReplacement, context) {
-    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes(),
-          subDivisionReplacements = subDivisionMarkdownNodes.reduce((subDivisionReplacements, subDivisionMarkdownNode) => {
-            const subDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context);
+  findDivisionTransforms(DivisionTransform, context) {
+    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes(),
+          subDivisionTransforms = subDivisionMarkdownNodes.reduce((subDivisionTransforms, subDivisionMarkdownNode) => {
+            const subDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(subDivisionMarkdownNode, context);
 
-            if (subDivisionReplacement !== null) {
-              subDivisionReplacements.push(subDivisionReplacement);
+            if (subDivisionTransform !== null) {
+              subDivisionTransforms.push(subDivisionTransform);
             }
 
-            return subDivisionReplacements;
+            return subDivisionTransforms;
           }, []);
 
-    return subDivisionReplacements;
+    return subDivisionTransforms;
   }
 
-  findSubDivisionMarkdownNodes() {
+  findDivisionMarkdownNodes() {
     const node = this,  ///
           subDivisionMarkdownNodes = subDivisionMarkdownNodesFromNode(node);
 
@@ -250,7 +235,7 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   findPageNumberDirectiveMarkdownNode() {
     let pageNumberDirectiveMarkdownNode = null;
 
-    const subDivisionMarkdownNodes = this.findSubDivisionMarkdownNodes();
+    const subDivisionMarkdownNodes = this.findDivisionMarkdownNodes();
 
     subDivisionMarkdownNodes.some((subDivisionMarkdownNode) => {
       const node = subDivisionMarkdownNode; ///
@@ -265,97 +250,55 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return pageNumberDirectiveMarkdownNode;
   }
 
-  removeSubDivisionMarkdownNode(SubDivisionReplacement, context) {
+  removeDivisionMarkdownNode(DivisionTransform, context) {
     const divisionMarkdownNode = this,  //
-          subDivisionReplacement = this.findSubDivisionReplacement(SubDivisionReplacement, context);
+          subDivisionTransform = this.findDivisionTransform(DivisionTransform, context);
 
-    if (subDivisionReplacement !== null) {
-      subDivisionReplacement.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+    if (subDivisionTransform !== null) {
+      subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
     }
 
-    return subDivisionReplacement;
+    return subDivisionTransform;
   }
 
-  removeSubDivisionMarkdownNodes(SubDivisionReplacement, context) {
+  removeDivisionMarkdownNodes(DivisionTransform, context) {
     const divisionMarkdownNode = this,  //
-          subDivisionReplacements = this.findSubDivisionReplacements(SubDivisionReplacement, context);
+          subDivisionTransforms = this.findDivisionTransforms(DivisionTransform, context);
 
-    subDivisionReplacements.forEach((subDivisionReplacement) => {
-      subDivisionReplacement.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+    subDivisionTransforms.forEach((subDivisionTransform) => {
+      subDivisionTransform.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
     });
 
-    return subDivisionReplacements;
+    return subDivisionTransforms;
   }
 
-  createFootnotesListReplacement(footnoteReplacementMap, context) {
-    const footnoteSubDivisionReplacements = this.findSubDivisionReplacements(FootnoteSubDivisionReplacement, context);
+  createFootnotesListTransform(footnoteTransformMap, context) {
+    const footnoteDivisionTransforms = this.findDivisionTransforms(FootnoteDivisionTransform, context);
 
-    footnoteSubDivisionReplacements.forEach((footnoteSubDivisionReplacement) => {
-      const footnoteReplacement = FootnoteReplacement.fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement),
-            identifier = footnoteSubDivisionReplacement.identifier(context);
+    footnoteDivisionTransforms.forEach((footnoteDivisionTransform) => {
+      const footnoteTransform = FootnoteTransform.fromFootnoteDivisionTransform(footnoteDivisionTransform),
+            identifier = footnoteDivisionTransform.identifier(context);
 
-      footnoteReplacementMap[identifier] = footnoteReplacement;
+      footnoteTransformMap[identifier] = footnoteTransform;
     });
 
     const divisionMarkdownNode = this,  ///
-          footnotesListSubDivisionReplacement = FootnotesListReplacement.fromDivisionMarkdownNodeAndFootnoteReplacementMap(divisionMarkdownNode, footnoteReplacementMap, context);
-
-    return footnotesListSubDivisionReplacement;
-  }
-
-  asHTML(context) {
-    let html = null;
-
-    const indent = EMPTY_STRING,
-          childNodesHTML = this.childNodesAsHTML(indent, context);
+          footnotesListDivisionTransform = FootnotesListTransform.fromDivisionMarkdownNodeAndFootnoteTransformMap(divisionMarkdownNode, footnoteTransformMap, context);
 
-    if (childNodesHTML !== null) {
-      const startingTag = this.startingTag(context),
-            closingTag = this.closingTag(context);
-
-      html = `${indent}${startingTag}
-${childNodesHTML}${indent}${closingTag}
-`;
-    }
-
-    return html;
+    return footnotesListDivisionTransform;
   }
 
   clone() { return super.clone(this.divisionClassName); }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
-    const divisionClassName = null,
-          divisionMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity, divisionClassName);
-
-    return divisionMarkdownNode;
-  }
-
-  static fromPaginatedChildNodesSubDivisionReplacementsAndDivisionClassName(paginatedChildNodes, subDivisionReplacements, divisionClassName, context) {
-    const ruleName = DIVISION_RULE_NAME,
-          childNodes = [
-            ...paginatedChildNodes
-          ],
-          opacity = null,
-          divisionMarkdownNode = DivisionMarkdownNode.fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity);
-
-    divisionMarkdownNode.setDivisionClassName(divisionClassName);
-
-    subDivisionReplacements.forEach((subDivisionReplacement) => {
-      subDivisionReplacement = subDivisionReplacement.clone();  ///
-
-      subDivisionReplacement.appendToDivisionMarkdownNode(divisionMarkdownNode, context);
-    });
-
-    return divisionMarkdownNode;
-  }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(DivisionMarkdownNode, ruleName, childNodes, opacity); }
 }
 
-function paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionReplacements, divisionClassName, markdownNodes, pageNumber, context) {
+function paginateDivisionMarkdownNode(paginatedChildNodes, subDivisionTransforms, divisionClassName, markdownNodes, pageNumber, context) {
   let markdownNode;
 
-  const indexAnchorReplacement = IndexAnchorReplacement.fromPageNumber(pageNumber, context),
-        divisionMarkdownNode = DivisionMarkdownNode.fromPaginatedChildNodesSubDivisionReplacementsAndDivisionClassName(paginatedChildNodes, subDivisionReplacements, divisionClassName, context),
-        anchorMarkdownNode = indexAnchorReplacement.getAnchorMarkdownNode();
+  const indexAnchorTransform = IndexAnchorTransform.fromPageNumber(pageNumber, context),
+        divisionMarkdownNode = DivisionMarkdownNode.fromPaginatedChildNodesDivisionTransformsAndDivisionClassName(paginatedChildNodes, subDivisionTransforms, divisionClassName, context),
+        anchorMarkdownNode = indexAnchorTransform.getAnchorMarkdownNode();
 
   divisionMarkdownNode.setPageNumber(pageNumber);