highmark-markdown 1.0.183 → 1.0.185

package/src/transform/html/directive/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html"
+
+export default class IndexDirectiveHTMLTransform extends HTMLTransform {
+  getIndexDirectiveHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          indexDirectiveHTMLNode = htmlNode; ///
+
+    return indexDirectiveHTMLNode;
+  }
+
+  static fromIndexDirectiveHTMLNode(indexDirectiveHTMLNde) {
+    const htmlNode = indexDirectiveHTMLNde, ///
+          indexDirectiveHTMLTransform = HTMLTransform.fromHTMLNode(IndexDirectiveHTMLTransform, htmlNode);
+
+    return indexDirectiveHTMLTransform;
+  }
+}

package/src/transform/html/directive/pageNumber.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html"
+
+export default class PageNumberDirectiveHTMLTransform extends HTMLTransform {
+  static fromPageNumberDirectiveHTMLNode(pageNumberDirectiveHTMLNde) {
+    const htmlNode = pageNumberDirectiveHTMLNde, ///
+          pageNumberDirectiveHTMLTransform = HTMLTransform.fromHTMLNode(PageNumberDirectiveHTMLTransform, htmlNode);
+
+    return pageNumberDirectiveHTMLTransform;
+  }
+}

package/src/transform/html/division.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import HTMLTransform from "../../transform/html"
+
+export default class DivisionHTMLTransform extends HTMLTransform {
+  getDivisionHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          divisionHTMLNode = htmlNode;  ///;
+
+    return divisionHTMLNode;
+  }
+
+  appendToTopmostHTMLNode(topmostHTMLNode) {
+    const htmlNode = this.getHTMLNode(),
+          childNode = htmlNode, ///
+          parentNode = topmostHTMLNode; ///
+
+    parentNode.appendChildNode(childNode);
+  }
+
+  resolve(divisionHTMLNodes, context) {
+    const divisionHTMLNode = this.getDivisionHTMLNode();
+
+    divisionHTMLNode.resolve(divisionHTMLNodes, context);
+  }
+
+  static fromDivisionHTMLNode(divisionHTMLNode) {
+    const htmlNode = divisionHTMLNode, ///
+          paragraphHTMLTransform = HTMLTransform.fromHTMLNode(DivisionHTMLTransform, htmlNode);
+
+    return paragraphHTMLTransform;
+  }
+}

package/src/transform/html/footnote.js

