highmark-markdown 1.0.173 → 1.0.174

package/src/node/markdown/image.js

@@ -2,27 +2,12 @@
 
 import MarkdownNode from "../../node/markdown";
 
-import { ALT_ATTRIBUTE_NAME, SRC_ATTRIBUTE_NAME} from "../../attributeNames";
-
 export default class ImageMarkdownNode extends MarkdownNode {
-  alt(context) {
-    const alt = this.fromSecondChildNode((secondChildNode) => {
-      const inlineTextMarkdownNode = secondChildNode,  ///
-            inlineTextMarkdownNodeContent = inlineTextMarkdownNode.content(context),
-            alt = inlineTextMarkdownNodeContent; ///
-
-      return alt;
-    });
-
-    return alt;
-  }
-
   src(context) {
     const { pathToURL = null } = context,
           src = this.fromSecondLastChildNode((secondLastChildNode) => {
             const pathMarkdownNode = secondLastChildNode,  ///
-                  pathMarkdownNodeContent = pathMarkdownNode.getContent(),
-                  path = pathMarkdownNodeContent, ///
+                  path = pathMarkdownNode.path(context), ///
                   src = (pathToURL === null) ?
                            path :  ///
                              pathToURL(path);
@@ -33,71 +18,5 @@ export default class ImageMarkdownNode extends MarkdownNode {
     return src;
   }
 
-  asHTML(indent, context) {
-    indent = this.adjustIndent(indent);
-
-    const selfClosingTag = this.selfClosingTag(context),
-          html = (indent === null) ?
-                   selfClosingTag :  ///
-                     `${indent}${selfClosingTag}
-`;
-
-    return html;
-  }
-
-  createDOMElement(context) {
-    const tagName = this.tagName(context),
-          domElement = document.createElement(tagName),
-          attributeNames = this.attributeNames(context),
-          attributeValues = this.attributeValues(context);
-
-    attributeNames.forEach((attributeName, index) => {
-      const attributeValue = attributeValues[index];
-
-      domElement.setAttribute(attributeName, attributeValue);
-    });
-
-    return domElement;
-  }
-
-  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;
-  }
-
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(ImageMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/indexLink.js

@@ -2,76 +2,17 @@
 
 import MarkdownNode from "../../node/markdown";
 
-import { INDEX_PREPEND } from "../../prepends";
-import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
-
 export default class IndexLinkMarkdownNode extends MarkdownNode {
-  attributeName(context) {
-    const attributeName = HREF_ATTRIBUTE_NAME;
-
-    return attributeName;
-  }
-
-  attributeValue(context) {
-    const content = this.content(context),
-          attributeValue = `#${INDEX_PREPEND}-${content}`;
-
-    return attributeValue;
-  }
-
-  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) {
-    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;
-  }
-
-  createChildNodeDOMElements(context) {
-    const content = this.content(context),
-          textNode  = document.createTextNode(content),
-          domElement = textNode; ///
-
-    this.addDOMElement(domElement);
-  }
-
-  content(context) {
-    const content = this.fromFirstChildNode((firstChildNode) => {
-      const terminalNode = firstChildNode,  ///
-            content = terminalNode.getContent();
-
-      return content;
-    });
-
-    return content;
-  }
+  // content(context) {
+  //   const content = this.fromFirstChildNode((firstChildNode) => {
+  //     const terminalNode = firstChildNode,  ///
+  //           content = terminalNode.getContent();
+  //
+  //     return content;
+  //   });
+  //
+  //   return content;
+  // }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexLinkMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/indexList.js

@@ -5,12 +5,6 @@ import MarkdownNode from "../../node/markdown";
 import { INDEX_LIST_RULE_NAME } from "../../ruleNames";
 
 export default class IndexListMarkdownNode extends MarkdownNode {
-  asPlainText(context) {
-    const plainText = null;
-
-    return plainText;
-  }
-
   static fromIndexItemReplacements(indexItemReplacements) {
     const ruleName = INDEX_LIST_RULE_NAME,
           childNodes = indexItemReplacements.map((indexItemReplacement) => {

package/src/node/markdown/inlineListing.js

@@ -1,48 +1,28 @@
 "use strict";
 
 import MarkdownNode from "../../node/markdown";
-import contentMixins from "../../mixins/content";
 
-import { replaceEntities } from "../../utilities/html";
 import { removeBackticks } from "../../utilities/string";
-
-class InlineListingMarkdownNode extends MarkdownNode {
-  createDOMElement(context) {
-    let domElement,
-        content = this.content(context);
-
-    content = removeBackticks(content); ///
-
-    content = replaceEntities(content); ///
-
-    const textNode = document.createTextNode(content);
-
-    domElement = super.createDOMElement(context);
-
-    const parentDOMElement = domElement;  ///
-
-    domElement = textNode; ///
-
-    parentDOMElement.appendChild(domElement);
-
-    domElement = parentDOMElement;  ///
-
-    return domElement;
-  }
-
-  childNodesAsHTML(indent, context) {
-    let content = this.content(context);
-
-    content = removeBackticks(content); ///
-
-    const childNodesHTML = content; ///
-
-    return childNodesHTML;
-  }
+import { replaceEntities } from "../../utilities/entities";
+
+export default class InlineListingMarkdownNode extends MarkdownNode {
+  // content(context) {
+  //   const content = this.fromFirstChildNode((firstChildNode) => {
+  //     let content;
+  //
+  //     const backtickedLiteralTerminalNode = firstChildNode; ///
+  //
+  //     content = backtickedLiteralTerminalNode.getContent();
+  //
+  //     content = removeBackticks(content); ///
+  //
+  //     content = replaceEntities(content); ///
+  //
+  //     return content;
+  //   });
+  //
+  //   return content;
+  // }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(InlineListingMarkdownNode, ruleName, childNodes, opacity); }
 }
-
-Object.assign(InlineListingMarkdownNode.prototype, contentMixins);
-
-export default InlineListingMarkdownNode;

package/src/node/markdown/inlineText.js

@@ -1,27 +1,7 @@
 "use strict";
 
 import MarkdownNode from "../../node/markdown";
-import contentMixins from "../../mixins/content";
-
-class InlineTextMarkdownNode extends MarkdownNode {
-  asHTML(indent, context) {
-    const content = this.content(context),
-          html = content; ///
-
-    return html;
-  }
-
-  createDOMElement(context) {
-    const content = this.content(context),
-          textNode = document.createTextNode(content),
-          domElement = textNode;  ///
-
-    return domElement;
-  }
 
+export default class InlineTextMarkdownNode extends MarkdownNode {
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(InlineTextMarkdownNode, ruleName, childNodes, opacity); }
 }
-
-Object.assign(InlineTextMarkdownNode.prototype, contentMixins);
-
-export default InlineTextMarkdownNode;

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

@@ -2,11 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
-import ItemNode from "../../../node/markdown/item";
+import MarkdownNode from "../../../node/markdown";
 
 const { second } = arrayUtilities;
 
-export default class OrderedItemMarkdownNode extends ItemNode {
+export default class OrderedItemMarkdownNode extends MarkdownNode {
   value(context) {
     const value = this.fromFirstChildNode((firstChildNode) => {
       const markerTerminalNode = firstChildNode,  ///
@@ -18,7 +18,7 @@ export default class OrderedItemMarkdownNode extends ItemNode {
     return value;
   }
 
-  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return ItemNode.fromRuleNameChildNodesAndOpacity(OrderedItemMarkdownNode, ruleName, childNodes, opacity); }
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(OrderedItemMarkdownNode, ruleName, childNodes, opacity); }
 }
 
 function valueFromMarkerTerminalNode(markerTerminalNode) {

package/src/node/markdown/line.js

@@ -2,8 +2,6 @@
 
 import MarkdownNode from "../../node/markdown";
 
-import { htmlFromMarkdownNode, plainTextFromMarkdownNode, domElementsFromMarkdownNode } from "../../utilities/childNodes";
-
 export default class LineMarkdownNode extends MarkdownNode {
   lines(context) {
     const { charactersPerLine } = context,
@@ -15,64 +13,5 @@ export default class LineMarkdownNode extends MarkdownNode {
     return lines;
   }
 
-  mount(parentDOMElement, siblingDOMElement, context) {
-    this.domElement = this.createDOMElement(context);
-
-    parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
-  }
-
-  unmount(parentDOMElement, context) {
-    if (this.domElement !== null) {
-      parentDOMElement.removeChild(this.domElement);
-
-      this.domElement = null;
-    }
-  }
-
-  createDOMElement(context) {
-    const markdownNode = this,
-          domElement = super.createDOMElement(context),
-          domElements = domElementsFromMarkdownNode(markdownNode, context),
-          parentDOMElement = domElement,  ///
-          childNodeDOMElements = domElements; ///
-
-    childNodeDOMElements.forEach((childNodeDOMElement) => {
-      const domElement = childNodeDOMElement; ///
-
-      parentDOMElement.appendChild(domElement);
-    });
-
-    return domElement;
-  }
-
-  asHTML(indent, context) {
-    indent = this.adjustIndent(indent);
-
-    const childNodesHTML = this.childNodesAsHTML(indent, context),
-          startingTag = this.startingTag(context),
-          closingTag = this.closingTag(context),
-          html = (indent !== null) ?
-                   `${indent}${startingTag}${childNodesHTML}${closingTag}
-`:                   `${startingTag}${childNodesHTML}${closingTag}`;
-
-    return html;
-  }
-
-  childNodesAsHTML(indent, context) {
-    const markdownNode = this,
-          html = htmlFromMarkdownNode(markdownNode, context),
-          childNodesHTML = html;  ///
-
-    return childNodesHTML;
-  }
-
-  childNodesAsPlainText(context) {
-    const markdownNode = this, ///
-          plainText = plainTextFromMarkdownNode(markdownNode, context),
-          childNodesPlainText = plainText;  ///
-
-    return childNodesPlainText;
-  }
-
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(LineMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/path.js

@@ -3,16 +3,16 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class PathMarkdownNode extends MarkdownNode {
-  getContent() {
-    const content = this.fromFirstChildNode((firstChildNode) => {
+  path(context) {
+    const path = this.fromFirstChildNode((firstChildNode) => {
       const pathTerminalNode = firstChildNode,  ///
             pathTerminalNodeContent = pathTerminalNode.getContent(),
-            content = pathTerminalNodeContent;  ///
+            path = pathTerminalNodeContent;  ///
 
-      return content;
+      return path;
     });
 
-    return content;
+    return path;
   }
 
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(PathMarkdownNode, ruleName, childNodes, opacity); }

package/src/node/markdown/strongText.js

@@ -1,46 +1,7 @@
 "use strict";
 
 import MarkdownNode from "../../node/markdown";
-import contentMixins from "../../mixins/content";
-
-class StrongTextMarkdownNode extends MarkdownNode {
-  inlineText(context) {
-    const inlineText = this.fromSecondChildNode((secondChildNode) => {
-      const indent = null,
-            inlineTextMarkdownNode = secondChildNode, ///
-            inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
-            inlineText = inlineTextMarkdownNodeHTML;  ///
-
-      return inlineText;
-    });
-
-    return inlineText;
-  }
-
-  createDOMElement(context) {
-    const inlineText = this.inlineText(context),
-      content = inlineText; ///
-
-    let domElement;
-
-    const textNode = document.createTextNode(content);
-
-    domElement = super.createDOMElement(context);
-
-    const parentDOMElement = domElement;  ///
-
-    domElement = textNode; ///
-
-    parentDOMElement.appendChild(domElement);
-
-    domElement = parentDOMElement;  ///
-
-    return domElement;
-  }
 
+export default class StrongTextMarkdownNode extends MarkdownNode {
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(StrongTextMarkdownNode, ruleName, childNodes, opacity); }
 }
-
-Object.assign(StrongTextMarkdownNode.prototype, contentMixins);
-
-export default StrongTextMarkdownNode;

package/src/node/markdown/stronglyEmphasisedText.js

@@ -1,80 +1,7 @@
 "use strict";
 
-import elementMap from "../../elementMap";
 import MarkdownNode from "../../node/markdown";
-import contentMixins from "../../mixins/content";
-
-import { STRONG_TEXT_RULE_NAME } from "../../ruleNames";
-
-const { tagName } = elementMap[STRONG_TEXT_RULE_NAME];
-
-class StronglyEmphasisedTextMarkdownNode extends MarkdownNode {
-  inlineText(context) {
-    const inlineText = this.fromSecondChildNode((secondChildNode) => {
-      const indent = null,
-            inlineTextMarkdownNode = secondChildNode, ///
-            inlineTextMarkdownNodeHTML = inlineTextMarkdownNode.asHTML(indent, context),
-            inlineText = inlineTextMarkdownNodeHTML;  ///
-
-      return inlineText;
-    });
-
-    return inlineText;
-  }
-
-  createDOMElement(context) {
-    let domElement;
-
-    domElement = document.createElement(tagName);
-
-    const parentDOMElement = domElement,  ///
-          childDOMElement = this.createChildDOMElement(context);
-
-    domElement = childDOMElement; ///
-
-    parentDOMElement.appendChild(domElement);
-
-    domElement = parentDOMElement;  ///
-
-    return domElement;
-  }
-
-  createChildDOMElement(context) {
-    const inlineText = this.inlineText(context),
-          content = inlineText; ///
-
-    let domElement;
-
-    const 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 = super.asHTML(indent, context);
-
-    const childNodesHTML = html,  ///
-          startingTag = `<${tagName}>`,
-          closingTag = `</${tagName}>`;
-
-    html = `${startingTag}${childNodesHTML}${closingTag}`;
-
-    return html;
-  }
 
+export default class StronglyEmphasisedTextMarkdownNode extends MarkdownNode {
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(StronglyEmphasisedTextMarkdownNode, ruleName, childNodes, opacity); }
 }
-
-Object.assign(StronglyEmphasisedTextMarkdownNode.prototype, contentMixins);
-
-export default StronglyEmphasisedTextMarkdownNode;

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

@@ -0,0 +1,7 @@
+"use strict";
+
+import TextMarkdownNode from "../../../node/markdown/text";
+
+export default class BlockTextMarkdownNode extends TextMarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return TextMarkdownNode.fromRuleNameChildNodesAndOpacity(BlockTextMarkdownNode, ruleName, childNodes, opacity); }
+}

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

@@ -0,0 +1,7 @@
+"use strict";
+
+import TextMarkdownNode from "../../../node/markdown/text";
+
+export default class PlainTextMarkdownNode extends TextMarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return TextMarkdownNode.fromRuleNameChildNodesAndOpacity(PlainTextMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/text.js

@@ -0,0 +1,80 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import { EMPTY_STRING } from "../../constants";
+import { ESCAPED_TOKEN_TYPE } from "../../tokenTypes";
+
+export default class TextMarkdownNode extends MarkdownNode {
+  text(context) {
+    const { tokens } = context;
+
+    let { whitespaceTokenIndex } = context;
+
+    const text = this.fromFirstChildNode((firstChildNode) => {
+      let text = EMPTY_STRING;
+
+      const terminalNode = firstChildNode,  ///
+            significantToken = terminalNode.getSignificantToken(),
+            significantTokenIndex = tokens.indexOf(significantToken),
+            previousTokenIndex = significantTokenIndex - 1;
+
+      if (previousTokenIndex > -1) {
+        const previousToken = tokens[previousTokenIndex],
+              previousTokenWhitespaceToken = previousToken.isWhitespaceToken();
+
+        if (previousTokenWhitespaceToken) {
+          if (previousTokenIndex > whitespaceTokenIndex) {
+            const whitespaceToken = previousToken,  ///
+                  whitespaceTokenContent = whitespaceToken.getContent();
+
+            text = `${text}${whitespaceTokenContent}`;
+
+            whitespaceTokenIndex = previousTokenIndex;  ///
+          }
+        }
+      }
+
+      let significantTokenContent = significantToken.getContent();
+
+      const significantTokenType = significantToken.getType();
+
+      if (significantTokenType === ESCAPED_TOKEN_TYPE) {
+        const start = 1;
+
+        significantTokenContent = significantTokenContent.substring(start);
+      }
+
+      text = `${text}${significantTokenContent}`;
+
+      const tokensLength = tokens.length,
+            nextTokenIndex = significantTokenIndex + 1;
+
+      if (nextTokenIndex < tokensLength) {
+        const nextToken = tokens[nextTokenIndex],
+              nextTokenWhitespaceToken = nextToken.isWhitespaceToken();
+
+        if (nextTokenWhitespaceToken) {
+          if (nextTokenIndex > whitespaceTokenIndex) {
+            const whitespaceToken = nextToken,  ///
+                  whitespaceTokenContent = whitespaceToken.getContent();
+
+            text = `${text}${whitespaceTokenContent}`;
+
+            whitespaceTokenIndex = nextTokenIndex;  ///
+          }
+        }
+      }
+
+      return text;
+    });
+
+    Object.assign(context, {
+      whitespaceTokenIndex
+    });
+
+    return text;
+  }
+
+  static fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(Class, ruleName, childNodes, opacity); }
+}