highmark-markdown 1.0.173 → 1.0.174

package/src/node/html/error.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+export default class ErrorHTMLNode extends HTMLNode {
+  error(context) { return this.outerNode.error(context); }
+
+  createDOMElement(context) {
+    let domElement;
+
+    const error = this.error(context),
+          content = error,  ///
+          textNode = document.createTextNode(content);
+
+    domElement = super.createDOMElement(context)
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
+  }
+
+  asHTML(indent, context) {
+    let html;
+
+    indent = this.adjustIndent(indent);
+
+    const childNodesHTML = this.childNodesAsHTML(indent, context),
+          startingTag = this.startingTag(context),
+          closingTag = this.closingTag(context);
+
+    html = `${indent}${startingTag}${childNodesHTML}${closingTag}
+`;
+
+    return html;
+  }
+
+  asPlainText(context) {
+    const error = this.error(context),
+          plainText = error;  ///
+
+    return plainText;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const error = this.error(context),
+          childNodesHTML = error; ///
+
+    return childNodesHTML;
+  }
+
+  static tagName = "span";
+
+  static className = "error";
+
+  static fromNothing() { return HTMLNode.fromNothing(ErrorHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(ErrorHTMLNode, outerNode); }
+}

package/src/node/html/footnote.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+export default class FootnoteHTMLNode extends HTMLNode {
+  mount(parentDOMElement, siblingDOMElement, context) {
+    ///
+  }
+
+  unmount(parentDOMElement, context) {
+    ///
+  }
+
+  static fromNothing() { return HTMLNode.fromNothing(FootnoteHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(FootnoteHTMLNode, outerNode); }
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class IndexHeadingHTMLNode extends HTMLNode {
+  static tagName = "h3";
+
+  static className = "index";
+
+  static fromNothing() { return HTMLNode.fromNothing(IndexHeadingHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(IndexHeadingHTMLNode, outerNode); }
+}

package/src/node/html/heading/primary.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class PrimaryHeadingHTMLNode extends HTMLNode {
+  static lines = 3;
+
+  static tagName = "h1";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(PrimaryHeadingHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(PrimaryHeadingHTMLNode, outerNode); }
+}

package/src/node/html/heading/quaternary.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class QuaternaryHeadingHTMLNode extends HTMLNode {
+  static lines = 2;
+
+  static tagName = "h4";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(QuaternaryHeadingHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(QuaternaryHeadingHTMLNode, outerNode); }
+}

package/src/node/html/heading/secondary.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class SecondaryHeadingHTMLNode extends HTMLNode {
+  static lines = 2.5;
+
+  static tagName = "h2";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(SecondaryHeadingHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(SecondaryHeadingHTMLNode, outerNode); }
+}

package/src/node/html/heading/tertiary.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class TertiaryHeadingHTMLNode extends HTMLNode {
+  static lines = 2.25;
+
+  static tagName = "h3";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(TertiaryHeadingHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(TertiaryHeadingHTMLNode, outerNode); }
+}

package/src/node/html/image.js

@@ -0,0 +1,107 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+import { EMPTY_STRING } from "../../constants";
+import { ALT_ATTRIBUTE_NAME, SRC_ATTRIBUTE_NAME } from "../../attributeNames";
+import {IMAGE_RULE_NAME} from "../../ruleNames";
+
+export default class ImageHTMLNode extends HTMLNode {
+  src(context) { return this.outerNode.src(context); }
+
+  alt(context) {
+    const alt = this.fromFirstChildNode((firstChildNode) => {
+      const inlineTextHTMLNode = firstChildNode,  ///
+            plainText = inlineTextHTMLNode.asPlainText(context),
+            alt = plainText;  ///
+
+      return alt;
+    });
+
+    return alt;
+  }
+
+  selfClosingTag(context) {
+    const tagName = this.tagName(context),
+          attributeNames = this.attributeNames(context),
+          attributeValues = this.attributeValues(context),
+          attributesHTML = attributeNames.reduce((attributesHML, attributeName, index) => {
+            const attributeValue = attributeValues[index];
+
+            attributesHML = (attributesHML === null) ?
+                              `${attributeName}="${attributeValue}"` :
+                                `${attributesHML} ${attributeName}="${attributeValue}"`;
+
+            return attributesHML;
+
+          }, null),
+          selfClosingTag = `<${tagName} ${attributesHTML}/>`;
+
+    return selfClosingTag;
+  }
+
+  attributeNames(context) {
+    const attributeNames = [
+      ALT_ATTRIBUTE_NAME,
+      SRC_ATTRIBUTE_NAME
+    ];
+
+    return attributeNames;
+  }
+
+  attributeValues(context) {
+    const alt = this.alt(context),
+          src = this.src(context),
+          attributeValues = [
+            alt,
+            src
+          ];
+
+    return attributeValues;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.domElement = this.createDOMElement(context);
+
+    parentDOMElement.insertBefore(this.domElement, siblingDOMElement)
+  }
+
+  unmount(parentDOMElement, context) {
+    parentDOMElement.removeChild(this.domElement);
+
+    this.domElement = null;
+  }
+
+  createDOMElement(context) {
+    let domElement;
+
+    const tagName = this.tagName(context);
+
+    domElement = document.createElement(tagName);
+
+    const attributeNames = this.attributeNames(context),
+          attributeValues = this.attributeValues(context);
+
+    attributeNames.forEach((attributeName, index) => {
+      const attributeValue = attributeValues[index];
+
+      domElement.setAttribute(attributeName, attributeValue);
+    });
+
+    return domElement;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const childNodesHTML = EMPTY_STRING;
+
+    return childNodesHTML;
+  }
+
+  static tagName = "img";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(ImageHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(ImageHTMLNode, outerNode); }
+}

package/src/node/html/indexList.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+export default class IndexListHTMLNode extends HTMLNode {
+  static tagName = "ul";
+
+  static className = "index";
+
+  static fromNothing() { return HTMLNode.fromNothing(IndexListHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(IndexListHTMLNode, outerNode); }
+}

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

@@ -0,0 +1,13 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class ContentsItemHTMLNode extends HTMLNode {
+  static tagName = "li";
+
+  static className = "contents";
+
+  static fromNothing() { return HTMLNode.fromNothing(ContentsItemHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(ContentsItemHTMLNode, outerNode); }
+}

package/src/node/html/item/footnotes.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class FootnotesListItemNode extends HTMLNode {
+  static tagName = "li";
+
+  static className = "footnotes";
+
+  static fromNothing() { return HTMLNode.fromNothing(FootnotesListItemNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(FootnotesListItemNode, outerNode); }
+}

package/src/node/{markdown/indexItem.js → html/item/index.js}

@@ -1,8 +1,8 @@
 "use strict";
 
-import MarkdownNode from "../../node/markdown";
+import HTMLNode from "../../../node/html";
 
-export default class IndexItemMarkdownNode extends MarkdownNode {
+export default class IndexItemHTMLNode extends HTMLNode {
   asHTML(indent, context) {
     indent = this.adjustIndent(indent);
 
@@ -23,5 +23,11 @@ export default class IndexItemMarkdownNode extends MarkdownNode {
     return childNodesHTML;
   }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexItemMarkdownNode, ruleName, childNodes, opacity); }
+  static tagName = "li";
+
+  static className = "index";
+
+  static fromNothing() { return HTMLNode.fromNothing(IndexItemHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(IndexItemHTMLNode, outerNode); }
 }

package/src/node/html/item/ordered.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import HTMLNode from "../../html";
+import HTMLNode from "../../../node/html";
 
 import { VALUE_ATTRIBUTE_NAME } from "../../../attributeNames";
 
@@ -20,6 +20,10 @@ export default class OrderedItemHTMLNode extends HTMLNode {
     return attributeValue;
   }
 
+  static tagName = "li";
+
+  static className = null;
+
   static fromNothing() { return HTMLNode.fromNothing(OrderedItemHTMLNode); }
 
   static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(OrderedItemHTMLNode, outerNode); }

package/src/node/html/item/unordered.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class UnorderedItemHTMLNode extends HTMLNode {
+  static tagName = "li";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(UnorderedItemHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(UnorderedItemHTMLNode, outerNode); }
+}

package/src/node/html/line.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+import PlainTextHTMLNode from "./text/plain";
+
+import { EMPTY_STRING } from "../../constants";
+
+export default class LineHTMLNode extends HTMLNode {
+  childNodesAsHTML(indent, context) {
+    let childNodesHTML;
+
+    let previousChildNode = null;
+
+    childNodesHTML = this.reduceChildNode((childNodesHTML, childNode) => {
+      const previousChildNodePlainTextHTMLNode = (previousChildNode instanceof PlainTextHTMLNode);
+
+      if (previousChildNodePlainTextHTMLNode) {
+        const childNodePlainTextHTMLNode = (childNode instanceof PlainTextHTMLNode);
+
+        if (!childNodePlainTextHTMLNode) {
+          childNodesHTML = `${childNodesHTML}
+`;
+        }
+      }
+
+      const childNodeHTML = childNode.asHTML(indent, context);
+
+      childNodesHTML = `${childNodesHTML}${childNodeHTML}`;
+
+      previousChildNode = childNode;  ///
+
+      return childNodesHTML;
+    }, EMPTY_STRING);
+
+    const previousChildNodePlainTextHTMLNode = (previousChildNode instanceof PlainTextHTMLNode);
+
+    if (previousChildNodePlainTextHTMLNode) {
+      childNodesHTML = `${childNodesHTML}
+`;
+    }
+
+    return childNodesHTML;
+  }
+
+  childNodesAsPlainText(context) {
+    const childNodesPlainText = this.reduceChildNode((childNodesPlainText, childNode) => {
+      const childNodePlainText = childNode.asPlainText(context);
+
+      childNodesPlainText = `${childNodesPlainText}${childNodePlainText}`;
+
+      return childNodesPlainText;
+    }, EMPTY_STRING);
+
+    return childNodesPlainText;
+  }
+
+  static tagName = "span";
+
+  static className = "line";
+
+  static fromNothing() { return HTMLNode.fromNothing(LineHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(LineHTMLNode, outerNode); }
+}

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

@@ -1,9 +1,9 @@
 "use strict";
 
-import HTMLNode from "../../node/html";
+import HTMLNode from "../../../node/html";
 
-import { CONTENTS_PREPEND } from "../../prepends";
-import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
+import { CONTENTS_PREPEND } from "../../../prepends";
+import { HREF_ATTRIBUTE_NAME } from "../../../attributeNames";
 
 export default class ContentsLinkHTMLNode extends HTMLNode {
   getIdentifier() { return this.outerNode.getIdentifier(); }
@@ -22,6 +22,10 @@ export default class ContentsLinkHTMLNode extends HTMLNode {
     return attributeValue;
   }
 
+  static tagName = "a";
+
+  static className = "contents-link";
+
   static fromNothing() { return HTMLNode.fromNothing(ContentsLinkHTMLNode); }
 
   static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(ContentsLinkHTMLNode, outerNode); }

package/src/node/html/link/email.js

@@ -0,0 +1,96 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+import { HREF_ATTRIBUTE_NAME } from "../../../attributeNames";
+
+export default class EmailLinkHTMLNode extends HTMLNode {
+  isSimple() { return this.outerNode.isSimple(); }
+
+  emailAddress(context) { return this.outerNode.emailAddress(context); }
+
+  attributeName(context) {
+    const attributeName = HREF_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const emailAddress = this.emailAddress(context),
+          attributeValue = `mailto:${emailAddress}`;
+
+    return attributeValue;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    super.mount(parentDOMElement, siblingDOMElement, context);
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const emailAddress = this.emailAddress(context),
+            content = emailAddress, ///
+            textNode = document.createTextNode(content),
+            domElement = textNode,  ///
+            parentDOMElement = this.domElement, ///
+            siblingDOMElement = null;
+
+      parentDOMElement.insertBefore(domElement, siblingDOMElement)
+    }
+  }
+
+  unmount(parentDOMElement, context) {
+    const simple = this.isSimple();
+
+    if (simple) {
+      const parentDOMElement = this.domElement,
+            firstChild = parentDOMElement.firstChild,
+            domElement = firstChild;  ///
+
+      parentDOMElement.removeChild(domElement)
+    }
+
+    super.unmount(parentDOMElement, context);
+  }
+
+  asPlainText(context) {
+    let plainText;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const emailAddress = this.emailAddress(context);
+
+      plainText = emailAddress; ///
+    } else {
+      plainText = super.asPlainText(context);
+    }
+
+    return plainText;
+  }
+
+  childNodesAsHTML(indent, context) {
+    let childNodesHTML;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const emailAddress = this.emailAddress(context);
+
+      childNodesHTML = `${emailAddress}
+`;
+    } else {
+      childNodesHTML = super.childNodesAsHTML(indent, context);
+    }
+
+    return childNodesHTML;
+  }
+
+  static tagName = "a";
+
+  static className = "email-link";
+
+  static fromNothing() { return HTMLNode.fromNothing(EmailLinkHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(EmailLinkHTMLNode, outerNode); }
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+import { FOOTNOTE_PREPEND } from "../../../prepends";
+import { HREF_ATTRIBUTE_NAME } from "../../../attributeNames";
+
+export default class FootnoteLinkHTMLNode extends HTMLNode {
+  attributeName(context) {
+    const attributeName = HREF_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const prepend = FOOTNOTE_PREPEND,
+          identifier = this.identifier(context),
+          attributeValue = `#${prepend}-${identifier}`; ///
+
+    return attributeValue;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const content = this.content(context),
+          childNodesHTML = content; ///
+
+    return childNodesHTML;
+  }
+
+  static fromNothing() { return HTMLNode.fromNothing(FootnoteLinkHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(FootnoteLinkHTMLNode, outerNode); }
+}

package/src/node/html/link/hyper.js

@@ -0,0 +1,96 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+import { HREF_ATTRIBUTE_NAME } from "../../../attributeNames";
+
+export default class HyperlinkHTMLNode extends HTMLNode {
+  isSimple() { return this.outerNode.isSimple(); }
+
+  url(context) { return this.outerNode.url(context); }
+
+  attributeName(context) {
+    const attributeName = HREF_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const url = this.url(context),
+          attributeValue = url; ///
+
+    return attributeValue;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    super.mount(parentDOMElement, siblingDOMElement, context);
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const url = this.url(context),
+            content = url, ///
+            textNode = document.createTextNode(content),
+            domElement = textNode,  ///
+            parentDOMElement = this.domElement, ///
+            siblingDOMElement = null;
+
+      parentDOMElement.insertBefore(domElement, siblingDOMElement)
+    }
+  }
+
+  unmount(parentDOMElement, context) {
+    const simple = this.isSimple();
+
+    if (simple) {
+      const parentDOMElement = this.domElement,
+            firstChild = parentDOMElement.firstChild,
+            domElement = firstChild;  ///
+
+      parentDOMElement.removeChild(domElement)
+    }
+
+    super.unmount(parentDOMElement, context);
+  }
+
+  asPlainText(context) {
+    let plainText;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const url = this.url(context);
+
+      plainText = url; ///
+    } else {
+      plainText = super.asPlainText(context);
+    }
+
+    return plainText;
+  }
+
+  childNodesAsHTML(indent, context) {
+    let childNodesHTML;
+
+    const simple = this.isSimple();
+
+    if (simple) {
+      const url = this.url(context);
+
+      childNodesHTML = `${url}
+`;
+    } else {
+      childNodesHTML = super.childNodesAsHTML(indent, context);
+    }
+
+    return childNodesHTML;
+  }
+
+  static tagName = "a";
+
+  static className = "hyperlink";
+
+  static fromNothing() { return HTMLNode.fromNothing(HyperlinkHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(HyperlinkHTMLNode, outerNode); }
+}