@@ -0,0 +1,66 @@
+"use strict";
+
+import HTMLTransform from "../../transform/html"
+
+export default class FootnoteHTMLTransform extends HTMLTransform {
+  identifier(context) {
+    const footnoteHTMLNode = this.getFootnoteHTMLNode(),
+          identifier = footnoteHTMLNode.identifier(context);
+
+    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;  ///
+
+    return footnoteHTMLNode;
+  }
+
+  getParagraphHTMLNode() {
+    const footnoteHTMLNode = this.getFootnoteHTMLNode(),  ///
+          paragraphHTMLNode = footnoteHTMLNode.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;
+  }
+
+  addAfterFootnoteLinkHTMLTransform(footnoteLinkHTMLTransform) {
+    const containingHTMLNode = footnoteLinkHTMLTransform.getContainingHTMLNode(),
+          existingHTMLNode = containingHTMLNode;  ///
+
+    this.addAfter(existingHTMLNode);
+  }
+
+  static fromFootnoteHTMLNode(footnoteHTMLNde) {
+    const htmlNode = footnoteHTMLNde, ///
+          footnoteHTMLTransform = HTMLTransform.fromHTMLNode(FootnoteHTMLTransform, htmlNode);
+
+    return footnoteHTMLTransform;
+  }
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html";
+import IndexHeadingHTMLNode from "../../../node/html/heading/index";
+
+export default class IndexHeadingHTMLTransform extends HTMLTransform {
+  static fromLetter(letter) {
+    const indexHeadingHTMLNode = IndexHeadingHTMLNode.fromLetter(letter),
+          htmlNode = indexHeadingHTMLNode,  ///
+          indexHeadingHTMLTransform = HTMLTransform.fromHTMLNode(IndexHeadingHTMLTransform, htmlNode);
+
+    return indexHeadingHTMLTransform;
+  }
+}

package/src/transform/html/index.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import letters from "../../letters";
+import IndexList from "../../index/list";
+import HTMLTransform from "../../transform/html";
+import IndexListHTMLTransform from "../../transform/html/list/index";
+import IndexHeadingHTMLTransform from "../../transform/html/heading/index";
+
+export default class IndexHTMLTransform extends HTMLTransform {
+  constructor(htmlNode, htmlNodes) {
+    super(htmlNode);
+
+    this.htmlNodes = htmlNodes;
+  }
+
+  getHTMLNodes() {
+    return this.htmlNodes;
+  }
+
+  replace(replacedHTMLNode) {
+    const parentNode = replacedHTMLNode.getParentNode(),
+          replacedChildNode = replacedHTMLNode, ///
+          replacementChildNodes = this.htmlNodes; ///
+
+    parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);
+  }
+
+  replaceIndexDirectiveHTMLTransform(indexDirectiveHTMLTransform) {
+    const indexDirectiveHTMLNode = indexDirectiveHTMLTransform.getIndexDirectiveHTMLNode(),
+          replacedHTMLNode = indexDirectiveHTMLNode;  ///
+
+    this.replace(replacedHTMLNode)
+  }
+
+  static fromIndexDirectiveHTMLTransformAndDivisionHTMLNodes(indexDirectiveHTMLTransform, divisionHTMLNodes, context) {
+    let indexHTMLTransform = null;
+
+    const indexDirectiveHTMLNode = indexDirectiveHTMLTransform.getIndexDirectiveHTMLNode(),
+          indexList = IndexList.fromIndexDirectiveHTMLNodeAndDivisionHTMLNodes(indexDirectiveHTMLNode, divisionHTMLNodes, context),
+          indexHTMLTransforms = [];
+
+    letters.forEach((letter) => {
+      const indexListHTMLTransform = IndexListHTMLTransform.fromIndexListAndLetter(indexList, letter);
+
+      if (indexListHTMLTransform !== null) {
+        let indexHTMLTransform;
+
+        const indexHeadingHTMLTransform = IndexHeadingHTMLTransform.fromLetter(letter);
+
+        indexHTMLTransform = indexHeadingHTMLTransform; ///
+
+        indexHTMLTransforms.push(indexHTMLTransform);
+
+        indexHTMLTransform = indexListHTMLTransform;  ///
+
+        indexHTMLTransforms.push(indexHTMLTransform);
+      }
+    });
+
+    const indexListHTMLTransformsLength = indexHTMLTransforms.length;
+
+    if (indexListHTMLTransformsLength > 0) {
+      const htmlNode = null,
+            htmlNodes = [];
+
+      indexHTMLTransforms.forEach((indexHTMLTransform) => {
+        const htmlNode = indexHTMLTransform.getHTMLNode();
+
+        htmlNodes.push(htmlNode);
+      });
+
+      indexHTMLTransform = HTMLTransform.fromHTMLNode(IndexHTMLTransform, htmlNode, htmlNodes);
+    }
+
+    return indexHTMLTransform;
+  }
+}

package/src/transform/html/indexAnchor.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import HTMLTransform from "../../transform/html"
+import AnchorHTMLNode from "../../node/html/anchor";
+
+import { INDEX_PREPEND } from "../../prepends";
+
+export default class IndexAnchorTMLTransform extends HTMLTransform {
+  prependToDivisionHTMLNode(divisionHTMLNode) {
+    const parentHTMLNode = divisionHTMLNode;
+
+    this.prependTo(parentHTMLNode);
+  }
+
+  static fromPageNumber(pageNumber) {
+    const prepend = INDEX_PREPEND,
+          identifier = pageNumber,  ///
+          anchorHTMLNode = AnchorHTMLNode.fromPrependAndIdentifier(prepend, identifier),
+          htmlNode = anchorHTMLNode, ///
+          paragraphHTMLTransform = HTMLTransform.fromHTMLNode(IndexAnchorTMLTransform, htmlNode);
+
+    return paragraphHTMLTransform;
+  }
+}

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

