highmark-markdown 0.0.1

package/src/node/markdown/footnoteItem.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+import AnchorMarkdownNode from "../../node/markdown/anchor";
+
+import { FOOTNOTE_ITEM_RULE_NAME } from "../../ruleNames";
+
+const { first, second } = arrayUtilities;
+
+export default class FootnoteItemMarkdownNode extends MarkdownNode {
+  getIdentifier() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          anchorMarkdownNode = firstChildNode,  ///
+          identifier = anchorMarkdownNode.getIdentifier();
+
+    return identifier;
+  }
+
+  static fromFootnoteMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier) {
+    const anchorMarkdownNode = AnchorMarkdownNode.fromIdentifier(identifier),
+          footnoteMarkdownNodeChildNodes = footnoteMarkdownNode.getChildNodes(),
+          secondFootnoteMarkdownNodeChildNode = second(footnoteMarkdownNodeChildNodes),
+          paragraphMarkdownNode = secondFootnoteMarkdownNodeChildNode,  ///
+          ruleName = FOOTNOTE_ITEM_RULE_NAME,
+          childNodes = [
+            anchorMarkdownNode,
+            paragraphMarkdownNode
+          ],
+          ambiguous = false,
+          footnoteItemMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndAmbiguous(FootnoteItemMarkdownNode, ruleName, childNodes, ambiguous);
+
+    return footnoteItemMarkdownNode;
+  }
+}

package/src/node/markdown/footnotesList.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import FootnoteItemMarkdownNode from "./footnoteItem";
+
+import { FOOTNOTES_LIST_RULE_NAME } from "../../ruleNames";
+import { linkMarkdownNodesFromNode, footnoteMarkdownNodesFromNode } from "../../utilities/query";
+
+export default class FootnotesListMarkdownNode extends MarkdownNode {
+  getIdentifiers() {
+    const childNodes = this.getChildNodes(),
+          footnoteItemMarkdownNodes = childNodes, ///
+          identifiers = footnoteItemMarkdownNodes.map((footnoteItemMarkdownNode) => {
+            const identifier = footnoteItemMarkdownNode.getIdentifier();
+
+            return identifier;
+          });
+
+    return identifiers;
+  }
+
+  static fromDocumentMarkdownNode(documentMarkdownNode) {
+    let footnotesListMarkdownNode = null;
+
+    const footnoteItemMarkdownNodes = footnoteItemMarkdownNodesFromDocumentMarkdownNode(documentMarkdownNode),
+          footnoteItemMarkdownNodesLength = footnoteItemMarkdownNodes.length;
+
+    if (footnoteItemMarkdownNodesLength > 0) {
+      const ruleName = FOOTNOTES_LIST_RULE_NAME,
+            childNodes = footnoteItemMarkdownNodes, ///
+            ambiguous = false;
+
+      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndAmbiguous(FootnotesListMarkdownNode, ruleName, childNodes, ambiguous);
+    }
+
+    return footnotesListMarkdownNode;
+  }
+}
+
+function footnoteItemMarkdownNodesFromDocumentMarkdownNode(documentMarkdownNode) {
+  const footnoteItemMarkdownNodes = [],
+        footnoteMarkdownNodes = footnoteMarkdownNodesFromNode(documentMarkdownNode),
+        linkMarkdownNodes = linkMarkdownNodesFromNode(documentMarkdownNode),
+        identifiers = footnoteMarkdownNodes.map((footnoteMarkdownNode) => {
+          const identifier = footnoteMarkdownNode.getIdentifier();
+
+          return identifier;
+        });
+
+  linkMarkdownNodes.forEach((linkMarkdownNode) => {
+    const identifier = linkMarkdownNode.getIdentifier(),
+          index = identifiers.indexOf(identifier);
+
+    if (index > -1) {
+      const footnoteMarkdownNode = footnoteMarkdownNodes[index],
+            footnoteItemMarkdownNode = FootnoteItemMarkdownNode.fromFootnoteMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier);
+
+      footnoteItemMarkdownNodes.push(footnoteItemMarkdownNode);
+    }
+  });
+
+  return footnoteItemMarkdownNodes;
+}

