highmark-markdown 1.0.152 → 1.0.154

package/src/mixins/node.js

@@ -122,6 +122,98 @@ function retrieveParentNode(childNode, node = this) {
   return parentNode;
 }
 
+function fromFirstChildNode(callback) {
+  let result;
+
+  const firstIndex = 0;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === firstIndex) {
+      const firstChildNode = childNode; ///
+
+      result = callback(firstChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromSecondChildNode(callback) {
+  let result;
+
+  const secondIndex = 1;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === secondIndex) {
+      const firstChildNode = childNode; ///
+
+      result = callback(firstChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromThirdChildNode(callback) {
+  let result;
+
+  const thirdIndex = 2;
+
+  this.forwardsSomeChildNode((childNode, index) => {
+    if (index === thirdIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromFirstLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        firstLastIndex = multiplicity - 1;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === firstLastIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+function fromSecondLastChildNode(callback) {
+  let result;
+
+  const multiplicity = this.getMultiplicity(),
+        secondLastIndex = multiplicity - 2;
+
+  this.backwardsSomeChildNode((childNode, index) => {
+    if (index === secondLastIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
 const nodeMixins = {
   removeChildNodes,
   removeChildNode,
@@ -132,7 +224,12 @@ const nodeMixins = {
   addChildNodeAfter,
   addChildNodesAfter,
   getDescendantNodes,
-  retrieveParentNode
+  retrieveParentNode,
+  fromFirstChildNode,
+  fromSecondChildNode,
+  fromThirdChildNode,
+  fromFirstLastChildNode,
+  fromSecondLastChildNode
 };
 
 export default nodeMixins;

package/src/node/markdown/blockListing.js

@@ -1,11 +1,7 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 
-const { first } = arrayUtilities;
-
 export default class BlockListingMarkdownNode extends MarkdownNode {
   asHTML(indent, context) {
       const childNodesHTML = this.childNodesAsHTML(indent, context),
@@ -19,10 +15,12 @@ export default class BlockListingMarkdownNode extends MarkdownNode {
   className(context) {
     let className = super.className(context);
 
-    const childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          blockListingStartMarkdownNode = firstChildNode, ///
-          blockListingStartMarkdownNodeClassName = blockListingStartMarkdownNode.className(context);
+    const blockListingStartMarkdownNodeClassName = this.fromFirstChildNode((firstChildNode) => {
+      const blockListingStartMarkdownNode = firstChildNode, ///
+            blockListingStartMarkdownNodeClassName = blockListingStartMarkdownNode.className(context);
+
+      return blockListingStartMarkdownNodeClassName;
+    });
 
     if (blockListingStartMarkdownNodeClassName !== null) {
       className = `${className} ${blockListingStartMarkdownNodeClassName}`;

package/src/node/markdown/blockListingStart.js

@@ -1,25 +1,23 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 import ClassNameMarkdownNode from "./className";
 
-const { second } = arrayUtilities;
-
 export default class BlockListingStartMarkdownNode extends MarkdownNode {
   className(context) {
-    let className = null;
+    const className = this.fromSecondChildNode((secondChildNode) => {
+      let className = null;
+
+      const secondChildNodeClassNameMarkdownNode = (secondChildNode instanceof ClassNameMarkdownNode)
 
-    const childNodes = this.getChildNodes(),
-          secondChildNode = second(childNodes),
-          secondChildNodeClassNameMarkdownNode = (secondChildNode instanceof ClassNameMarkdownNode)
+      if (secondChildNodeClassNameMarkdownNode) {
+        const classNameMarkdownNode = secondChildNode; ///
 
-    if (secondChildNodeClassNameMarkdownNode) {
-      const classNameMarkdownNode = secondChildNode; ///
+        className = classNameMarkdownNode.className(context);
+      }
 
-      className = classNameMarkdownNode.className(context);
-    }
+      return className;
+    });
 
     return className;
   }

package/src/node/markdown/className.js

@@ -1,18 +1,16 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 
-const { second } = arrayUtilities;
-
 export default class ClassNameMarkdownNode extends MarkdownNode {
   className(context) {
-    const childNodes = this.getChildNodes(),
-          secondChildNode = second(childNodes),
-          identifierTerminalNode = secondChildNode, ///
-          identifierTerminalNodeContent = identifierTerminalNode.getContent(),
-          className = identifierTerminalNodeContent; ///
+    const className = this.fromSecondChildNode((secondChildNode) => {
+      const identifierTerminalNode = secondChildNode, ///
+            identifierTerminalNodeContent = identifierTerminalNode.getContent(),
+            className = identifierTerminalNodeContent; ///
+
+      return className;
+    });
 
     return className;
   }

package/src/node/markdown/directives.js

@@ -1,11 +1,7 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 
-const { first } = arrayUtilities;
-
 export default class DirectivesMarkdownNode extends MarkdownNode {
   asHTML(indent, context) {
     const firstDirectiveMarkdownNode = this.getFirstDirectiveMarkdownNode(),
@@ -16,9 +12,11 @@ export default class DirectivesMarkdownNode extends MarkdownNode {
   }
 
   getFirstDirectiveMarkdownNode() {
-    const childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          firstDirectiveMarkdownNode = firstChildNode; ///
+    const firstDirectiveMarkdownNode = this.fromFirstChildNode((firstChildNode) => {
+      const firstDirectiveMarkdownNode = firstChildNode;  ///
+
+      return firstDirectiveMarkdownNode;
+    });
 
     return firstDirectiveMarkdownNode;
   }

package/src/node/markdown/division.js

@@ -91,13 +91,12 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     });
 
     const { linesPerPage } = context,
-          paginatedChildNodes = [],
-          childNodes = this.getChildNodes();
+          paginatedChildNodes = [];
 
     let { pageNumber } = context,
         totalLines = 0;
 
-    childNodes.forEach((childNode) => {
+    this.forEachChildNode((childNode) => {
       const lines = childNode.lines(context);
 
       if ((totalLines + lines) > linesPerPage) {

package/src/node/markdown/emailLink.js

@@ -1,47 +1,46 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 import contentMixins from "../../mixins/content";
 
 import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 
-const { first, second, secondLast } = arrayUtilities;
-
 class EmailLinkMarkdownNode extends MarkdownNode {
   inlineText(context) {
     let inlineText = null;
 
-    const childNodes = this.getChildNodes(),
-          childNodesLength = childNodes.length;
+    const multiplicity = this.getMultiplicity();
 
-    if (childNodesLength !== 1) {
-      const indent = null,
-            secondChildNode = second(childNodes),
-            inlineTextMarkdownNode = secondChildNode, ///
-            inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context);
+    if (multiplicity > 1) {
+      inlineText = this.fromSecondChildNode((secondChildNode) => {
+        const indent = null,
+              inlineTextMarkdownNode = secondChildNode, ///
+              inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context);
 
-      inlineText = inlineTextMarkdownNodeHTML;  ///
+        inlineText = inlineTextMarkdownNodeHTML;  ///
+      });
     }
 
     return inlineText;
   }
 
   emailAddress(context) {
-    const childNodes = this.getChildNodes(),
-          childNodesLength = childNodes.length;
+    const multiplicity = this.getMultiplicity();
 
     let emailAddressTerminalNode;
 
-    if (childNodesLength === 1) {
-      const firstChildNode = first(childNodes);
+    if (multiplicity === 1) {
+      emailAddressTerminalNode = this.fromFirstChildNode((firstChildNode) => {
+        const emailAddressTerminalNode = firstChildNode;  ///
 
-      emailAddressTerminalNode = firstChildNode;  ///
+        return emailAddressTerminalNode;
+      });
     } else {
-      const secondLastChildNode = secondLast(childNodes);
+      emailAddressTerminalNode = this.fromSecondLastChildNode((secondLastChildNode) => {
+        const emailAddressTerminalNode = secondLastChildNode;  ///
 
-      emailAddressTerminalNode = secondLastChildNode;  ///
+        return emailAddressTerminalNode;
+      });
     }
 
     const emailAddressTerminalNodeContent = emailAddressTerminalNode.getContent(),

package/src/node/markdown/emphasisedText.js

@@ -1,20 +1,18 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 import contentMixins from "../../mixins/content";
 
-const { second } = arrayUtilities;
-
 class EmphasisedTextMarkdownNode extends MarkdownNode {
   inlineText(context) {
-    const indent = null,
-          childNodes = this.getChildNodes(),
-          secondChildNode = second(childNodes),
-          inlineTextMarkdownNode = secondChildNode, ///
-          inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
-          inlineText = inlineTextMarkdownNodeHTML;  ///
+    const inlineText = this.fromSecondChildNode((secondChildNode) => {
+      const indent = null,
+            inlineTextMarkdownNode = secondChildNode, ///
+            inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
+            inlineText = inlineTextMarkdownNodeHTML;  ///
+
+      return inlineText;
+    });
 
     return inlineText;
   }

package/src/node/markdown/footnote.js

@@ -16,10 +16,12 @@ export default class FootnoteMarkdownNode extends MarkdownNode {
   }
 
   identifier(context) {
-    const childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          referenceMarkdownNode = firstChildNode,  ///
-          identifier = referenceMarkdownNode.identifier(context);
+    const identifier = this.fromFirstChildNode((firstChildNode) => {
+      const referenceMarkdownNode = firstChildNode,  ///
+            identifier = referenceMarkdownNode.identifier(context);
+
+      return identifier;
+    });
 
     return identifier;
   }

package/src/node/markdown/footnoteLink.js

@@ -34,10 +34,12 @@ export default class FootnoteLinkMarkdownNode extends MarkdownNode {
   }
 
   identifier(context) {
-    const childNodes = this.getChildNodes(),
-          firstChildNode = first(childNodes),
-          linkTerminalNode = firstChildNode,  ///
-          identifier = identifierFromLinkTerminalNode(linkTerminalNode);
+    const identifier = this.fromFirstChildNode((firstChildNode) => {
+      const linkTerminalNode = firstChildNode,  ///
+            identifier = identifierFromLinkTerminalNode(linkTerminalNode);
+
+      return identifier;
+    });
 
     return identifier;
   }

package/src/node/markdown/heading.js

@@ -34,9 +34,11 @@ export default class HeadingMarkdownNode extends MarkdownNode {
   }
 
   getLineMarkdownNode() {
-    const childNodes = this.getChildNodes(),
-          lastChildNode = last(childNodes),
-          lineMarkdownNode = lastChildNode;  ///
+    const lineMarkdownNode = this.fromFirstLastChildNode((firstLastChildNode) => {
+      const lineMarkdownNode = firstLastChildNode;  ///
+
+      return lineMarkdownNode;
+    });
 
     return lineMarkdownNode;
   }

package/src/node/markdown/hyperlink.js

@@ -7,23 +7,26 @@ import contentMixins from "../../mixins/content";
 
 import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
 
-const { first, second, secondLast } = arrayUtilities;
+const { second } = arrayUtilities;
 
 class HyperlinkLinkMarkdownNode extends MarkdownNode {
   url(context) {
-    const childNodes = this.getChildNodes(),
-          childNodesLength = childNodes.length;
+    const multiplicity = this.getMultiplicity();
 
     let urlTerminalNode;
 
-    if (childNodesLength === 1) {
-      const firstChildNode = first(childNodes);
+    if (multiplicity === 1) {
+      urlTerminalNode = this.fromFirstChildNode((firstChildNode) => {
+        const urlTerminalNode = firstChildNode; ///
 
-      urlTerminalNode = firstChildNode;  ///
+        return urlTerminalNode;
+      });
     } else {
-      const secondLastChildNode = secondLast(childNodes);
+      urlTerminalNode = this.fromSecondLastChildNode((secondLastChildNode) => {
+        const urlTerminalNode = secondLastChildNode; ///
 
-      urlTerminalNode = secondLastChildNode;  ///
+        return urlTerminalNode;
+      });
     }
 
     const urlTerminalNodeContent = urlTerminalNode.getContent(),
@@ -35,16 +38,16 @@ class HyperlinkLinkMarkdownNode extends MarkdownNode {
   inlineText(context) {
     let inlineText = null;
 
-    const childNodes = this.getChildNodes(),
-          childNodesLength = childNodes.length;
+    const multiplicity = this.getMultiplicity();
 
-    if (childNodesLength !== 1) {
-      const indent = null,
-            secondChildNode = second(childNodes),
-            inlineTextMarkdownNode = secondChildNode, ///
-            inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context);
+    if (multiplicity > 1) {
+      inlineText = this.fromSecondChildNode((secondChildNode) => {
+        const indent = null,
+              inlineTextMarkdownNode = secondChildNode, ///
+              inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context);
 
-      inlineText = inlineTextMarkdownNodeHTML;  ///
+        inlineText = inlineTextMarkdownNodeHTML;  ///
+      });
     }
 
     return inlineText;

package/src/node/markdown/image.js

@@ -6,15 +6,17 @@ import MarkdownNode from "../../node/markdown";
 
 import { ALT_ATTRIBUTE_NAME, SRC_ATTRIBUTE_NAME} from "../../attributeNames";
 
-const { second, secondLast } = arrayUtilities;
+const { secondLast } = arrayUtilities;
 
 export default class ImageMarkdownNode extends MarkdownNode {
   alt(context) {
-    const childNodes = this.getChildNodes(),
-          secondChildNode = second(childNodes),
-          inlineTextMarkdownNode = secondChildNode,  ///
-          inlineTextMarkdownNodeContent = inlineTextMarkdownNode.content(context),
-          alt = inlineTextMarkdownNodeContent; ///
+    const alt = this.fromSecondChildNode((secondChildNode) => {
+      const inlineTextMarkdownNode = secondChildNode,  ///
+            inlineTextMarkdownNodeContent = inlineTextMarkdownNode.content(context),
+            alt = inlineTextMarkdownNodeContent; ///
+
+      return alt;
+    });
 
     return alt;
   }

package/src/node/markdown.js

@@ -116,9 +116,7 @@ class MarkdownNode extends NonTerminalNode {
     ({ lines = null } = this.constructor);
 
     if (lines === null) {
-      const childNodes = this.getChildNodes();
-
-      lines = childNodes.reduce((lines, childNode) => {
+      lines = this.reduceChildNode((lines, childNode) => {
         const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
         if (childNodeMarkdownNode) {
@@ -256,8 +254,7 @@ ${childNodesHTML}${indent}${closingTag}
   }
 
   childNodesAsHTML(indent, context) {
-    const childNodes = this.getChildNodes(),
-          childNodesHTML = childNodes.reduce((childNodesHTML, childNode) => {
+    const childNodesHTML = this.reduceChildNode((childNodesHTML, childNode) => {
             const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
             if (childNodeMarkdownNode) {
@@ -278,8 +275,7 @@ ${childNodesHTML}${indent}${closingTag}
   }
 
   childNodesAsPlainText(context) {
-    const childNodes = this.getChildNodes(),
-          childNodesPlainText = childNodes.reduce((childNodesPlainText, childNode) => {
+    const childNodesPlainText = this.reduceChildNode((childNodesPlainText, childNode) => {
             const childNodeMarkdownNode = (childNode instanceof MarkdownNode);
 
             if (childNodeMarkdownNode) {

package/src/utilities/node.js

@@ -0,0 +1,93 @@
+"use strict";
+
+export function fromFirstChildNode(nonTerminalNode, callback) {
+  let result;
+
+  const firstIndex = 0;
+
+  nonTerminalNode.forwardsSomeChildNode((childNode, index) => {
+    if (index === firstIndex) {
+      const firstChildNode = childNode; ///
+
+      result = callback(firstChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+export function fromSecondChildNode(nonTerminalNode, callback) {
+  let result;
+
+  const secondIndex = 1;
+
+  nonTerminalNode.forwardsSomeChildNode((childNode, index) => {
+    if (index === secondIndex) {
+      const firstChildNode = childNode; ///
+
+      result = callback(firstChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+export function fromThirdChildNode(nonTerminalNode, callback) {
+  let result;
+
+  const thirdIndex = 2;
+
+  nonTerminalNode.forwardsSomeChildNode((childNode, index) => {
+    if (index === thirdIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+export function fromFirstLastChildNode(nonTerminalNode, callback) {
+  let result;
+
+  const multiplicity = nonTerminalNode.getMultiplicity(),
+        firstLastIndex = multiplicity - 1;
+
+  nonTerminalNode.backwardsSomeChildNode((childNode, index) => {
+    if (index === firstLastIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}
+
+export function fromSecondLastChildNode(nonTerminalNode, callback) {
+  let result;
+
+  const multiplicity = nonTerminalNode.getMultiplicity(),
+        secondLastIndex = multiplicity - 2;
+
+  nonTerminalNode.backwardsSomeChildNode((childNode, index) => {
+    if (index === secondLastIndex) {
+      const thirdChildNode = childNode; ///
+
+      result = callback(thirdChildNode);
+
+      return true;
+    }
+  });
+
+  return result;
+}