@@ -0,0 +1,48 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html";
+import ContentsItemHTMLNode from "../../../node/html/item/contents";
+import ContentsLinkHTMLTransform from "../../../transform/html/link/contents";
+
+export default class ContentsItemHTMLTransform extends HTMLTransform {
+  getContentsItemHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          contentsItemHTMLNode = htmlNode;  ///
+
+    return contentsItemHTMLNode;
+  }
+
+  static fromNestedHeadingNode(nestedHeadingNode, context) {
+    const htmlTransforms = [],
+          contentsLinkHTMLTransform = ContentsLinkHTMLTransform.fromNestedHeadingNode(nestedHeadingNode, context);
+
+    if (contentsLinkHTMLTransform !== null) {
+      const htmlNode = nestedHeadingNode.getHTMLNode(),
+            headingHTMLNode = htmlNode;  ///
+
+      headingHTMLNode.anchor(context);
+
+      const htmlTransform = contentsLinkHTMLTransform;  ///
+
+      htmlTransforms.push(htmlTransform);
+    }
+
+    const childNestedNodes = nestedHeadingNode.getChildNestedNodes(),
+          nestedHeadingNodes = childNestedNodes,  ///
+          nestedHeadingNodesLength = nestedHeadingNodes.length;
+
+    if (nestedHeadingNodesLength > 0) {
+      const { ContentsListHTMLTransform } = ContentsItemHTMLTransform,
+            contentsListHTMLTransform = ContentsListHTMLTransform.fromNestedHeadingNodes(nestedHeadingNodes, context),
+            htmlTransform = contentsListHTMLTransform; ///
+
+      htmlTransforms.push(htmlTransform);
+    }
+
+    const contentsItemHTMLNode = ContentsItemHTMLNode.fromHTMLTransforms(htmlTransforms),
+          htmlNode = contentsItemHTMLNode,  ///
+          contentsItemHTMLTransform = HTMLTransform.fromHTMLNode(ContentsItemHTMLTransform, htmlNode);
+
+    return contentsItemHTMLTransform;
+  }
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html"
+import FootnoteItemHTMLNode from "../../../node/html/item/footnote";
+
+export default class FootnoteItemHTMLTransform extends HTMLTransform {
+  getFootnoteItemHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          footnoteItemHTMLNode = htmlNode; ///
+
+    return footnoteItemHTMLNode;
+  }
+
+  static fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier) {
+    const footnoteItemHTMLNode = FootnoteItemHTMLNode.fromLineTMLTransformAndIdentifier(lineHTMLTransform, identifier),
+          ascendantNode = footnoteItemHTMLNode, ///
+          footnoteItemTransform = lineHTMLTransform.expand(FootnoteItemHTMLTransform, ascendantNode);
+
+    return footnoteItemTransform;
+  }
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html";
+import IndexItemHTMLNode from "../../../node/html/item";
+
+export default class IndexItemHTMLTransform extends HTMLTransform {
+  getIndexItemHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          indexItemHTMLNode = htmlNode; ///
+
+    return indexItemHTMLNode;
+  }
+
+  static fromIndexItem(indexItem) {
+    const indexItemHTNLMode = IndexItemHTMLNode.fromIndexItem(indexItem),
+          htmlNode = indexItemHTNLMode, ///
+          indexItemHTMLTransform = HTMLTransform.fromHTMLNode(IndexItemHTMLTransform, htmlNode);
+
+    return indexItemHTMLTransform;
+  }
+}

package/src/transform/html/line.js

