highmark-markdown 1.0.173 → 1.0.174

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

@@ -0,0 +1,72 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+import { INDEX_PREPEND } from "../../../prepends";
+import { HREF_ATTRIBUTE_NAME } from "../../../attributeNames";
+
+export default class IndexLinkHTMLNode extends HTMLNode {
+  attributeName(context) {
+    const attributeName = HREF_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const content = this.content(context),
+          attributeValue = `#${INDEX_PREPEND}-${content}`;
+
+    return attributeValue;
+  }
+
+  asHTML(indent, context) {
+    const childNodesHTML = this.childNodesAsHTML(indent, context),
+          startingTag = this.startingTag(context),
+          closingTag = this.closingTag(context),
+          html = `${startingTag}${childNodesHTML}${closingTag}`;
+
+    return html;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const content = this.content(context),
+          childNodesHTML = content; ///
+
+    return childNodesHTML;
+  }
+
+  createDOMElement(context) {
+    let domElement;
+
+    const content = this.content(context),
+          textNode = document.createTextNode(content);
+
+    domElement = super.createDOMElement(context);
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
+  }
+
+  createChildNodeDOMElements(context) {
+    const content = this.content(context),
+          textNode  = document.createTextNode(content),
+          domElement = textNode; ///
+
+    this.addDOMElement(domElement);
+  }
+
+  static tagName = "a";
+
+  static className = "index";
+
+  static fromNothing() { return HTMLNode.fromNothing(IndexLinkHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(IndexLinkHTMLNode, outerNode); }
+}

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+import { START_ATTRIBUTE_NAME } from "../../../attributeNames";
+
+export default class FootnotesListHTMLNode extends HTMLNode {
+  attributeName(context) {
+    const attributeName = START_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const attributeValue = this.start;  ///
+
+    return attributeValue;
+  }
+
+  static tagName = "ol";
+
+  static className = "footnotes";
+
+  static fromNothing() { return HTMLNode.fromNothing(FootnotesListHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(FootnotesListHTMLNode, outerNode); }
+}

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

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

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

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

package/src/node/html/{blockListing.js → listing/block.js}

@@ -1,18 +1,15 @@
 "use strict";
 
-import HTMLNode from "../../node/html";
+import HTMLNode from "../../../node/html";
 
 export default class BlockListingHTMLNode extends HTMLNode {
   className(context) { return this.outerNode.className(context); }
 
-  asHTML(indent, context) {
-    const childNodesHTML = this.childNodesAsHTML(indent, context),
-          startingTag = this.startingTag(context),
-          closingTag = this.closingTag(context),
-          html = `${startingTag}${childNodesHTML}${closingTag}`;
+  static lines = 2;
 
-    return html;
-  }
+  static tagName = "pre";
+
+  static className = null;
 
   static fromNothing() { return HTMLNode.fromNothing(BlockListingHTMLNode); }
 

package/src/node/html/listing/inline.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+export default class InlineListingHTMLNode extends HTMLNode {
+  createDOMElement(context) {
+    let domElement;
+
+    const content = this.content(context),
+          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;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const content = this.content(context),
+          childNodesHTML = content; ///
+
+    return childNodesHTML;
+  }
+
+  childNodesAsPlainText(indent, context) {
+    const content = this.content(context),
+          childNodesPlainText = content; ///
+
+    return childNodesPlainText;
+  }
+
+  static tagName = "code";
+
+  static className = "inline";
+
+  static fromNothing() { return HTMLNode.fromNothing(InlineListingHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(InlineListingHTMLNode, outerNode); }
+}

package/src/node/html/pageNumber.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+export default class PageNumberHTMLNode extends HTMLNode {
+  getPageNumber() { return this.outerNode.getPageNumber(); }
+
+  createDOMElement(context) {
+    let domElement;
+
+    const pageNumber = this.getPageNumber(),
+          content = pageNumber, ///
+          textNode = document.createTextNode(content);
+
+    domElement = super.createDOMElement(context)
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
+  }
+
+  asPlainText(context) {
+    const pageNumber = this.getPageNumber(),
+          plainText = pageNumber; ///
+
+    return plainText;
+  }
+
+  childNodesAsHTML(indent, context) {
+    const pageNumber = this.getPageNumber(),
+          childNodesHTML = `${pageNumber}
+`;
+
+    return childNodesHTML;
+  }
+
+  static fromNothing() { return HTMLNode.fromNothing(PageNumberHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(PageNumberHTMLNode, outerNode); }
+}

package/src/node/html/paragraph.js

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

package/src/node/html/table.js

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

package/src/node/html/tableBody.js

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

package/src/node/html/tableBodyCell.js

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

package/src/node/html/tableBodyRow.js

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

package/src/node/html/tableHead.js

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

package/src/node/html/tableHeadCell.js

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

package/src/node/html/tableHeadRow.js

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

package/src/node/html/text/block.js

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

package/src/node/html/text/emphasised.js

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

package/src/node/html/text/inline.js

@@ -0,0 +1,57 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+
+import { EMPTY_STRING } from "../../../constants";
+
+export default class InlineTextHTMLNode extends HTMLNode {
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.childNodes.forEach((childNode) => {
+      childNode.mount(parentDOMElement, siblingDOMElement, context);
+    });
+  }
+
+  unmount(parentDOMElement, context) {
+    this.childNodes.forEach((childNode) => {
+      childNode.unmount(parentDOMElement, context);
+    });
+  }
+
+  asHTML(indent, context) {
+    const childNodesHTML = this.childNodesAsHTML(indent, context),
+          html = childNodesHTML;  ///
+
+    return html;
+  }
+
+  childNodesAsHTML(indent, context) {
+    let childNodesHTML;
+
+    childNodesHTML = super.childNodesAsHTML(indent, context);
+
+    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 = null;
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(InlineTextHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(InlineTextHTMLNode, outerNode); }
+}

package/src/node/html/text/plain.js

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

package/src/node/html/text/strong.js

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

package/src/node/html/text/stronglyEmphasised.js

@@ -0,0 +1,98 @@
+"use strict";
+
+import HTMLNode from "../../../node/html";
+import tagNameMap from "../../../map/tagName";
+
+import { EMPTY_STRING } from "../../../constants";
+import { STRONG_TEXT_RULE_NAME } from "../../../ruleNames";
+
+export default class StronglyEmphasisedTextHTMLNode extends HTMLNode {
+  createChildDOMElement(context) {
+    let domElement;
+
+    const tagName = tagNameMap[STRONG_TEXT_RULE_NAME],
+          plainText = this.childNodesAsPlainText(context),
+          content = plainText,  ///
+          textNode = document.createTextNode(content);
+
+    domElement = document.createElement(tagName);
+
+    const parentDOMElement = domElement;  ///
+
+    domElement = textNode; ///
+
+    parentDOMElement.appendChild(domElement);
+
+    domElement = parentDOMElement;  ///
+
+    return domElement;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    this.domElement = this.createDOMElement(context);
+
+    parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
+
+    const childDOMElement = this.createChildDOMElement(context),
+          domElement = childDOMElement; ///
+
+    parentDOMElement = this.domElement;
+
+    siblingDOMElement = null;
+
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
+
+  }
+
+  unmount(parentDOMElement, context) {
+    {
+      const parentDOMElement = this.domElement,
+            firstChild = parentDOMElement.firstChild,
+            domElement = firstChild;  ///
+
+      parentDOMElement.removeChild(domElement)
+    }
+
+    parentDOMElement.removeChild(this.domElement);
+
+    this.domElement = null;
+  }
+
+  childNodesAsHTML(indent, context) {
+    let childNodesHTML;
+
+    indent = this.adjustIndent(indent);
+
+    childNodesHTML = super.childNodesAsHTML(indent, context);
+
+    const startingTag = `<${strongTextTagName}>`,
+          closingTag = `</${strongTextTagName}>`,
+          html = `${indent}${startingTag}
+${childNodesHTML}${indent}${closingTag}
+`;
+
+    childNodesHTML = html;  ///
+
+    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 = "em";
+
+  static className = null;
+
+  static fromNothing() { return HTMLNode.fromNothing(StronglyEmphasisedTextHTMLNode); }
+
+  static fromOuterNode(outerNode) { return HTMLNode.fromOuterNode(StronglyEmphasisedTextHTMLNode, outerNode); }
+}

package/src/node/html/text.js

@@ -0,0 +1,34 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+export default class TextHTMLNode extends HTMLNode {
+  text(content) { return this.outerNode.text(content); }
+
+  createDOMElement(context) {
+    const text = this.text(context),
+          content = text, ///
+          textNode = document.createTextNode(content),
+          domElement = textNode;  ///
+
+    return domElement;
+  }
+
+  asHTML(indent, context) {
+    const text = this.text(context),
+          html = text; ///
+
+    return html;
+  }
+
+  asPlainText(context) {
+    const text = this.text(context),
+          plainText = text; ///
+
+    return plainText;
+  }
+
+  static fromNothing(Class) { return HTMLNode.fromNothing(Class); }
+
+  static fromOuterNode(Class, outerNode) { return HTMLNode.fromOuterNode(Class, outerNode); }
+}