highmark-markdown 1.2.97 → 1.2.102

package/src/map/nonTerminalNode/markdown.js

@@ -3,6 +3,7 @@
 import PathMarkdownNode from "../../node/markdown/path";
 import ImageMarkdownNode from "../../node/markdown/image";
 import ErrorMarkdownNode from "../../node/markdown/error";
+import XMLTextMarkdownNode from "../../node/markdown/text/xml";
 import DocumentMarkdownNode from "../../node/markdown/document";
 import DivisionMarkdownNode from "../../node/markdown/division";
 import FootnoteMarkdownNode from "../../node/markdown/footnote";
@@ -10,20 +11,29 @@ import BlockEndMarkdownNode from "../../node/markdown/blockEnd";
 import ContainerMarkdownNode from "../../node/markdown/container";
 import ReferenceMarkdownNode from "../../node/markdown/reference";
 import HyperlinkMarkdownNode from "../../node/markdown/hyperlink";
-import EmailLinkMarkdownNode from "../../node/markdown/link/email";
 import ClassNameMarkdownNode from "../../node/markdown/className";
+import EmailLinkMarkdownNode from "../../node/markdown/link/email";
 import PlainTextMarkdownNode from "../../node/markdown/text/plain";
 import BlockTextMarkdownNode from "../../node/markdown/text/block";
+import EndXMLTagMarkdownNode from "../../node/markdown/xmlTag/end";
+import XMLTagNameMarkdownNode from "../../node/markdown/xmlTagName"
 import BlockStartMarkdownNode from "../../node/markdown/blockStart";
 import SubDivisionMarkdownNode from "../../node/markdown/subDivision";
-import OrderedItemMarkdownNode from "../../node/markdown/item/ordered";
 import ReleaseNameMarkdownNode from "../../node/markdown/releaseName";
+import StartXMLTagMarkdownNode from "../../node/markdown/xmlTag/start";
+import OrderedItemMarkdownNode from "../../node/markdown/item/ordered";
+import XMLAttributeMarkdownNode from "../../node/markdown/xmlAttribute"
 import LanguageNameMarkdownNode from "../../node/markdown/languageName";
 import BlockListingMarkdownNode from "../../node/markdown/listng/block";
 import FootnoteLinkMarkdownNode from "../../node/markdown/link/footnote";
 import InlineListingMarkdownNode from "../../node/markdown/listng/inline";
 import EmbedDirectiveMarkdownNode from "../../node/markdown/directive/embed";
+import CompleteXMLTagMarkdownNode from "../../node/markdown/xmlTag/complete";
+import XMLAttributeNameMarkdownNode from "../../node/markdown/xmlAttributeName"
 import IncludeDirectiveMarkdownNode from "../../node/markdown/directive/include";
