highmark-markdown 0.0.206 → 0.0.210

package/src/markdownStyle/bnf.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const bnf = `
+
+    style          ::=  ( ruleSet | declaration | nonsense | error )+ ;
+
+    
+    ruleSet..      ::=  selectorsList "{" ( ruleSet | declaration | nonsense )* "}" ;
+    
+    
+    declaration    ::=  name ":" values ";" ;
+
+    
+    nonsense.      ::=  [string-literal] | [escaped] | [rule-name] | [number] | [colour] | [unit] | [name] | [special] | [unassigned] ;
+
+
+    error.         ::=  . ;
+
+
+    selectorsList  ::=  selectors ( "," selectors )* ;
+
+
+    selectors      ::=  selector+ ;
+
+
+    selector       ::=  [rule-name] class* pseudoClass* 
+    
+                     |  class+ pseudoClass*
+
+                     |  pseudoClass+
+
+                     ;
+
+    
+    values         ::=  value+ ;
+
+    
+    class          ::=  <NO_WHITESPACE>"."<NO_WHITESPACE>identifier ;
+
+    
+    pseudoClass    ::=  <NO_WHITESPACE>":"<NO_WHITESPACE>identifier ;
+    
+    
+    name.          ::=  identifier ;
+
+    
+    value.         ::=  identifier ( <NO_WHITESPACE>"(" arguments ")" )?
+    
+                     |  [number]<NO_WHITESPACE>[unit]
+    
+                     |  [string-literal] 
+                              
+                     |  [number]
+                              
+                     |  [colour]
+                              
+                     ;
+                     
+
+    arguments      ::=  argument ( "," argument )* ;
+    
+
+    argument       ::=  identifier
+    
+                     |  [number]<NO_WHITESPACE>[unit]
+    
+                     |  [string-literal] 
+                              
+                     |  [number]
+                              
+                     |  [colour]
+                     
+                     ;
+
+
+    identifier     ::=  ( [rule-name] | [name] ) ( <NO_WHITESPACE>"-"<NO_WHITESPACE>( [rule-name] | [name] ) )* ;
+
+    
+`;
+
+export default bnf;

package/src/markdownStyle/entries.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import elementMap from "../elementMap";
+
+import { ruleNamesExpressionFromElementMap } from "../utilities/entries";
+
+const ruleNamesExpression = ruleNamesExpressionFromElementMap(elementMap);
+
+const entries = [
+  {
+    "escaped": "^\\\\[^\\s]"
+  },
+  {
+    "rule-name": `^(?:${ruleNamesExpression})`
+  },
+  {
+    "number": "^(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?"
+  },
+  {
+    "colour": "^#(?:[0-9a-fA-F]{6}|[0-9a-fA-F]{3})"
+  },
+  {
+    "unit": "^(?:deg|%)"
+  },
+  {
+    "name": "^[_a-zA-Z0-9]+"
+  },
+  {
+    "bracket": "^(?:\\{|\\})"
+  },
+  {
+    "special": "^(?:,|:|;|-|\\.|\\(|\\)|\\[|\\])"
+  },
+  {
+    "unassigned": "^[^\\s]+"
+  }
+];
+
+export default entries;

package/src/markdownStyle/lexer.js

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

package/src/markdownStyle/parser.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { CommonParser } from "occam-parsers";
+
+import bnf from "./bnf";
+
+export default class MarkdownStyleParser extends CommonParser {
+  static bnf = bnf;
+
+  static fromNothing() { return CommonParser.fromNothing(MarkdownStyleParser); }
+
+  static fromBNF(bnf) { return CommonParser.fromBNF(MarkdownStyleParser, bnf); }
+
+  static fromRules(rules) { return CommonParser.fromRules(MarkdownStyleParser, rules); }
+}

package/src/node/markdown/division.js

@@ -9,7 +9,7 @@ import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
 import { nestNodes } from "../../utilities/contents";
 import { replaceTokens } from "../../utilities/tokens";
 import { renumberLinkMarkdownNodes } from "../../utilities/footnotes";
