highmark-markdown 0.0.1

package/src/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+export { default as nodeMap } from "./nodeMap";
+export { default as ruleNames } from "./ruleNames";
+export { default as tokenTypes } from "./tokenTypes";
+export { default as MarkdownNode } from "./node/markdown";
+export { default as nodeUtilities } from "./utilities/node";
+export { default as MarkdownLexer } from "./markdown/lexer";
+export { default as linkUtilities } from "./utilities/link";
+export { default as MarkdownParser } from "./markdown/parser";
+export { default as queryUtilities } from "./utilities/query";
+export { default as ruleNameToHTMLMap } from "./ruleNameToHTMLMap";
+export { default as FootnotesListMarkdownNode } from "./node/markdown/footnotesList";

package/src/markdown/bnf.js

@@ -0,0 +1,143 @@
+"use strict";
+
+const bnf = `
+
+    document                ::=  ( blockListing | orderedList | unorderedList | table | footnote | primaryHeading | secondaryHeading | tertiaryHeading | quaternaryHeading | lineBreak | paragraph | verticalSpace | error )+ ;
+
+    
+    blockListing            ::=  blockListingStart blockText blockListingEnd ;
+
+
+    orderedList             ::=  orderedListItem+ ;
+
+
+    unorderedList           ::=  unorderedListItem+ ;
+
+
+    footnotesList           ::=  footnoteItem+ ;
+
+
+    table                   ::=  tableHead tableSeparator tableBody ;
+
+
+    footnote                ::=  reference paragraph ;
+
+
+    primaryHeading          ::=  [single-hash] line ;
+
+
+    secondaryHeading        ::=  [double-hash] line ;
+
+
+    tertiaryHeading         ::=  [triple-hash] line ;
+    
+    
+    quaternaryHeading       ::=  [quadruple-hash] line ;
+
+
+    lineBreak!              ::=  [dashes] endOfLine ;
+
+
+    paragraph               ::=  line+ ;
+    
+
+    verticalSpace!          ::=  endOfLine+ ;
+
+
+    error!                  ::=  . ;
+
+
+    blockListingStart       ::=  [backticks] className? endOfLine ;
+
+
+    blockListingEnd         ::=  [backticks] endOfLine ;
+
+
+    footnoteItem            ::=  anchor paragraph ;
+    
+    
+    orderedListItem         ::=  [number]<NO_WHITESPACE>"." line ;
+    
+    
+    unorderedListItem       ::=  [single-asterisk] line ;
+
+
+    tableHead               ::=  tableHeadRow ;
+
+    
+    tableBody               ::=  tableBodyRow+ ;
+
+    
+    tableSeparator!         ::=  [many-dashes] endOfLine ;
+
+    
+    tableHeadRow            ::=  [vertical-bar] tableHeadCell+ endOfLine ;
+
+    
+    tableBodyRow            ::=  [vertical-bar] tableBodyCell+ endOfLine ;
+
+
+    tableHeadCell!          ::=  tableCell ;
+
+
+    tableBodyCell!          ::=  tableCell ; 
+
+
+    tableCell               ::=  ( link | hyperlink | inlineListing | stronglyEmphasisedText | emphasisedText | strongText | text )+ [vertical-bar] ;
+
+
+    line!                   ::=  ( link | image | hyperlink | inlineListing | stronglyEmphasisedText | emphasisedText | strongText | text )+ endOfLine ;
+
+
+    link!                   ::=  [open-square-bracket-caret] [identifier] [close-square-bracket] ;
+    
+
+    image                   ::=  [exclamation-mark-open-square-bracket] inlineText... [close-square-bracket]<NO_WHITESPACE>"(" url ")" ;
+
+
+    hyperlink               ::=  [open-square-bracket] inlineText... [close-square-bracket]<NO_WHITESPACE>"(" url ")" ;
+
+
+    reference!              ::=  [open-square-bracket-caret] [identifier] [close-square-bracket-colon] ;
+    
+
+    inlineListing           ::=  [backtick] inlineText... [backtick] ;
+    
+
+    stronglyEmphasisedText  ::=  [triple-asterisk] inlineText... [triple-asterisk] ;
+    
+
+    emphasisedText          ::=  [single-asterisk] inlineText... [single-asterisk] ;
+
+
+    strongText              ::=  [double-asterisk] inlineText... [double-asterisk] ;
+
+
+    blockText!              ::=  ( text | endOfLine )+ ;
+    
+
+    inlineText              ::=  text+ ;
+    
+    
+    anchor                  ::=  [number] ;
+    
+
+    text                    ::=  [escaped] | [number] | [path] | [domain] | [protocol] | [identifier] | [word] | [special] | [unassigned] ;
+    
+
+    url                     ::=  ( [protocol] [domain] )? [path] 
+    
+                              |  [protocol] [domain]
+                              
+                              ;
+    
+
+    className               ::=  <NO_WHITESPACE>[identifier] ;
+
+
+    endOfLine               ::=  <END_OF_LINE> ;
+
+`;
+
+export default bnf;
+