+import SimpleXMLElementMarkdownNode from "../../node/markdown/xmlElement/simple";
+import XMLAttributeValueMarkdownNode from "../../node/markdown/xmlAttributeValue"
+import ComplexXMLElementMarkdownNode from "../../node/markdown/xmlElement/complex";
 
 import { PATH_MARKDOWN_RULE_NAME,
          IMAGE_MARKDOWN_RULE_NAME,
@@ -31,6 +41,7 @@ import { PATH_MARKDOWN_RULE_NAME,
          DOCUMENT_MARKDOWN_RULE_NAME,
          DIVISION_MARKDOWN_RULE_NAME,
          FOOTNOTE_MARKDOWN_RULE_NAME,
+         XML_TEXT_MARKDOWN_RULE_NAME,
          BLOCK_END_MARKDOWN_RULE_NAME,
          CONTAINER_MARKDOWN_RULE_NAME,
          REFERENCE_MARKDOWN_RULE_NAME,
@@ -39,16 +50,25 @@ import { PATH_MARKDOWN_RULE_NAME,
          CLASS_NAME_MARKDOWN_RULE_NAME,
          PLAIN_TEXT_MARKDOWN_RULE_NAME,
          BLOCK_TEXT_MARKDOWN_RULE_NAME,
+         END_XML_TAG_MARKDOWN_RULE_NAME,
          BLOCK_START_MARKDOWN_RULE_NAME,
          ORDERED_ITEM_MARKDOWN_RULE_NAME,
          SUB_DIVISION_MARKDOWN_RULE_NAME,
          RELEASE_NAME_MARKDOWN_RULE_NAME,
+         XML_TAG_NAME_MARKDOWN_RULE_NAME,
          LANGUAGE_NAME_MARKDOWN_RULE_NAME,
          BLOCK_LISTING_MARKDOWN_RULE_NAME,
          FOOTNOTE_LINK_MARKDOWN_RULE_NAME,
+         START_XML_TAG_MARKDOWN_RULE_NAME,
+         XML_ATTRIBUTE_MARKDOWN_RULE_NAME,
          INLINE_LISTING_MARKDOWN_RULE_NAME,
          EMBED_DIRECTIVE_MARKDOWN_RULE_NAME,
-         INCLUDE_DIRECTIVE_MARKDOWN_RULE_NAME } from "../../ruleNames/markdown";
+         COMPLETE_XML_TAG_MARKDOWN_RULE_NAME,
+         INCLUDE_DIRECTIVE_MARKDOWN_RULE_NAME,
+         SIMPLE_XML_ELEMENT_MARKDOWN_RULE_NAME,
+         XML_ATTRIBUTE_NAME_MARKDOWN_RULE_NAME,
+         XML_ATTRIBUTE_VALUE_MARKDOWN_RULE_NAME,
+         COMPLEX_XML_ELEMENT_MARKDOWN_RULE_NAME } from "../../ruleNames/markdown";
 
 const markdownNonTerminalNodeMap = {
   [PATH_MARKDOWN_RULE_NAME]: PathMarkdownNode,
@@ -57,6 +77,7 @@ const markdownNonTerminalNodeMap = {
   [DOCUMENT_MARKDOWN_RULE_NAME]: DocumentMarkdownNode, ///
   [DIVISION_MARKDOWN_RULE_NAME]: DivisionMarkdownNode,
   [FOOTNOTE_MARKDOWN_RULE_NAME]: FootnoteMarkdownNode,
+  [XML_TEXT_MARKDOWN_RULE_NAME]: XMLTextMarkdownNode,
   [BLOCK_END_MARKDOWN_RULE_NAME]: BlockEndMarkdownNode,
   [CONTAINER_MARKDOWN_RULE_NAME]: ContainerMarkdownNode,
   [REFERENCE_MARKDOWN_RULE_NAME]: ReferenceMarkdownNode,
@@ -65,16 +86,25 @@ const markdownNonTerminalNodeMap = {
   [CLASS_NAME_MARKDOWN_RULE_NAME]: ClassNameMarkdownNode,
   [PLAIN_TEXT_MARKDOWN_RULE_NAME]: PlainTextMarkdownNode,
   [BLOCK_TEXT_MARKDOWN_RULE_NAME]: BlockTextMarkdownNode,
+  [END_XML_TAG_MARKDOWN_RULE_NAME]: EndXMLTagMarkdownNode,
   [BLOCK_START_MARKDOWN_RULE_NAME]: BlockStartMarkdownNode,
+  [XML_TAG_NAME_MARKDOWN_RULE_NAME]: XMLTagNameMarkdownNode,
   [ORDERED_ITEM_MARKDOWN_RULE_NAME]: OrderedItemMarkdownNode,
   [SUB_DIVISION_MARKDOWN_RULE_NAME]: SubDivisionMarkdownNode,
   [RELEASE_NAME_MARKDOWN_RULE_NAME]: ReleaseNameMarkdownNode,
+  [START_XML_TAG_MARKDOWN_RULE_NAME]: StartXMLTagMarkdownNode,
+  [XML_ATTRIBUTE_MARKDOWN_RULE_NAME]: XMLAttributeMarkdownNode,
   [LANGUAGE_NAME_MARKDOWN_RULE_NAME]: LanguageNameMarkdownNode,
   [BLOCK_LISTING_MARKDOWN_RULE_NAME]: BlockListingMarkdownNode,
   [FOOTNOTE_LINK_MARKDOWN_RULE_NAME]: FootnoteLinkMarkdownNode,
   [INLINE_LISTING_MARKDOWN_RULE_NAME]: InlineListingMarkdownNode,
   [EMBED_DIRECTIVE_MARKDOWN_RULE_NAME]: EmbedDirectiveMarkdownNode,
-  [INCLUDE_DIRECTIVE_MARKDOWN_RULE_NAME]: IncludeDirectiveMarkdownNode
+  [COMPLETE_XML_TAG_MARKDOWN_RULE_NAME]: CompleteXMLTagMarkdownNode,
+  [INCLUDE_DIRECTIVE_MARKDOWN_RULE_NAME]: IncludeDirectiveMarkdownNode,
+  [SIMPLE_XML_ELEMENT_MARKDOWN_RULE_NAME]: SimpleXMLElementMarkdownNode,
+  [XML_ATTRIBUTE_NAME_MARKDOWN_RULE_NAME]: XMLAttributeNameMarkdownNode,
+  [XML_ATTRIBUTE_VALUE_MARKDOWN_RULE_NAME]: XMLAttributeValueMarkdownNode,
+  [COMPLEX_XML_ELEMENT_MARKDOWN_RULE_NAME]: ComplexXMLElementMarkdownNode
 };
 
 export default markdownNonTerminalNodeMap;

package/src/markdown/bnf.js

@@ -29,6 +29,8 @@ const bnf = `
                                |  unorderedList 
                                    
                                |  blockListing 
+                               
+                               |  xmlElement 
       
                                |  paragraph 
                                
@@ -103,6 +105,13 @@ const bnf = `
     blockListing             ::=  blockStart blockLine* blockEnd ;
 
 
+    xmlElement               ::=  simpleXMLElement 
+  
+                               |  complexXMLElement
+                                 
+                               ;
+                            
+                               
     paragraph                ::=  line ( endOfLine line )* ;
     
 
@@ -127,7 +136,34 @@ const bnf = `
     pageNumberDirective      ::=  "@pageNumber" ;
 
 
-    nonsense.                ::=  ( [escaped] | [number] | [identifier] | [word] | [special] | [unassigned] )+ ;
+    simpleXMLElement         ::=  completeXMLTag ;
+
+
+    complexXMLElement        ::=  startXMLTag ( xmlElement | xmlText )* endXMLTag ;
+
+
+    completeXMLTag           ::=  "<"<NO_WHITESPACE>xmlTagName xmlAttribute* "/>" endOfLine* ;
+
+
+    startXMLTag              ::=  "<"<NO_WHITESPACE>xmlTagName xmlAttribute* ">" endOfLine* ;
+
+
+    endXMLTag                ::=  "</"<NO_WHITESPACE>xmlTagName ">" endOfLine* ;
+  
+
+    xmlText                  ::=  ( [escaped] | [number] | [special] | [string-literal] | [primary-identifier] | [secondary-identifier] | [unassigned] )+ endOfLine* ;
+  
+    
+    xmlAttribute             ::=  xmlAttributeName<NO_WHITESPACE>"="<NO_WHITESPACE>xmlAttributeValue ;
+
+
+    xmlTagName               ::=  ( [primary-identifier] | [secondary-identifier] ) ;
+    
+    
+    xmlAttributeName         ::=  [primary-identifier] ( <NO_WHITESPACE>[secondary-identifier] )* ;
+
+
+    xmlAttributeValue        ::=  [string-literal] ;
 
 
     tableHead                ::=  tableHeadRow ;
@@ -225,31 +261,33 @@ const bnf = `
     blockEnd                 ::=  [backticks] ;
 
 
-    className                ::=  <NO_WHITESPACE>[identifier] ;
+    className                ::=  <NO_WHITESPACE>[primary-identifier] ;
     
 
-    languageName             ::=  <NO_WHITESPACE>[identifier] ;
+    languageName             ::=  <NO_WHITESPACE>[primary-identifier] ;
     
 
-    releaseName              ::=  <NO_WHITESPACE>[identifier] ;
+    releaseName              ::=  <NO_WHITESPACE>[primary-identifier] ;
     
 
     blockText                ::=  [escaped] 
                               
                                |  [number] 
                               
-                               |  [identifier] 
-                              
                                |  [email-address]
                               
                                |  [url] 
                               
                                |  [path] 
                               
-                               |  [word] 
-                              
                                |  [special] 
                               
+                               |  [string-literal]  
+                                
+                               |  [primary-identifier] 
+                              
+                               |  [secondary-identifier] 
+                              
                                |  [unassigned]  
                                 
                                |  [dashes] 
@@ -263,18 +301,20 @@ const bnf = `
                               
                                |  [number] 
                               
-                               |  [identifier] 
-                              
                                |  [email-address]
                               
                                |  [url] 
                               
                                |  [path] 
                               
-                               |  [word] 
-                              
                                |  [special] 
                               
+                               |  [string-literal] 
+                              
+                               |  [primary-identifier] 
+                              
+                               |  [secondary-identifier] 
+                              
                                |  [unassigned] 
                               
                                ;
@@ -298,6 +338,9 @@ const bnf = `
     path                     ::=  [path] ;
 
     
+    nonsense.                ::=  ( [escaped] | [number] | [special] | [string-literal] | [primary-identifier] | [secondary-identifier] | [unassigned] )+ ;
+
+
     endOfLine                ::=  <END_OF_LINE> ;
 
 

package/src/markdown/entries.js

@@ -53,13 +53,16 @@ const entries = [
     "directive": "@[a-z]+([A-Z][a-z]+)*"
   },
   {
-    "identifier": "[a-z]+(?:-[a-z]+)*"
+    "primary-identifier": "^[a-z0-9]+(?:-[a-z0-9]+)*"
   },
   {
-    "word": "^[\\w\\-]+"
+    "secondary-identifier": "^[A-Z][a-zA-Z0-9]*"
   },
   {
-    "special": "^\\.\\.\\.|\\.|\\?|\\(|\\)|!\\[|\\[\\^|\\]:|\\[|\\]|\\^|\\/|,|!|;|:|`|'|\""
+    "xml-delimiter": "^(?:<\\/|\\/>|<|>|\\/)"
+  },
+  {
+    "special": "^(?:\\.\\.\\.|\\.|\\?|\\(|\\)|!\\[|\\[\\^|\\]:|\\[|\\]|\\^|,|!|;|:|`|'|\"|=)"
   },
   {
     "unassigned": "^[^\\s]+"
@@ -67,3 +70,4 @@ const entries = [
 ];
 
 export default entries;
+

package/src/markdown/lexer.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { CommonLexer, WhitespaceToken, EndOfLineSignificantToken } from "occam-lexers";
+import { CommonLexer, WhitespaceToken, DoublyQuotedStringLiteralToken, EndOfLineSignificantToken } from "occam-lexers";
 
 import entries from "./entries";
 
@@ -25,7 +25,7 @@ export default class MarkdownLexer extends CommonLexer {
 
   static SinglyQuotedStringLiteralToken = null;
 
-  static DoublyQuotedStringLiteralToken = null;
+  static DoublyQuotedStringLiteralToken = DoublyQuotedStringLiteralToken;
 
   static fromRules(rules) { return CommonLexer.fromRules(MarkdownLexer, rules); }
 

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

@@ -1,6 +1,6 @@
 "use strict";
 
-import TextHTMLNode from "../../html/text";
+import TextHTMLNode from "../../../node/html/text";
 
 export default class BlockTextHTMLNode extends TextHTMLNode {
   static tagName = null;

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

@@ -0,0 +1,22 @@
+"use strict";
+
+import TextHTMLNode from "../../../node/html/text";
+
+export default class XMLTextHTMLNode extends TextHTMLNode {
+  static tagName = null;
+
+  static className = null;
+
+  text(context) {
+    let text = super.text(context);
+
+    text = `${text}
+`;
+
+    return text;
+  }
+
+  static fromNothing() { return TextHTMLNode.fromNothing(XMLTextHTMLNode); }
+
+  static fromOuterNode(outerNode) { return TextHTMLNode.fromOuterNode(XMLTextHTMLNode, outerNode); }
+}

package/src/node/html/xmlElement/complex.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import XMLElementHTMLNode from "../../../node/html/xmlElement";
+
+import { EMPTY_STRING } from "../../../constants";
+
+export default class ComplexXMLElementHTMLNode extends XMLElementHTMLNode {
+  asHTML(indent, context) {
+    let html;
+
+    const jsx = this.isJSX(context);
+
+    if (jsx) {
+      html = EMPTY_STRING;
+    } else {
+      indent = this.adjustIndent(indent);
+
+      const childNodesHTML = this.childNodesAsHTML(indent, context),
+            startingTag = this.startingTag(context),
+            closingTag = this.closingTag(context);
+
+      html = (indent === null) ?
+              `${startingTag}${childNodesHTML}${closingTag}` :
+                `${indent}${startingTag}
+${childNodesHTML}${indent}${closingTag}
+`;
+    }
+
+    return html;
+  }
+
+  static fromNothing() { return XMLElementHTMLNode.fromNothing(ComplexXMLElementHTMLNode); }
+
+  static fromOuterNode(outerNode) { return XMLElementHTMLNode.fromOuterNode(ComplexXMLElementHTMLNode, outerNode); }
+}

package/src/node/html/xmlElement/simple.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import XmLElementHTMLNode from "../../../node/html/xmlElement";
+
+import { EMPTY_STRING } from "../../../constants";
+
+export default class SimpleXMLElementHTMLNode extends XmLElementHTMLNode {
+  asHTML(indent, context) {
+    let html;
+
+    const jsx = this.isJSX(context);
+
+    if (jsx) {
+      html = EMPTY_STRING
+    } else {
+      indent = this.adjustIndent(indent);
+
+      const selfClosingTag = this.selfClosingTag(context);
+
+      html = (indent === null) ?
+               `${selfClosingTag}` :
+                 `${indent}${selfClosingTag}
+`;
+    }
+
+    return html;
+  }
+
+  static fromNothing() { return XmLElementHTMLNode.fromNothing(SimpleXMLElementHTMLNode); }
+
+  static fromOuterNode(outerNode) { return XmLElementHTMLNode.fromOuterNode(SimpleXMLElementHTMLNode, outerNode); }
+}

package/src/node/html/xmlElement.js

@@ -0,0 +1,173 @@
+"use strict";
+
+import HTMLNode from "../../node/html";
+
+import { EMPTY_STRING } from "../../constants";
+import { mountElement, unmountElement } from "../../utilities/jsx";
+
+const jsxNameRegularExpression = /^[A-Z]/;
+
+export default class XMLElementHTMLNode extends HTMLNode {
+  isJSX(context) {
+    const tagName = this.tagName(context),
+          tagNameJSXName = jsxNameRegularExpression.test(tagName),
+          jsx = tagNameJSXName; ///
+
+    return jsx;
+  }
+
+  tagName(context) {
+    const markdownNode = this.getMarkdownNode(),
+          tagName = markdownNode.tagName(context);
+
+    return tagName;
+  }
+
+  properties(context) {
+    const markdownNode = this.getMarkdownNode(),
+          properties = markdownNode.properties(context);
+
+    return properties;
+  }
+
+  attributeNames(context) {
+    const markdownNode = this.getMarkdownNode(),
+      attributeNames = markdownNode.attributeNames(context);
+
+    return attributeNames;
+  }
+
+  attributeValues(context) {
+    const markdownNode = this.getMarkdownNode(),
+          attributeValues = markdownNode.attributeValues(context);
+
+    return attributeValues;
+  }
+
+  startingTag(context) {
+    let startingTag = EMPTY_STRING;
+
+    const tagName = this.tagName(context);
+
+    startingTag = `${startingTag}<${tagName}`;
+
+    const attributeNames = this.attributeNames(context),
+          attributeValues = this.attributeValues(context);
+
+    attributeNames.forEach((attributeName, index) => {
+      const attributeValue = attributeValues[index];
+
+      startingTag = `${startingTag} ${attributeName}="${attributeValue}"`;
+    });
+
+    startingTag = `${startingTag}/>`;
+
+    return startingTag;
+  }
+
+  closingTag(context) {
+    const tagName = this.tagName(context),
+          closingTag = `</${tagName}>`;
+
+    return closingTag;
+  }
+
+  selfClosingTag(context) {
+    let selfClosingTag = EMPTY_STRING;
+
+    const tagName = this.tagName(context);
+
+    selfClosingTag = `${selfClosingTag}<${tagName}`;
+
+    const attributeNames = this.attributeNames(context),
+          attributeValues = this.attributeValues(context);
+
+    attributeNames.forEach((attributeName, index) => {
+      const attributeValue = attributeValues[index];
+
+      selfClosingTag = `${selfClosingTag} ${attributeName}="${attributeValue}"`;
+
+    });
+
+    selfClosingTag = `${selfClosingTag}/>`;
+
+    return selfClosingTag;
+  }
+
+  createDOMElement(context) {
+    let domElement = null;
+
+    const jsx = this.isJSX(context);
+
+    if (jsx) {
+      const jsxDOMElement = this.createJSXDomElement(context);
+
+      domElement = jsxDOMElement; ///
+    } else {
+      const tagName = this.tagName(context);
+
+      domElement = document.createElement(tagName);
+
+      const attributeNames = this.attributeNames(context),
+            attributeValues = this.attributeValues(context);
+
+      attributeNames.forEach((attributeName, index) => {
+        const attributeValue = attributeValues[index];
+
+        domElement.setAttribute(attributeName, attributeValue);
+      });
+    }
+
+    return domElement;
+  }
+
+  createJSXDomElement(context) {
+    let jsxDOMElement = null;
+
+    const { JSXElements = [] } = context,
+          tagName = this.tagName(context),
+          JSXElement = JSXElements.find((JSXElement) => {
+            const { defaultProperties = {} } = JSXElement,
+                  { name } = defaultProperties,
+                  nameTagName = (name === tagName);
+
+            if (nameTagName) {
+              return true;
+            }
+          }) || null;
+
+    if (JSXElement !== null) {
+      const properties = this.properties(context),
+            jsxElement =
+
+              <JSXElement {...properties} />
+
+            ,
+            domElement = jsxElement.getDOMElement();
+
+      jsxDOMElement = domElement; ///
+    }
+
+    return jsxDOMElement;
+  }
+
+  mount(parentDOMElement, siblingDOMElement, context) {
+    super.mount(parentDOMElement, siblingDOMElement, context);
+
+    if (this.domElement !== null) {
+      mountElement(this.domElement);
+    }
+  }
+
+  unmount(parentDOMElement) {
+    if (this.domElement !== null) {
+      unmountElement(this.domElement);
+    }
+
+    super.unmount(parentDOMElement);
+  }
+
+  static fromNothing(Class) { return HTMLNode.fromNothing(Class); }
+
+  static fromOuterNode(Class, outerNode) { return HTMLNode.fromOuterNode(Class, outerNode); }
+}

package/src/node/html.js

@@ -266,35 +266,39 @@ class HTMLNode extends Node {
   mount(parentDOMElement, siblingDOMElement, context) {
     this.domElement = this.createDOMElement(context);
 
-    (siblingDOMElement !== null) ?
-      insertAfter(this.domElement, parentDOMElement, siblingDOMElement) :
-        insertBeforehand(this.domElement, parentDOMElement);
+    if (this.domElement !== null) {
+      (siblingDOMElement !== null) ?
+        insertAfter(this.domElement, parentDOMElement, siblingDOMElement) :
+          insertBeforehand(this.domElement, parentDOMElement);
 
-    parentDOMElement = this.domElement; ///
+      parentDOMElement = this.domElement; ///
 
-    siblingDOMElement = null;
+      siblingDOMElement = null;
 
-    this.childNodes.forEach((childNode) => {
-      siblingDOMElement = childNode.mount(parentDOMElement, siblingDOMElement, context);
-    });
+      this.childNodes.forEach((childNode) => {
+        siblingDOMElement = childNode.mount(parentDOMElement, siblingDOMElement, context);
+      });
 
-    siblingDOMElement = this.domElement;  ///
+      siblingDOMElement = this.domElement;  ///
+    }
 
     return siblingDOMElement;
   }
 
   unmount(parentDOMElement) {
-    {
-      const parentDOMElement = this.domElement; ///
+    if (this.domElement !== null) {
+      {
+        const parentDOMElement = this.domElement; ///
 
-      this.childNodes.forEach((childNode) => {
-        childNode.unmount(parentDOMElement);
-      });
-    }
+        this.childNodes.forEach((childNode) => {
+          childNode.unmount(parentDOMElement);
+        });
+      }
 
-    remove(this.domElement, parentDOMElement);
+      remove(this.domElement, parentDOMElement);
 
-    this.domElement = null;
+      this.domElement = null;
+    }
   }
 
   asHTML(indent, context) {

package/src/node/markdown/className.js

@@ -5,9 +5,9 @@ import MarkdownNode from "../../node/markdown";
 export default class ClassNameMarkdownNode extends MarkdownNode {
   className(context) {
     const className = this.fromSecondChildNode((secondChildNode) => {
-      const identifierTerminalNode = secondChildNode, ///
-            content = identifierTerminalNode.getContent(),
-            className = content;  ///
+      const terminalNode = secondChildNode, ///
+            terminalNodeContent = terminalNode.getContent(),
+            className = terminalNodeContent;  ///
 
       return className;
     });

package/src/node/markdown/languageName.js

@@ -5,9 +5,9 @@ import MarkdownNode from "../../node/markdown";
 export default class LanguageNameMarkdownNode extends MarkdownNode {
   languageName(context) {
     const languageName = this.fromSecondChildNode((secondChildNode) => {
-      const identifierTerminalNode = secondChildNode, ///
-            content = identifierTerminalNode.getContent(),
-            languageName = content;  ///
+      const terminalNode = secondChildNode, ///
+            terminalNodeContent = terminalNode.getContent(),
+            languageName = terminalNodeContent;  ///
 
       return languageName;
     });

package/src/node/markdown/releaseName.js

@@ -5,9 +5,9 @@ import MarkdownNode from "../../node/markdown";
 export default class ReleaseNameMarkdownNode extends MarkdownNode {
   releaseName(context) {
     const releaseName = this.fromSecondChildNode((secondChildNode) => {
-      const identifierTerminalNode = secondChildNode, ///
-            content = identifierTerminalNode.getContent(),
-            releaseName = content;  ///
+      const terminalNode = secondChildNode, ///
+            terminalNodeContent = terminalNode.getContent(),
+            releaseName = terminalNodeContent;  ///
 
       return releaseName;
     });

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

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