-import { contentsMarkdownNodeFromNode, headingMarkdownNodesFromNode } from "../../utilities/query";
+import { headingMarkdownNodesFromNode, contentsMarkdownNodeFromNode, footnotesMarkdownNodesFromNode } from "../../utilities/query";
 
 const { filter } = arrayUtilities;
 
@@ -113,18 +113,34 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   }
 
   createFootnotes(context) {
-    const footnotesListMarkdownNode = this.createFootnotesListMarkdownNode(context);
+    const node = this,  ///
+          footnotesMarkdownNodes = footnotesMarkdownNodesFromNode(node);
 
-    if (footnotesListMarkdownNode !== null) {
-      const childNode = footnotesListMarkdownNode,  ///
-            divisionMarkdownNode = this;  ///
+    footnotesMarkdownNodes.forEach((footnotesMarkdownNode) => {
+      let childNode,
+          parentNode;
 
-      this.addChildNode(childNode);
+      childNode = footnotesMarkdownNode;  ///
 
-      renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context)
-    }
+      parentNode = this.findParentNode(childNode);
 
-    return footnotesListMarkdownNode;
+      const subDivisionMarkdownNode = parentNode;  ///
+
+      childNode = subDivisionMarkdownNode;  ///
+
+      parentNode = this.findParentNode(childNode);
+
+      const divisionMarkdownNode = parentNode,  ///
+            footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context),
+            replacedChildNode = footnotesMarkdownNode,  ///
+            replacementChildNode = footnotesListMarkdownNode; ///
+
+      parentNode = subDivisionMarkdownNode; ///
+
+      parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+
+      renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context)
+    });
   }
 
   createFootnotesListMarkdownNode(context) {

package/src/node/markdown/footnotes.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class FootnotesMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    const html = null;
+
+    return html;
+  }
+
+  createDOMElement(context) {
+    const domElement = null;
+
+    return domElement;
+  }
+
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/nodeMap.js

@@ -13,6 +13,7 @@ import ImportsMarkdownNode from "./node/markdown/imports";
 import ContentsMarkdownNode from "./node/markdown/contents";
 import DivisionMarkdownNode from "./node/markdown/division";
 import FootnoteMarkdownNode from "./node/markdown/footnote";
+import FootnotesMarkdownNode from "./node/markdown/footnotes";
 import ReferenceMarkdownNode from "./node/markdown/reference";
 import ParagraphMarkdownNode from "./node/markdown/paragraph";
 import HyperlinkMarkdownNode from "./node/markdown/hyperlink";