package/src/markdown/entries.js

@@ -0,0 +1,84 @@
+"use strict";
+
+const entries = [
+  {
+    "escaped": "^\\\\[^\\s]"
+  },
+  {
+    "exclamation-mark-open-square-bracket": "^!\\["
+  },
+  {
+    "close-square-bracket-colon": "^\\]:"
+  },
+  {
+    "open-square-bracket-caret": "^\\[\\^"
+  },
+  {
+    "close-square-bracket": "^\\]"
+  },
+  {
+    "open-square-bracket": "^\\["
+  },
+  {
+    "triple-asterisk": "^\\*\\*\\*"
+  },
+  {
+    "double-asterisk": "^\\*\\*"
+  },
+  {
+    "single-asterisk": "^\\*"
+  },
+  {
+    "quadruple-hash": "^####"
+  },
+  {
+    "triple-hash": "^###"
+  },
+  {
+    "double-hash": "^##"
+  },
+  {
+    "single-hash": "^#"
+  },
+  {
+    "vertical-bar": "^\\|"
+  },
+  {
+    "many-dashes": "^-{4,}"
+  },
+  {
+    "dashes": "^-{2,3}"
+  },
+  {
+    "backticks": "^```"
+  },
+  {
+    "backtick": "^`"
+  },
+  {
+    "number": "^[1-9][0-9]*"
+  },
+  {
+    "path": "^\\/(?:[a-z]+\\/)*(?:[a-z\\-]+(?:\\.[a-z]+)?)?"
+  },
+  {
+    "domain": "^[a-z\\-]+(?:\\.[a-z\\-]+)+"
+  },
+  {
+    "protocol": "^[a-z]+:\\/\\/"
+  },
+  {
+    "identifier": "^[a-z]+(?:-[a-z]+)*"
+  },
+  {
+    "word": "^\\w+"
+  },
+  {
+    "special": "^\\.\\.\\.|\\.|\\?|\\(|\\)|\\^|\\/|-|@|,|!|;|:|`|'|\""
+  },
+  {
+    "unassigned": "^[^\\s]+"
+  }
+];
+
+export default entries;

package/src/markdown/lexer.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import { CommonLexer } from "occam-lexers";
+import { WhitespaceToken, EndOfLineSignificantToken } from "occam-lexers";
+
+import entries from "./entries";
+
+export default class MarkdownLexer extends CommonLexer {
+  static entries = entries;
+
+  static EndOfLineToken = EndOfLineSignificantToken;
+
+  static WhitespaceToken = WhitespaceToken;
+
+  static EndOfLineCommentToken = null;
+
+  static SingleLineCommentToken = null;
+
+  static RegularExpressionToken = null;
+
+  static EndOfMultiLineCommentToken = null;
+
+  static StartOfMultiLineCommentToken = null;
+
+  static MiddleOfMultiLineCommentToken = null;
+
+  static SinglyQuotedStringLiteralToken = null;
+
+  static DoublyQuotedStringLiteralToken = null;
+
+  static fromNothing() { return CommonLexer.fromNothing(MarkdownLexer); }
+
+  static fromRules(rules) { return CommonLexer.fromRules(MarkdownLexer, rules); }
+
+  static fromEntries(entries) { return CommonLexer.fromEntries(MarkdownLexer, entries); }
+}