@@ -0,0 +1,27 @@
+"use strict";
+
+import HTMLTransform from "../../transform/html"
+
+export default class LineHTMLTransform extends HTMLTransform {
+  getLineHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          lineHTMLNode = htmlNode;  ///;
+
+    return lineHTMLNode;
+  }
+
+  static fromLineHTMLNode(lineHTMLNode) {
+    const htmlNode = lineHTMLNode, ///
+          paragraphHTMLTransform = HTMLTransform.fromHTMLNode(LineHTMLTransform, htmlNode);
+
+    return paragraphHTMLTransform;
+  }
+
+  static fromFootnoteHTMLTransform(footnoteHTNLTransform) {
+    const lineHTMLNode = footnoteHTNLTransform.getLineHTMLNode(),
+          htmlNode = lineHTMLNode, ///
+          paragraphHTMLTransform = HTMLTransform.fromHTMLNode(LineHTMLTransform, htmlNode);
+
+    return paragraphHTMLTransform;
+  }
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html";
+import LineHTMLTransform from "../../../transform/html/line";
+import ContentsLinkHTMLNode from "../../../node/html/link/contents";
+
+export default class ContentsLinkHTMLTransform extends HTMLTransform {
+  getIdentifier() {
+    const contentsLinkHTMLNode = this.getContentsLinkHTMLNode(),
+          identifier = contentsLinkHTMLNode.getIdentifier();
+
+    return identifier;
+  }
+
+  getContentsLinkHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          contentsLinkHTMLNode = htmlNode;  ///
+
+    return contentsLinkHTMLNode;
+  }
+
+  static fromNestedHeadingNode(nestedHeadingNode, context) {
+    let contentsLinkHTMLTransform = null;
+
+    const htmlNode = nestedHeadingNode.getHTMLNode(),
+          headingHTMLNode = htmlNode;  ///
+
+    if (headingHTMLNode !== null) {
+      const identifier = headingHTMLNode.identifier(context),
+            lineHTMLNode = headingHTMLNode.getLineHTMLNode(),
+            lineHTMLTransform = LineHTMLTransform.fromLineHTMLNode(lineHTMLNode, context),
+            contentsLinkHTMLNode = ContentsLinkHTMLNode.fromLineHTMLTransformAndIdentifier(lineHTMLTransform, identifier),
+            htmlNode = contentsLinkHTMLNode;  ///
+
+      contentsLinkHTMLTransform = HTMLTransform.fromHTMLNode(ContentsLinkHTMLTransform, htmlNode);
+    }
+
+    return contentsLinkHTMLTransform;
+  }
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html"
+import DivisionHTMLNode from "../../../node/html/division";
+
+export default class FootnoteLinkHTMLTransform extends HTMLTransform {
+  getDivisionHTMLNode() {
+    const footnoteLinkHTMLNode = this.getFootnoteLinkHTMLNode(),
+          divisionHTMLNode = footnoteLinkHTMLNode.findAncestorNode((ancestorNode) => {
+            const ancestorNodeDivisionHTMLNode = (ancestorNode instanceof DivisionHTMLNode);
+
+            if (ancestorNodeDivisionHTMLNode) {
+              return true;
+            }
+          });
+
+    return divisionHTMLNode;
+  }
+
+  getContainingHTMLNode() {
+    let containingHTMLNode;
+
+    const footnoteLinkHTMLNode = this.getFootnoteLinkHTMLNode();
+
+    footnoteLinkHTMLNode.someAncestorNode((ancestorNode) => {
+      const ancestorNodeDivisionHTMLNode = (ancestorNode instanceof DivisionHTMLNode);
+
+      if (ancestorNodeDivisionHTMLNode) {
+        return true;
+      }
+
+      containingHTMLNode = ancestorNode;  ///
+    });
+
+    return containingHTMLNode;
+  }
+
+  getFootnoteLinkHTMLNode() {
+    const htmlNode = this.getHTMLNode(),
+          footnoteLinkHHTMLNode = htmlNode; ///
+
+    return footnoteLinkHHTMLNode;
+  }
+
+  identifier(context) {
+    const footnoteLinkHTMLNode = this.getFootnoteLinkHTMLNode(),
+          identifier = footnoteLinkHTMLNode.identifier(context);
+
+    return identifier;
+  }
+
+  static fromFootnoteLinkHTMLNode(footnoteLinkHTMLNode) {
+    const htmlNode = footnoteLinkHTMLNode,  ///
+          footnoteLinkHTMLTransform = HTMLTransform.fromHTMLNode(FootnoteLinkHTMLTransform, htmlNode);
+
+    return footnoteLinkHTMLTransform;
+  }
+}