package/src/node/markdown/hyperlink.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
+
+const { second, secondLast } = arrayUtilities;
+
+export default class HyperlinkMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          innerHTML = this.getInnerHTML(context),
+          href = this.getHref(context),
+          name = HREF_ATTRIBUTE_NAME,
+          value = href; ///
+
+    this.setAttribute(name, value);
+
+    this.setInnerHTML(innerHTML);
+
+    return domElement;
+  }
+
+  getInnerHTML(context) {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          inlineTextMarkdownNode = secondChildNode,  ///
+          inlineTextMarkdownNodeContent = inlineTextMarkdownNode.getContent(context),
+          innerHTML = inlineTextMarkdownNodeContent; ///
+
+    return innerHTML;
+  }
+
+  getHref(context) {
+    const childNodes = this.getChildNodes(),
+          secondLastChildNode = secondLast(childNodes),
+          URLMarkdownNode = secondLastChildNode,  ///
+          URLMarkdownNodeContent = URLMarkdownNode.getContent(context),
+          href = URLMarkdownNodeContent; ///
+
+    return href;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(HyperlinkMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/image.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+import { SRC_ATTRIBUTE_NAME } from "../../attributeNames";
+
+const { second, secondLast } = arrayUtilities;
+
+export default class ImageMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          innerHTML = this.getInnerHTML(context),
+          src = this.getSrc(context),
+          name = SRC_ATTRIBUTE_NAME,
+          value = src; ///
+
+    this.setAttribute(name, value);
+
+    this.setInnerHTML(innerHTML);
+
+    return domElement;
+  }
+
+  getInnerHTML(context) {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          inlineTextMarkdownNode = secondChildNode,  ///
+          inlineTextMarkdownNodeContent = inlineTextMarkdownNode.getContent(context),
+          innerHTML = inlineTextMarkdownNodeContent; ///
+
+    return innerHTML;
+  }
+
+  getSrc(context) {
+    const childNodes = this.getChildNodes(),
+          secondLastChildNode = secondLast(childNodes),
+          URLMarkdownNode = secondLastChildNode,  ///
+          URLMarkdownNodeContent = URLMarkdownNode.getContent(context),
+          src = URLMarkdownNodeContent; ///
+
+    return src;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(ImageMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/inlineListing.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { second } = arrayUtilities;
+
+export default class InlineListingMarkdownNode extends MarkdownNode {
+  getContent() {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          blockTextMarkdownNode = secondChildNode,  ///
+          content = blockTextMarkdownNode;  ///
+
+    return content;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(InlineListingMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/inlineText.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import contentMixins from "../../mixins/content";
+
+import MarkdownNode from "../markdown";
+
+class InlineTextMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const content = this.getContent(context),
+          domElement = document.createTextNode(content);
+
+    this.setDOMElement(domElement);
+
+    return domElement;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(InlineTextMarkdownNode, ruleName, childNodes, ambiguous); }
+}
+
+Object.assign(InlineTextMarkdownNode.prototype, contentMixins);
+
+export default InlineTextMarkdownNode;

package/src/node/markdown/line.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import { domElementsFromChildNodes } from "../../utilities/childNodes";
+
+export default class LineMarkdownNode extends MarkdownNode {
+  createChildNodeDOMElements(context) {
+    const domElement = this.getDOMElement(),
+          childNodes = this.getChildNodes(),
+          domElements = domElementsFromChildNodes(childNodes, context),
+          parentDOMElement = domElement,  ///
+          siblingDOMElement = null;
+
+    domElements.forEach((domElement) => {
+      parentDOMElement.insertBefore(domElement, siblingDOMElement);
+    });
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(LineMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/lineBreak.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class LineBreakMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(LineBreakMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/link.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+import { EMPTY_STRING } from "../../constants";
+import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
+
+const { second } = arrayUtilities;
+
+export default class LinkMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          href = this.getHRef(),
+          name = HREF_ATTRIBUTE_NAME,
+          value = href; ///
+
+    this.setAttribute(name, value);
+
+    return domElement;
+  }
+
+  getIdentifier() {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          textMarkdownNode = secondChildNode,  ///
+          textMarkdownNodeContent = textMarkdownNode.getContent(),
+          identifier = textMarkdownNodeContent; ///
+
+    return identifier;
+  }
+
+  getHRef() {
+    const identifier = this.getIdentifier(),
+          href = `#${identifier}`;
+
+    return href;
+  }
+
+  clear() {
+    const innerHTML = EMPTY_STRING;
+
+    this.setInnerHTML(innerHTML);
+  }
+
+  setNumber(number) {
+    const innerHTML = `${number}`;
+
+    this.setInnerHTML(innerHTML);
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(LinkMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/orderedList.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+import { START_ATTRIBUTE_NAME } from "../../attributeNames";
+
+const { first } = arrayUtilities;
+
+export default class OrderedListMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          start = this.getStart(),
+          name = START_ATTRIBUTE_NAME,  ///
+          value = start; ///
+
+    this.setAttribute(name, value);
+
+    return domElement;
+  }
+
+  getStart() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          firstOrderedListItemMarkdownNode = firstChildNode,  ///
+          start = firstOrderedListItemMarkdownNode.getStart();
+
+    return start;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(OrderedListMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/orderedListItem.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class OrderedListItemMarkdownNode extends MarkdownNode {
+  getStart() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          markerTerminalNode = firstChildNode,  ///
+          markerTerminalNodeContent = markerTerminalNode.getContent(),
+          start = markerTerminalNodeContent;  ///
+
+    return start;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(OrderedListItemMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/paragraph.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class ParagraphMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(ParagraphMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/primaryHeading.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class PrimaryHeadingMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(PrimaryHeadingMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/quaternaryHeading.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class QuaternaryHeadingMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(QuaternaryHeadingMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/reference.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { second } = arrayUtilities;
+
+export default class ReferenceMarkdownNode extends MarkdownNode {
+  getIdentifier() {
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          textMarkdownNode = secondChildNode,  ///
+          textMarkdownNodeContent = textMarkdownNode.getContent(),
+          identifier = textMarkdownNodeContent; ///
+
+    return identifier;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(ReferenceMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/secondaryHeading.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class SecondaryHeadingMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(SecondaryHeadingMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/strongText.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import contentMixins from "../../mixins/content";
+
+import MarkdownNode from "../markdown";
+
+class StrongTextMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(StrongTextMarkdownNode, ruleName, childNodes, ambiguous); }
+}
+
+Object.assign(StrongTextMarkdownNode.prototype, contentMixins);
+
+export default StrongTextMarkdownNode;

package/src/node/markdown/stronglyEmphasisedText.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import contentMixins from "../../mixins/content";
+
+import MarkdownNode from "../markdown";
+import ruleNameToHTMLMap from "../../ruleNameToHTMLMap";
+
+import { STRONG_TEXT_RULE_NAME } from "../../ruleNames";
+
+const strongTextHTML = ruleNameToHTMLMap[STRONG_TEXT_RULE_NAME],
+      { tagName: strongTextTagName } = strongTextHTML;
+
+class StronglyEmphasisedTextMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    let domElement = super.createDOMElement(context);
+
+    const childDOMElement = domElement, ///
+          tagName = strongTextTagName; ///
+
+    domElement = document.createElement(tagName);
+
+    this.setDOMElement(domElement);
+
+    const parentDOMElement = domElement,  ///
+          siblingDOMElement = null;
+
+    domElement = childDOMElement; ///
+
+    parentDOMElement.insertBefore(domElement, siblingDOMElement);
+
+    return domElement;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(StronglyEmphasisedTextMarkdownNode, ruleName, childNodes, ambiguous); }
+}
+
+Object.assign(StronglyEmphasisedTextMarkdownNode.prototype, contentMixins);
+
+export default StronglyEmphasisedTextMarkdownNode;

package/src/node/markdown/table.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TableMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableBody.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TableBodyMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableBodyMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableBodyCell.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class TableBodyCellMarkdownNode extends MarkdownNode {
+  createChildNodeDOMElements(context) {
+    const domElement = this.getDOMElement(),
+          childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          tableCellMarkdownNode = firstChildNode; ///
+
+    tableCellMarkdownNode.createChildNodeDOMElements(domElement, context);
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableBodyCellMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableBodyRow.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TableBodyRowMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableBodyRowMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableCell.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+import TextMarkdownNode from "./text";
+
+import { PERIOD } from "../../constants";
+import { domElementsFromChildNodes } from "../../utilities/childNodes";
+
+const { first } = arrayUtilities;
+
+export default class TableCellMarkdownNode extends MarkdownNode {
+  createChildNodeDOMElements(domElement, context) {
+    const childNodes = this.getChildNodes(),
+          childNodesLength = childNodes.length;
+
+    if (childNodesLength === 2) {
+      const firstChildNode = first(childNodes),
+            firstChildNodeTextMarkdownNode = (firstChildNode instanceof TextMarkdownNode);
+
+      if (firstChildNodeTextMarkdownNode) {
+        const textMarkdownNode = firstChildNode,  ///
+              content = textMarkdownNode.getContent();
+
+        if (content === PERIOD) {
+          return;
+        }
+      }
+    }
+
+    const domElements = domElementsFromChildNodes(childNodes, context),
+          parentDOMElement = domElement,  ///
+          siblingDOMElement = null;
+
+    domElements.forEach((domElement) => {
+      parentDOMElement.insertBefore(domElement, siblingDOMElement);
+    });
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableCellMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableHead.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TableHeadMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableHeadMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableHeadCell.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class TableHeadCellMarkdownNode extends MarkdownNode {
+  createChildNodeDOMElements(context) {
+    const domElement = this.getDOMElement(),
+          childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          tableCellMarkdownNode = firstChildNode; ///
+
+    tableCellMarkdownNode.createChildNodeDOMElements(domElement, context);
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableHeadCellMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableHeadRow.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TableHeadRowMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableHeadRowMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tableSeparator.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TableSeparatorMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TableSeparatorMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/tertiaryHeading.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class TertiaryHeadingMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TertiaryHeadingMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/text.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class TextMarkdownNode extends MarkdownNode {
+  getContent() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          terminalNode = firstChildNode,  ///
+          content = terminalNode.getContent();
+
+    return content;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(TextMarkdownNode, ruleName, childNodes, ambiguous); }
+}