package/src/markdown/parser.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import { CommonParser } from "occam-parsers";
+
+import bnf from "./bnf";
+import nodeMap from "../nodeMap";
+
+import { setNonTerminalNodes } from "../utilities/node";
+
+export default class MarkdownParser extends CommonParser {
+  static bnf = bnf;
+
+  static fromNothing() {
+    const markdownParser = CommonParser.fromNothing(MarkdownParser);
+
+    setNonTerminalNodes(markdownParser, nodeMap);
+
+    return markdownParser;
+  }
+
+  static fromBNF(bnf) {
+    const markdownParser = CommonParser.fromBNF(MarkdownParser, bnf);
+
+    setNonTerminalNodes(markdownParser, nodeMap);
+
+    return markdownParser;
+  }
+
+  static fromRules(rules) {
+    const markdownParser = CommonParser.fromRules(MarkdownParser, rules);
+
+    setNonTerminalNodes(markdownParser, nodeMap);
+
+    return markdownParser;
+  }
+}

package/src/mixins/content.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { contentFromMarkdownNodes } from "../utilities/content";
+
+function getContent(context) {
+  const markdownNode = this, ///
+        markdownNodes = [
+          markdownNode
+        ],
+        content = contentFromMarkdownNodes(markdownNodes, context);
+
+  return content;
+}
+
+const contentMixins = {
+  getContent
+};
+
+export default contentMixins;

package/src/mixins/element.js

@@ -0,0 +1,47 @@
+"use strict";
+
+function addDOMElement(parentDOMElement, siblingDOMElement = null) {
+  if ((parentDOMElement !== null ) && (this.domElement !== null)) {
+    parentDOMElement.insertBefore(this.domElement, siblingDOMElement);
+  }
+}
+
+function removeDOMElement(parentDOMElement) {
+  if ((parentDOMElement !== null ) && (this.domElement !== null)) {
+    parentDOMElement.removeChild(this.domElement);
+
+    this.domElement = null;
+  }
+}
+
+function getDescendantElements(descendantElements = []) {
+  const domElement = this.getDOMElement();
+
+  if (domElement !== null) {
+    const descendantElement = this; ///
+
+    descendantElements.push(descendantElement);
+
+    const childNodes = this.getChildNodes();
+
+    childNodes.forEach((childNode) => {
+      const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+      if (childNodeNonTerminalNode) {
+        const nonTerminalNode = childNode;  ///
+
+        nonTerminalNode.getDescendantElements(descendantElements);
+      }
+    });
+  }
+
+  return descendantElements;
+}
+
+const elementMixins = {
+  addDOMElement,
+  removeDOMElement,
+  getDescendantElements
+};
+
+export default elementMixins;

package/src/mixins/node.js

@@ -0,0 +1,27 @@
+"use strict";
+
+function getDescendantNodes(descendantNodes = []) {
+  const descendantNode = this; ///
+
+  descendantNodes.push(descendantNode);
+
+  const childNodes = this.getChildNodes();
+
+  childNodes.forEach((childNode) => {
+    const childNodeNonTerminalNode = childNode.isNonTerminalNode();
+
+    if (childNodeNonTerminalNode) {
+      const nonTerminalNode = childNode;  ///
+
+      nonTerminalNode.getDescendantNodes(descendantNodes);
+    }
+  });
+
+  return descendantNodes;
+}
+
+const nodeMixins = {
+  getDescendantNodes
+};
+
+export default nodeMixins;

package/src/node/markdown/anchor.js

@@ -0,0 +1,37 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+import { ID_ATTRIBUTE_NAME } from "../../attributeNames";
+import { ANCHOR_RULE_NAME } from "../../ruleNames";
+
+export default class AnchorMarkdownNode extends MarkdownNode {
+  constructor(ruleName, childNodes, ambiguous, precedence, domElement, identifier) {
+    super(ruleName, childNodes, ambiguous, precedence, domElement);
+
+    this.identifier = identifier;
+  }
+
+  getIdentifier() {
+    return this.identifier;
+  }
+
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          name = ID_ATTRIBUTE_NAME,
+          value = this.identifier;
+
+    this.setAttribute(name, value);
+
+    return domElement;
+  }
+
+  static fromIdentifier(identifier) {
+    const ruleName = ANCHOR_RULE_NAME,
+          childNodes = [],
+          ambiguous = false,
+          anchorMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndAmbiguous(AnchorMarkdownNode, ruleName, childNodes, ambiguous, identifier);
+
+    return anchorMarkdownNode;
+  }
+}