package/src/transform/html/link/nestedFootnote.js

@@ -0,0 +1,12 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html"
+
+export default class NestedFootnoteLinkHTMLTransform extends HTMLTransform {
+  static fromNestedFootnoteLinkHTMLNode(nestedFootnoteLinkHTMLNode) {
+    const htmlNode = nestedFootnoteLinkHTMLNode,  ///
+          nestedFootnoteLinkHTMLTransform = HTMLTransform.fromHTMLNode(NestedFootnoteLinkHTMLTransform, htmlNode);
+
+    return nestedFootnoteLinkHTMLTransform;
+  }
+}

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

@@ -0,0 +1,86 @@
+"use strict";
+
+import { nodeUtilities } from "occam-dom";
+import { arrayUtilities } from "necessary";
+
+import HTMLTransform from "../../../transform/html";
+import ContentsListHTMLNode from "../../../node/html/list/contents";
+import ContentsItemHTMLTransform from "../../../transform/html/item/contents";
+
+import { nestHTMLNodes } from "../../../utilities/contents";
+import { headingHTMLNodesFromNode } from "../../../utilities/html";
+
+const { filter } = arrayUtilities,
+      { isLessThan } = nodeUtilities;
+
+class ContentsListHTMLTransform extends HTMLTransform {
+  replaceContentsDirectiveHTMLTransform(contentsDirectiveHTMLTransform) {
+    const contentsDirectiveHTMLNode = contentsDirectiveHTMLTransform.getContentsDirectiveHTMLNode(),
+          replacedHTMLNode = contentsDirectiveHTMLNode;  ///
+
+    super.replace(replacedHTMLNode);
+  }
+
+  static fromContentsDirectiveHTMLTransformAndTopmostHTMLNode(contentsDirectiveHTMLTransform, topmostHTMLNode, context) {
+    let contentsListHTMLTransform = null;
+
+    const node = topmostHTMLNode, ///
+          headingHTMLNodes = headingHTMLNodesFromNode(node),
+          contentsDirectiveHTMLNode = contentsDirectiveHTMLTransform.getContentsDirectiveHTMLNode();
+
+    filter(headingHTMLNodes, (headingHTMLNode) => {
+      const contentsDirectiveHTMLNodeLessThanHeadingHTMLNode = isLessThan(contentsDirectiveHTMLNode, headingHTMLNode);
+
+      if (contentsDirectiveHTMLNodeLessThanHeadingHTMLNode) {
+        return true;
+      }
+    });
+
+    const headingHTMLNodesLength = headingHTMLNodes.length;
+
+    if (headingHTMLNodesLength > 0) {
+      const nestedHeadingNodes = nestedHeadingNodesFromHeadingHTMLNodes(headingHTMLNodes),
+            contentsItemHTMLTransforms = contentsItemHTMLTransformsFromNestedHeadingNodes(nestedHeadingNodes, context),
+            contentsListHTMLNode = ContentsListHTMLNode.fromContentsItemHTMLTransforms(contentsItemHTMLTransforms),
+            htmlNode = contentsListHTMLNode;  ///
+
+      contentsListHTMLTransform = HTMLTransform.fromHTMLNode(ContentsListHTMLTransform, htmlNode);
+    }
+
+    return contentsListHTMLTransform;
+  }
+
+  static fromNestedHeadingNodes(nestedHeadingNodes, context) {
+    const contentsItemHTMLTransforms = contentsItemHTMLTransformsFromNestedHeadingNodes(nestedHeadingNodes, context),
+          contentsListHTMLNode = ContentsListHTMLNode.fromContentsItemHTMLTransforms(contentsItemHTMLTransforms),
+          htmlNode = contentsListHTMLNode,  ///
+          contentsListHTMLTransform = HTMLTransform.fromHTMLNode(ContentsListHTMLTransform, htmlNode);
+
+    return contentsListHTMLTransform;
+  }
+}
+
+Object.assign(ContentsItemHTMLTransform, {  ///
+  ContentsListHTMLTransform
+});
+
+export default ContentsListHTMLTransform;
+
+function nestedHeadingNodesFromHeadingHTMLNodes(headingHTMLNodes) {
+  const htmlNodes = headingHTMLNodes, ///
+        nestedNode = nestHTMLNodes(htmlNodes),
+        childNestedNodes = nestedNode.getChildNestedNodes(),
+        nestedHeadingNodes = childNestedNodes;  ///
+
+  return nestedHeadingNodes;
+}
+
+function contentsItemHTMLTransformsFromNestedHeadingNodes(nestedHeadingNodes, context) {
+  const contentsItemHTMLTransforms = nestedHeadingNodes.map((nestedHeadingNode) => {
+    const contentsItemHTMLTransform = ContentsItemHTMLTransform.fromNestedHeadingNode(nestedHeadingNode, context);
+
+    return contentsItemHTMLTransform;
+  });
+
+  return contentsItemHTMLTransforms;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html";
+import FootnotesListHTMLNode from "../../../node/html/list/footnotes";
+
+export default class FootnotesListHTMLTransform extends HTMLTransform {
+  appendToDivisionHTMLNode(divisionHTMLNode) {
+    const parentHTMLNode = divisionHTMLNode;
+
+    this.appendTo(parentHTMLNode);
+  }
+
+  static fromStartAndFootnoteItemHTMLTransforms(start, footnoteItemHTMLTransforms) {
+    const footnotesListHTMLNode = FootnotesListHTMLNode.fromStartAndFootnoteItemHTMLTransforms(start, footnoteItemHTMLTransforms),
+          htmlNode = footnotesListHTMLNode, ///
+          footnotesListHTMLTransform = HTMLTransform.fromHTMLNode(FootnotesListHTMLTransform, htmlNode);
+
+    return footnotesListHTMLTransform;
+  }
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+
+import HTMLTransform from "../../../transform/html";
+import IndexListHTMLNode from "../../../node/html/list/index";
+import IndexItemHTMLTransform from "../../../transform/html/item/index";
+
+export default class IndexListHTMLTransform extends HTMLTransform {
+  static fromIndexListAndLetter(indexList, letter) {
+    let indexListHTMLTransform = null;
+
+    const indexItemHTMLTransforms = indexList.reduceIndexItemByLetter(letter, (indexItem) => {
+            const indexItemHTMLTransform = IndexItemHTMLTransform.fromIndexItem(indexItem);
+
+            return indexItemHTMLTransform;
+          }),
+          indexItemHTMLTransformsLength = indexItemHTMLTransforms.length;
+
+    if (indexItemHTMLTransformsLength > 0) {
+      const indexListHTMLNode = IndexListHTMLNode.fromIndexItemHTMLTransforms(indexItemHTMLTransforms),
+            htmlNode = indexListHTMLNode; ///
+
+      indexListHTMLTransform = HTMLTransform.fromHTMLNode(IndexListHTMLTransform, htmlNode);
+    }
+
+    return indexListHTMLTransform;
+  }
+}

package/src/transform/html/pageNumber.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import HTMLTransform from "../../transform/html"
+import PageNumberHTMLNode from "../../node/html/pageNumber";
+
+export default class PageNumberTMLTransform extends HTMLTransform {
+  appendToDivisionHTMLNode(divisionHTMLNode) {
+    const parentHTMLNode = divisionHTMLNode;
+
+    this.appendTo(parentHTMLNode);
+  }
+
+  static fromPageNumber(pageNumber) {
+    const pageNumberHTMLNode = PageNumberHTMLNode.fromPageNumber(pageNumber),
+          htmlNode = pageNumberHTMLNode, ///
+          paragraphHTMLTransform = HTMLTransform.fromHTMLNode(PageNumberTMLTransform, htmlNode);
+
+    return paragraphHTMLTransform;
+  }
+}