@@ -63,8 +64,9 @@ import { LINK_RULE_NAME,
          IMPORT_RULE_NAME,
          IMPORTS_RULE_NAME,
          CONTENTS_RULE_NAME,
-         FOOTNOTE_RULE_NAME,
          DIVISION_RULE_NAME,
+         FOOTNOTE_RULE_NAME,
+         FOOTNOTES_RULE_NAME,
          REFERENCE_RULE_NAME,
          PARAGRAPH_RULE_NAME,
          HYPERLINK_RULE_NAME,
@@ -116,8 +118,9 @@ const nodeMap = {
   [IMPORT_RULE_NAME]: ImportMarkdownNode,
   [IMPORTS_RULE_NAME]: ImportsMarkdownNode,
   [CONTENTS_RULE_NAME]: ContentsMarkdownNode,
-  [FOOTNOTE_RULE_NAME]: FootnoteMarkdownNode,
   [DIVISION_RULE_NAME]: DivisionMarkdownNode,
+  [FOOTNOTE_RULE_NAME]: FootnoteMarkdownNode,
+  [FOOTNOTES_RULE_NAME]: FootnotesMarkdownNode,
   [REFERENCE_RULE_NAME]: ReferenceMarkdownNode,
   [PARAGRAPH_RULE_NAME]: ParagraphMarkdownNode,
   [HYPERLINK_RULE_NAME]: HyperlinkMarkdownNode,

package/src/ruleNames.js

@@ -11,8 +11,9 @@ export const BULLET_RULE_NAME = "bullet";
 export const IMPORT_RULE_NAME = "import";
 export const IMPORTS_RULE_NAME = "imports";
 export const CONTENTS_RULE_NAME = "contents";
-export const FOOTNOTE_RULE_NAME = "footnote";
 export const DIVISION_RULE_NAME = "division";
+export const FOOTNOTE_RULE_NAME = "footnote";
+export const FOOTNOTES_RULE_NAME = "footnotes";
 export const REFERENCE_RULE_NAME = "reference";
 export const PARAGRAPH_RULE_NAME = "paragraph";
 export const HYPERLINK_RULE_NAME = "hyperlink";
@@ -67,8 +68,9 @@ const ruleNames = {
   IMPORT_RULE_NAME,
   IMPORTS_RULE_NAME,
   CONTENTS_RULE_NAME,
-  FOOTNOTE_RULE_NAME,
   DIVISION_RULE_NAME,
+  FOOTNOTE_RULE_NAME,
+  FOOTNOTES_RULE_NAME,
   REFERENCE_RULE_NAME,
   PARAGRAPH_RULE_NAME,
   HYPERLINK_RULE_NAME,

package/src/style/declaration.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { COLOUR } from "../constants";
+import { nodeQuery } from "../utilities/query";
+import { contentFromNodeAndTokens } from "../utilities/content";
+
+const nameNonTerminalNodeQuery = nodeQuery("/*/name"),
+      valuesNonTerminalNodeQuery = nodeQuery("/*/values");
+
+export default class Declaration {
+  constructor(name, values) {
+    this.name = name;
+    this.values = values;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getValues() {
+    return this.values;
+  }
+
+  asCSS() {
+    const name = this.name.replace(/colour/g, COLOUR),
+          css = `  ${name}: ${this.values};`;
+
+    return css;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const nameNonTerminalNode = nameNonTerminalNodeQuery(node),
+          valuesNonTerminalNode = valuesNonTerminalNodeQuery(node),
+          nameNonTerminalNodeContent = contentFromNodeAndTokens(nameNonTerminalNode, tokens),
+          valuesNonTerminalNodesContent = contentFromNodeAndTokens(valuesNonTerminalNode, tokens),
+          name = nameNonTerminalNodeContent, ///
+          values = valuesNonTerminalNodesContent, ///
+          declaration = new Declaration(name, values);
+
+    return declaration;
+  }
+}

package/src/style/declarations.js

@@ -0,0 +1,64 @@
+"use strict";
+
+import Declaration from "./declaration";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const declarationNonTerminalNodesQuery = nodesQuery("/*/declaration");
+
+export default class Declarations {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  asCSS(selectorsList) {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength(),
+          selectorsListLength = selectorsList.getLength();
+
+    if ((length > 0) && (selectorsListLength > 0)) {
+      const declarationsCSS = this.array.reduce((declarationsCSS, declaration) => {
+              const declarationCSS = declaration.asCSS();
+
+              declarationsCSS = (declarationsCSS === null) ?
+                                  declarationCSS : ///
+                                    `${declarationsCSS}
+${declarationCSS}`;
+
+              return declarationsCSS;
+            }, null),
+            selectorsListCSS = selectorsList.asCSS();
+
+      css = `${selectorsListCSS} {
+${declarationsCSS}
+}
+`;
+    }
+
+    return css;
+  }
+
+  static fromNothing() {
+    const array = [],
+          declarations = new Declarations(array);
+
+    return declarations;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const declarationNonTerminalNodes = declarationNonTerminalNodesQuery(node),
+          array = declarationNonTerminalNodes.map((declarationNonTerminalNode) => {
+            const node = declarationNonTerminalNode, ///
+                  declaration = Declaration.fromNodeAndTokens(node, tokens);
+
+            return declaration;
+          }),
+          declarations = new Declarations(array);
+
+    return declarations;
+  }
+}

package/src/style/division.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import RuleSets from "./ruleSets";
+import Declarations from "./declarations";
+
+import { EMPTY_STRING } from "../constants";
+
+export default class Division {
+  constructor(ruleSets, declarations, selectorsList) {
+    this.ruleSets = ruleSets;
+    this.declarations = declarations;
+    this.selectorsList = selectorsList;
+  }
+
+  getRuleSets() {
+    return this.ruleSets;
+  }
+
+  getDeclarations() {
+    return this.declarations;
+  }
+
+  getSelectorsList() {
+    return this.selectorsList;
+  }
+
+  asCSS() {
+    const outermost = true,
+          ruleSetsCSS = this.ruleSets.asCSS(this.selectorsList, outermost),
+          declarationsCSS = this.declarations.asCSS(this.selectorsList, outermost),
+          css = (declarationsCSS === EMPTY_STRING) ?
+                  ruleSetsCSS : ///
+                    `${declarationsCSS}
+${ruleSetsCSS}`;
+
+    return css;
+  }
+
+  static fromNodeTokensAndSelectorsList(node, tokens, selectorsList) {
+    const ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
+          declarations = Declarations.fromNodeAndTokens(node, tokens),
+          division = new Division(ruleSets, declarations, selectorsList);
+
+    return division;
+  }
+}

package/src/style/ruleSet.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import Declarations from "./declarations";
+import SelectorsList from "./selectorsList";
+
+import { EMPTY_STRING } from "../constants";
+
+export default class RuleSet {
+  constructor(ruleSets, declarations, selectorsList) {
+    this.ruleSets = ruleSets;
+    this.declarations = declarations;
+    this.selectorsList = selectorsList;
+  }
+
+  getRuleSets() {
+    return this.ruleSets;
+  }
+
+  getDeclarations() {
+    return this.declarations;
+  }
+
+  getSelectorsList() {
+    return this.selectorsList;
+  }
+
+  asCSS(selectorsList, outermost = false) {
+    selectorsList = selectorsList.combine(this.selectorsList, outermost);  ///
+
+    const declarationsCSS = this.declarations.asCSS(selectorsList),
+          ruleSetsCSS = this.ruleSets.asCSS(selectorsList),
+          css = (declarationsCSS === EMPTY_STRING) ?
+                  ruleSetsCSS : ///
+                    `${declarationsCSS}
+${ruleSetsCSS}`;
+
+    return css;
+  }
+
+  static fromRuleSetsNodeAndTokens(RuleSets, node, tokens) {
+    const ruleSets = RuleSets.fromNodeAndTokens(node, tokens),
+          declarations = Declarations.fromNodeAndTokens(node, tokens),
+          selectorsList = SelectorsList.fromNodeAndTokens(node, tokens),
+          ruleSet = new RuleSet(ruleSets, declarations, selectorsList);
+
+    return ruleSet;
+  }
+}

package/src/style/ruleSets.js

@@ -0,0 +1,57 @@
+"use strict";
+
+import RuleSet from "./ruleSet";
+
+import { nodesQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+
+const ruleSetNonTerminalNodesQuery = nodesQuery("/*/ruleSet");
+
+export default class RuleSets {
+  constructor(array) {
+    this.array = array;
+  }
+
+  getLength() { return this.array.length; }
+
+  asCSS(selectorsList, outermost = false) {
+    let css = EMPTY_STRING;
+
+    const length = this.getLength(),
+          selectorsListLength = selectorsList.getLength();
+
+    if ((length > 0) && (selectorsListLength > 0)) {
+      css = this.array.reduce((css, ruleSet) => {
+        const ruleSetCSS = ruleSet.asCSS(selectorsList, outermost);
+
+        css = (css === null) ?
+                ruleSetCSS :  ///
+                  `${css}${ruleSetCSS}`;
+
+        return css;
+      }, null);
+    }
+
+    return css;
+  }
+
+  static fromNothing() {
+    const array = [],
+          ruleSets = new RuleSets(array);
+
+    return ruleSets;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const ruleSetNonTerminalNodes = ruleSetNonTerminalNodesQuery(node),
+          array = ruleSetNonTerminalNodes.map((ruleSetNonTerminalNode) => {
+            const node = ruleSetNonTerminalNode, ///
+                  ruleSet = RuleSet.fromRuleSetsNodeAndTokens(RuleSets, node, tokens);
+
+            return ruleSet;
+          }),
+          ruleSets = new RuleSets(array);
+
+    return ruleSets;
+  }
+}

package/src/style/selector.js

@@ -0,0 +1,126 @@
+"use strict";
+
+import ruleNames from "../ruleNames";
+import elementMap from "../elementMap";
+
+import { nodeQuery } from "../utilities/query";
+import { EMPTY_STRING } from "../constants";
+import { remainingContentFromNodeTokensAndOffset } from "../utilities/content";
+
+const { DIVISION_RULE_NAME,
+        STRONG_TEXT_RULE_NAME,
+        ORDERED_LIST_RULE_NAME,
+        UNORDERED_LIST_RULE_NAME,
+        ORDERED_LIST_ITEM_RULE_NAME,
+        UNORDERED_LIST_ITEM_RULE_NAME,
+        STRONGLY_EMPHASISED_TEXT_RULE_NAME } = ruleNames,
+      { tagName: strongTextTagName } = elementMap[STRONG_TEXT_RULE_NAME],
+      { tagName: orderedListTagName } = elementMap[ORDERED_LIST_RULE_NAME],
+      { tagName: unorderedListTagName } = elementMap[UNORDERED_LIST_RULE_NAME];
+
+const ruleNameValues = Object.values(ruleNames),
+      ruleNameTerminalNodeQuery = nodeQuery("/selector/@rule-name");
+
+export default class Selector {
+  constructor(content, whitespace) {
+    this.content = content;
+    this.whitespace = whitespace;
+  }
+
+  getContent() {
+    return this.content;
+  }
+
+  hasWhitespace() {
+    return this.whitespace;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    let selector = null;
+
+    const content = contentFromNodeAndTokens(node, tokens);
+
+    if (content !== null) {
+      const whitespace = whitespaceFromNode(node);
+
+      selector = new Selector(content, whitespace);
+    }
+
+    return selector;
+  }
+}
+
+function whitespaceFromNode(node) {
+  const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node),
+        whitespace = (ruleNameTerminalNode !== null);
+
+  return whitespace;
+}
+
+function contentFromNodeAndTokens(node, tokens) {
+  let content;
+
+  const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node);
+
+  if (ruleNameTerminalNode !== null) {
+    content = EMPTY_STRING;
+
+    const ruleNameTerminalNodeContent = ruleNameTerminalNode.getContent(),
+          ruleName = ruleNameTerminalNodeContent, ///
+          ruleNameValuesIncludesRuleName = ruleNameValues.includes(ruleName);
+
+    if (ruleNameValuesIncludesRuleName) {
+      const { tagName, className } = elementMap[ruleName];
+
+      if (tagName !== null) {
+        content = `${content}${tagName}`;
+      }
+
+      switch (ruleName) {
+        case DIVISION_RULE_NAME: {
+          content = null;
+
+          break;
+        }
+
+        case ORDERED_LIST_ITEM_RULE_NAME: {
+          content = `${orderedListTagName} > ${content}`;
+
+          break;
+        }
+
+        case UNORDERED_LIST_ITEM_RULE_NAME: {
+          content = `${unorderedListTagName} > ${content}`;
+
+          break;
+        }
+
+        case STRONGLY_EMPHASISED_TEXT_RULE_NAME: {
+          content = `${content} > ${strongTextTagName}`;
+
+          break;
+        }
+      }
+
+      if (className !== null) {
+        content = `${content}.${className}`;
+      }
+
+      if (ruleName === DIVISION_RULE_NAME) {
+        content = null;
+      } else {
+        const offset = 1,
+              remainingContent = remainingContentFromNodeTokensAndOffset(node, tokens, offset);
+
+        content = `${content}${remainingContent}`;
+      }
+    }
+  } else {
+    const offset = 0,
+          remainingContent = remainingContentFromNodeTokensAndOffset(node, tokens, offset);
+
+    content = remainingContent; ///
+  }
+
+  return content;
+}