package/src/node/markdown/blockListing.js

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

package/src/node/markdown/blockListingEnd.js

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

package/src/node/markdown/blockListingStart.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+import ClassNameMarkdownNode from "./className";
+
+const { second } = arrayUtilities;
+
+export default class BlockListingStartMarkdownNode extends MarkdownNode {
+  getClassName() {
+    let className = null;
+
+    const childNodes = this.getChildNodes(),
+          secondChildNode = second(childNodes),
+          secondChildNodeClassNameMarkdownNode = (secondChildNode instanceof ClassNameMarkdownNode)
+
+    if (secondChildNodeClassNameMarkdownNode) {
+      const classNameMarkdownNode = secondChildNode; ///
+
+      className = classNameMarkdownNode.getClassName();
+    }
+
+    return className;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(BlockListingStartMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/blockText.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import contentMixins from "../../mixins/content";
+
+import MarkdownNode from "../markdown";
+
+class BlockTextMarkdownNode 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(BlockTextMarkdownNode, ruleName, childNodes, ambiguous); }
+}
+
+Object.assign(BlockTextMarkdownNode.prototype, contentMixins);
+
+export default BlockTextMarkdownNode;

package/src/node/markdown/className.js

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

package/src/node/markdown/document.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
+
+import { renumberLinkMarkdownNodes } from "../../utilities/link";
+
+export default class DocumentMarkdownNode extends MarkdownNode {
+  createChildNodeDOMElements(context) {
+    const documentMarkdownNode = this,  ///
+          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDocumentMarkdownNode(documentMarkdownNode);
+
+    super.createChildNodeDOMElements(context);
+
+    if (footnotesListMarkdownNode !== null) {
+      const domElement = footnotesListMarkdownNode.createDOMElement(context);
+
+      this.insertDOMElement(domElement);
+
+      renumberLinkMarkdownNodes(documentMarkdownNode, footnotesListMarkdownNode);
+    }
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(DocumentMarkdownNode, ruleName, childNodes, ambiguous); }
+}
+

package/src/node/markdown/emphasisedText.js

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

package/src/node/markdown/endOfLine.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class EndOfLineMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const content = this.getContent(context),
+          domElement = document.createTextNode(content);
+
+    this.setDOMElement(domElement);
+
+    return domElement;
+  }
+
+  getContent() {
+    const firstSignificantToken = this.getFirstSignificantToken(),
+          endOfLineToken = firstSignificantToken, ///
+          content = endOfLineToken.getContent();
+
+    return content;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(EndOfLineMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/error.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class ErrorMarkdownNode extends MarkdownNode {
+  createDOMElement(context) {
+    const domElement = super.createDOMElement(context),
+          content = this.getContent(context),
+          textContent = content;  ///
+
+    Object.assign(domElement, {
+      textContent
+    });
+
+    return domElement;
+  }
+
+  createChildNodeDOMElements(context) {
+    ///
+  }
+
+  getContent() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          terminalNode = firstChildNode,  ///
+          content = terminalNode.getContent();
+
+    return content;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(ErrorMarkdownNode, ruleName, childNodes, ambiguous); }
+}

package/src/node/markdown/footnote.js

@@ -0,0 +1,21 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+const { first } = arrayUtilities;
+
+export default class FootnoteMarkdownNode extends MarkdownNode {
+  getIdentifier() {
+    const childNodes = this.getChildNodes(),
+          firstChildNode = first(childNodes),
+          referenceMarkdownNode = firstChildNode,  ///
+          referenceMarkdownNodeIdentifier = referenceMarkdownNode.getIdentifier(),
+          identifier = referenceMarkdownNodeIdentifier;  ///
+
+    return identifier;
+  }
+
+  static fromRuleNameChildNodesAndAmbiguous(ruleName, childNodes, ambiguous) { return MarkdownNode.fromRuleNameChildNodesAndAmbiguous(FootnoteMarkdownNode, ruleName, childNodes, ambiguous); }
+}