highmark-markdown 0.0.156 → 0.0.157

package/src/example/view/div/sizeable/left.js

@@ -12,7 +12,7 @@ class LeftSizeableDiv extends SizeableDiv {
 
 export default withStyle(LeftSizeableDiv)`
 
-  width: 64rem;
+  width: 96rem;
   min-width: 12rem;
   flex-direction: column;
   

package/src/example/view.js

@@ -16,7 +16,7 @@ import ParseTreeTextarea from "./view/textarea/parseTree";
 import LexicalEntriesTextarea from "./view/textarea/lexicalEntries";
 
 import { MarkdownLexer, MarkdownParser } from "../index";
-import { EMPTY_STRING, DOCUMENT_DIVISION_CLASS_NAME, FRONT_MATTER_DIVISION_CLASS_NAME } from "./constants";
+import { EMPTY_STRING, DOCUMENT_DIVISION_CLASS_NAME } from "./constants";
 
 const { bnf } = MarkdownParser,
       { entries } = MarkdownLexer;
@@ -48,8 +48,7 @@ class View extends Element {
       const parentNode = null,
             indent = EMPTY_STRING,
             context = {
-              tokens,
-              importer
+              tokens
             };
 
       divisionMarkdownNode.resolveImports(parentNode, context);
@@ -135,10 +134,11 @@ class View extends Element {
     this.update();
   }
 
-  static initialMarkdown = `@contents 3
-  
-@import cover.mds
-   
+  static initialMarkdown = `
+# Occam [^occam]
+
+[^occam]: An occam footnote.
+
 `;
 
   static tagName = "div";
@@ -153,25 +153,3 @@ export default withStyle(View)`
   padding: 1rem;
   
 `;
-
-function importer(path, context) {
-  const content = `
-
-# Primary heading
-
-`       ,
-        tokens = markdownLexer.tokenise(content),
-        node = markdownParser.parse(tokens),
-        divisionMarkdownNode = node,  ///
-        divisionClassName = FRONT_MATTER_DIVISION_CLASS_NAME;
-
-  divisionMarkdownNode.setDivisionClassName(divisionClassName);
-
-  const importedNode = node, ///
-        importedTokens = tokens;  ///
-
-  Object.assign(context, {
-    importedNode,
-    importedTokens
-  });
-}

package/src/markdown/bnf.js

@@ -228,7 +228,7 @@ const bnf = `
     reference.              ::=  "[^" [identifier] "]:" ;
     
 
-    anchor                  ::=  [number] ;
+    anchor                  ::=  [identifier] ;
     
 
     className               ::=  <NO_WHITESPACE>[identifier] ;

package/src/markdown/entries.js

@@ -56,7 +56,7 @@ const entries = [
     "path": "^[a-z0-9\\-_]+(?:\\/[a-z0-9\\-_]+)*\\.[a-z0-9\\-_]+"
   },
   {
-    "identifier": "^[a-z]+(?:-[a-z]+)*"
+    "identifier": "[a-z]+(?:-[a-z]+)*"
   },
   {
     "word": "^\\w+"

package/src/markdown/parser.js

@@ -5,7 +5,7 @@ import { CommonParser } from "occam-parsers";
 import bnf from "./bnf";
 import nodeMap from "../nodeMap";
 
-import { setNonTerminalNodes } from "../utilities/nodes";
+import { setNonTerminalNodes } from "../utilities/parser";
 
 export default class MarkdownParser extends CommonParser {
   static bnf = bnf;

package/src/mixins/content.js

@@ -2,12 +2,12 @@
 
 import { contentFromMarkdownNodes } from "../utilities/content";
 
-function content(context, trimmed = true) {
+function content(context, leftTrimmed = true, rightTrimmed = true) {
   const markdownNode = this, ///
         markdownNodes = [
           markdownNode
         ],
-        content = contentFromMarkdownNodes(markdownNodes, context, trimmed);
+        content = contentFromMarkdownNodes(markdownNodes, context, leftTrimmed, rightTrimmed);
 
   return content;
 }

package/src/node/markdown/blockText.js

@@ -5,17 +5,20 @@ import contentMixins from "../../mixins/content";
 
 class BlockTextMarkdownNode extends MarkdownNode {
   asHTML(indent, context) {
-    const trimmed = false,
-          content = this.content(context, trimmed),
+    const leftTrimmed = false,
+          rightTrimmed = false,
+          content = this.content(context, leftTrimmed, rightTrimmed),
           html = content; ///
 
     return html;
   }
 
   createDOMElement(context) {
-    const trimmed = false,
-          content = this.content(context, trimmed),
-          domElement = document.createTextNode(content, trimmed);
+    const leftTrimmed = false,
+          rightTrimmed = false,
+          content = this.content(context, leftTrimmed, rightTrimmed),
+          textNode = document.createTextNode(content),
+          domElement = textNode;
 
     this.setDOMElement(domElement);
 

package/src/node/markdown/contentsItem.js

@@ -1,28 +1,25 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
+import ContentsLinkMarkdownNode from "../../node/markdown/contentsLink";
 
 import { CONTENTS_ITEM_RULE_NAME } from "../../ruleNames";
 
-const { push } = arrayUtilities;
-
 export default class ContentsItemMarkdownNode extends MarkdownNode {
-  static fromNestedHeadingMarkdownNodeAndContentsListMarkdownNode(nestedHeadingMarkdownNode, ContentsListMarkdownNode, context) {
-    const node = nestedHeadingMarkdownNode.getNode(),
-          childNestedNodes = nestedHeadingMarkdownNode.getChildNestedNodes(),
-          nestedHeadingMarkdownNodes = childNestedNodes,  ///
-          contentsListMarkdownNode = ContentsListMarkdownNode.fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes);
-
-    const ruleName = CONTENTS_ITEM_RULE_NAME,
+  static fromContentsListMarkdownNodeAndNestedHeadingMarkdownNode(ContentsListMarkdownNode, nestedHeadingMarkdownNode, context) {
+    const contentsLinkMarkdownNode = ContentsLinkMarkdownNode.fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context),
+          contentsListMarkdownNode = ContentsListMarkdownNode.fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context),
           childNodes = [];
 
-    if (node !== null) {
-      const headingMarkdownNode = node, ///
-            headingMarkdownNodeChildNodes = clone(headingMarkdownNode.getChildNodes()); ///
+    if (contentsLinkMarkdownNode !== null) {
+      const childNode = contentsLinkMarkdownNode; ///
+
+      childNodes.push(childNode);
 
-      push(childNodes, headingMarkdownNodeChildNodes);
+      const node = nestedHeadingMarkdownNode.getNode(),
+            headingMarkdownNode = node;  ///
+
+      headingMarkdownNode.addAnchor(context);
     }
 
     if (contentsListMarkdownNode !== null) {
@@ -31,19 +28,10 @@ export default class ContentsItemMarkdownNode extends MarkdownNode {
       childNodes.push(childNode);
     }
 
-    const opacity = null,
+    const ruleName = CONTENTS_ITEM_RULE_NAME,
+          opacity = null,
           contentsItemMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsItemMarkdownNode, ruleName, childNodes, opacity);
 
     return contentsItemMarkdownNode;
   }
 }
-
-function clone(nodes) {
-  nodes = nodes.map((node) => { ///
-    node = node.clone();  ///
-
-    return node;
-  });
-
-  return nodes;
-}

package/src/node/markdown/contentsLink.js

@@ -0,0 +1,162 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import MarkdownNode from "../../node/markdown";
+
+import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
+import { CONTENTS_LINK_RULE_NAME } from "../../ruleNames";
+
+const { push } = arrayUtilities;
+
+export default class ContentsLinkMarkdownNode extends MarkdownNode {
+  constructor(ruleName, childNodes, opacity, precedence, domElement, identifier) {
+    super(ruleName, childNodes, opacity, precedence, domElement);
+
+    this.identifier = identifier;
+  }
+
+  getIdentifier() {
+    return this.identifier;
+  }
+
+  attributeName(context) {
+    const attributeName = HREF_ATTRIBUTE_NAME;
+
+    return attributeName;
+  }
+
+  attributeValue(context) {
+    const attributeValue = `#${this.identifier}`;
+
+    return attributeValue;
+  }
+
+  static fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context) {
+    let contentsLinkMarkdownNode = null;
+
+    const node = nestedHeadingMarkdownNode.getNode(),
+          headingMarkdownNode = node;  ///
+
+    if (headingMarkdownNode !== null) {
+      const { replacementTokens } = context,
+            headingMarkdownNodeOffset = offsetFromNode(headingMarkdownNode, context), ///
+            headingMarkdownNodeTokens = tokensFromNode(headingMarkdownNode, context),
+            headingMarkdownNodeChildNodes = childNodesFromNode(headingMarkdownNode);
+
+      push(replacementTokens, headingMarkdownNodeTokens);
+
+      replaceChildNodesTokens(headingMarkdownNodeChildNodes, headingMarkdownNodeTokens, headingMarkdownNodeOffset, context);
+
+      const childNodes = headingMarkdownNodeChildNodes, ///
+            ruleName = CONTENTS_LINK_RULE_NAME,
+            opacity = null,
+            identifier = headingMarkdownNode.identifier(context);
+
+      contentsLinkMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsLinkMarkdownNode, ruleName, childNodes, opacity, identifier);
+    }
+
+    return contentsLinkMarkdownNode;
+  }
+}
+
+function offsetFromNode(node, context) {
+  const { tokens } = context,
+        nonTerminalNode = node,  ///
+        firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+        offset = firstSignificantTokenIndex;  ///
+
+  return offset;
+}
+
+function tokensFromNode(node, context) {
+  let tokens;
+
+  ({ tokens } = context);
+
+  const nonTerminalNode = node,  ///
+        lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
+        firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
+        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);
+
+  tokens = tokens.map((token) => {  ///
+    token = token.clone();  ///
+
+    return token;
+  });
+
+  return tokens;
+}
+
+function childNodesFromNode(node) {
+  let childNodes;
+
+  const nonTerminalNode = node;  ///
+
+  childNodes = nonTerminalNode.getChildNodes();
+
+  childNodes = childNodes.map((childNode) => { ///
+    childNode = childNode.clone();  ///
+
+    return childNode;
+  });
+
+  return childNodes;
+}
+
+function replaceNodeTokens(node, replacementTokens, offset, context) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    replaceTerminalNodeTokens(terminalNode, replacementTokens, offset, context);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, offset, context);
+  }
+}
+
+function replaceChildNodesTokens(childNodes, tokens, offset, context) {
+  childNodes.forEach((childNode) => {
+    const node = childNode; ///
+
+    replaceNodeTokens(node, tokens, offset, context);
+  });
+}
+
+function replaceTerminalNodeTokens(terminalNode, tokens, offset, context) {
+  let index,
+      significantToken;
+
+  const temporaryTokens = tokens; ///
+
+  ({ tokens } = context);
+
+  significantToken = terminalNode.getSignificantToken();
+
+  index = tokens.indexOf(significantToken);
+
+  index -= offset;
+
+  tokens = temporaryTokens; ///
+
+  const token = tokens[index];
+
+  significantToken = token;  ///
+
+  terminalNode.setSignificantToken(significantToken);
+}
+
+function replaceNonTerminalNodeTokens(nonTerminalNode, tokens, offset, context) {
+  const childNodes = nonTerminalNode.getChildNodes();
+
+  replaceChildNodesTokens(childNodes, tokens, offset, context);
+}

package/src/node/markdown/contentsList.js

@@ -1,35 +1,73 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import MarkdownNode from "../../node/markdown";
 import ContentsItemMarkdownNode from "../../node/markdown/contentsItem";
 
+import { nestNodes } from "../../utilities/contents";
 import { CONTENTS_LIST_RULE_NAME } from "../../ruleNames";
+import { headingMarkdownNodesFromNode, contentsMarkdownNodeFromNode } from "../../utilities/query";
+
+const { filter } = arrayUtilities;
 
 export default class ContentsListMarkdownNode extends MarkdownNode {
-  static fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
-    let contentsListMarkdownNode = null;
+  static fromDivisionMarkdownNode(divisionMarkdownNode, context) {
+    const node = divisionMarkdownNode,  ///
+          contentsMarkdownNode = contentsMarkdownNodeFromNode(node);
 
-    const nestedHeadingMarkdownNodesLength = nestedHeadingMarkdownNodes.length;
+    if (contentsMarkdownNode === null) {
+      return;
+    }
 
-    if (nestedHeadingMarkdownNodesLength > 0) {
-      const ruleName = CONTENTS_LIST_RULE_NAME,
-            childNodes = childNodesFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
-            opacity = null;
+    const headingMarkdownNodes = headingMarkdownNodesFromDivisionMarkdownNodeAndContentsMarkdownNode(divisionMarkdownNode, contentsMarkdownNode, context),
+          headingMarkdownNodesLength = headingMarkdownNodes.length;
 
-      contentsListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsListMarkdownNode, ruleName, childNodes, opacity);
+    if (headingMarkdownNodesLength === 0) {
+      return;
     }
 
-    return contentsListMarkdownNode;
+    const ruleName = CONTENTS_LIST_RULE_NAME,
+          childNodes = childNodesFromHeadingMarkdownNodes(headingMarkdownNodes, context),
+          opacity = null,
+          contentsListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsListMarkdownNode, ruleName, childNodes, opacity),
+          replacementChildNode = contentsListMarkdownNode, ///
+          replacedChildNode = contentsMarkdownNode;  ///
+
+    Object.assign(context, {
+      replacedChildNode,
+      replacementChildNode
+    });
   }
 }
 
-function childNodesFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
-  const childNodes = nestedHeadingMarkdownNodes.map((nestedHeadingMarkdownNode) => {
-    const contentsItemMarkdownNode = ContentsItemMarkdownNode.fromNestedHeadingMarkdownNodeAndContentsListMarkdownNode(nestedHeadingMarkdownNode, ContentsListMarkdownNode, context),
-          childNode = contentsItemMarkdownNode; ///
+function childNodesFromHeadingMarkdownNodes(headingMarkdownNodes, context) {
+  const nodes = headingMarkdownNodes, ///
+        nestedNode = nestNodes(nodes),
+        childNestedNodes = nestedNode.getChildNestedNodes(),
+        childNodes = childNestedNodes.map((childNestedNode) => {
+          const nestedHeadingMarkdownNode = childNestedNode,  ///
+                contentsItemMarkdownNode = ContentsItemMarkdownNode.fromContentsListMarkdownNodeAndNestedHeadingMarkdownNode(ContentsListMarkdownNode, nestedHeadingMarkdownNode, context),
+                childNode = contentsItemMarkdownNode; ///
 
-    return childNode;
-  });
+          return childNode;
+        });
 
   return childNodes;
 }
+
+function headingMarkdownNodesFromDivisionMarkdownNodeAndContentsMarkdownNode(divisionMarkdownNode, contentsMarkdownNode, context) {
+  const node = divisionMarkdownNode,  ///
+        maximumLevel = contentsMarkdownNode.maximumLevel(context),
+        headingMarkdownNodes = headingMarkdownNodesFromNode(node);
+
+  filter(headingMarkdownNodes, (headingMarkdownNode) => {
+    const level = headingMarkdownNode.getLevel();
+
+    if (level <= maximumLevel) {
+      return true;
+    }
+  });
+
+  return headingMarkdownNodes;
+}

package/src/node/markdown/division.js

@@ -1,18 +1,11 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import MarkdownNode from "../../node/markdown";
 import ContentsListMarkdownNode from "../../node/markdown/contentsList";
+import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
 
-const { filter } = arrayUtilities;
-
-import { nestNodes } from "../../utilities/tree";
 import { replaceTokens } from "../../utilities/tokens";
-import { headingMarkdownNodesFromNode, contentsMarkdownNodeFromNode } from "../../utilities/query";
-// import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
-
-// import { renumberLinkMarkdownNodes, renumberLinkMarkdownNodesHTML, appendFootnotesListMarkdownNodeHTML } from "../../utilities/footnotes";
+import { parentNodeFromNodeAndChildNode } from "../../utilities/node";
 
 export default class DivisionMarkdownNode extends MarkdownNode {
   constructor(ruleName, childNodes, precedence, opacity, domElement, divisionClassName) {
@@ -36,86 +29,51 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   }
 
   createContents(context) {
-    const node = this,  ///
-          contentsMarkdownNode = contentsMarkdownNodeFromNode(node);
-
-    if (contentsMarkdownNode === null) {
-      return;
-    }
-
-    const maximumLevel = contentsMarkdownNode.maximumLevel(context);
-
-    const headingMarkdownNodes = headingMarkdownNodesFromNodeAndMaximumLevel(node, maximumLevel, context),
-          headingMarkdownNodesLength = headingMarkdownNodes.length;
-
-    if (headingMarkdownNodesLength === 0) {
-      return;
-    }
-
-    const nodes = headingMarkdownNodes, ///
-          nestedNode = nestNodes(nodes),
-          childNestedNodes = nestedNode.getChildNestedNodes(),
-          replacementTokens = [];
+    const replacementTokens = [],
+          divisionMarkdownNode = this;
 
     Object.assign(context, {
       replacementTokens
     });
 
-    const nestedHeadingMarkdownNodes = childNestedNodes,  ///
-          contentsListMarkdownNode = ContentsListMarkdownNode.fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
-          replacementChildNode = contentsListMarkdownNode,
-          replacedChildNode = contentsMarkdownNode; ///
+    ContentsListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
+
+    const { replacementChildNode = null, replacedChildNode = null } = context;
 
-    this.replaceChildNode(replacedChildNode, replacementChildNode);
+    if ((replacementChildNode !== null) && (replacedChildNode !== null)) {
+      const node = this,  ///
+            childNode = replacedChildNode,  ///
+            parentNode = parentNodeFromNodeAndChildNode(node, childNode);
 
-    // replaceTokens(replacedChildNode, replacementTokens, context);
+      parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+
+      replaceTokens(replacedChildNode, replacementTokens, context);
+    }
 
     delete context.replacementTokens;
+    delete context.replacedChildNode;
+    delete context.replacementChildNode;
   }
 
   createFootnotes(context) {
+    const replacementTokens = [],
+          divisionMarkdownNode = this;  ///
 
-  }
+    Object.assign(context, {
+      replacementTokens
+    });
 
-  recreateFootnotes(context) {
+    FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
 
-  }
+    const { replacementChildNode = null } = context;
 
-  // childNodesAsHTML(indent, context) {
-  //   const divisionMarkdownNode = this,  ///
-  //         contentsListMarkdownNode = ContentsListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context),
-  //         footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
-  //
-  //   let childNodesHTML = super.childNodesAsHTML(indent, context);
-  //
-  //   if (contentsListMarkdownNode !== null) {
-  //     childNodesHTML = replaceContentsMarkdownNodeHTML(childNodesHTML, divisionMarkdownNode, contentsListMarkdownNode, context);
-  //   }
-  //
-  //   if (footnotesListMarkdownNode !== null) {
-  //     childNodesHTML = renumberLinkMarkdownNodesHTML(childNodesHTML, divisionMarkdownNode, footnotesListMarkdownNode, context);
-  //
-  //     childNodesHTML = appendFootnotesListMarkdownNodeHTML(childNodesHTML, footnotesListMarkdownNode, indent, context);
-  //   }
-  //
-  //   return childNodesHTML;
-  // }
-
-  // createChildNodeDOMElements(context) {
-  //   const divisionMarkdownNode = this,  ///
-  //         footnotesListMarkdownNode = FootnotesListMarkdownNode.fromDivisionMarkdownNode(divisionMarkdownNode, context);
-  //
-  //   super.createChildNodeDOMElements(context);
-  //
-  //   if (footnotesListMarkdownNode !== null) {
-  //     const footnotesListMarkdownNodeDOMElement = footnotesListMarkdownNode.createDOMElement(context),
-  //           childNodeDOMElement = footnotesListMarkdownNodeDOMElement;  ///
-  //
-  //     this.insertDOMElement(childNodeDOMElement);
-  //
-  //     renumberLinkMarkdownNodes(divisionMarkdownNode, footnotesListMarkdownNode, context);
-  //   }
-  // }
+    if (replacementChildNode !== null) {
+      const childNode = replacementChildNode,  ///
+            parentNode = this;  ///
+
+      parentNode.addChildNode(childNode);
+    }
+  }
 
   clone() {
     debugger
@@ -128,17 +86,3 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return divisionMarkdownNode;
   }
 }
-
-function headingMarkdownNodesFromNodeAndMaximumLevel(node, maximumLevel) {
-  const  headingMarkdownNodes = headingMarkdownNodesFromNode(node);
-
-  filter(headingMarkdownNodes, (headingMarkdownNode) => {
-    const level = headingMarkdownNode.getLevel();
-
-    if (level <= maximumLevel) {
-      return true;
-    }
-  });
-
-  return headingMarkdownNodes;
-}

package/src/node/markdown/emailLink.js

@@ -83,9 +83,9 @@ class EmailLinkMarkdownNode extends MarkdownNode {
     const inlineText = this.inlineText(context),
           content = (inlineText !== null) ?
                       inlineText :
-                        this.content(context);
-
-    const childNodeDOMElement = document.createTextNode(content);
+                        this.content(context),
+          textNode = document.createTextNode(content),
+          childNodeDOMElement = textNode; ///
 
     this.insertDOMElement(childNodeDOMElement);
   }

package/src/node/markdown/endOfLine.js

@@ -13,7 +13,8 @@ export default class EndOfLineMarkdownNode extends MarkdownNode {
 
   createDOMElement(context) {
     const content = EMPTY_STRING, ///
-          domElement = document.createTextNode(content);
+          textNode = document.createTextNode(content),
+          domElement = textNode;  ///
 
     this.setDOMElement(domElement);
 

package/src/node/markdown/error.js

@@ -13,7 +13,8 @@ class ErrorMarkdownNode extends MarkdownNode {
 
   createChildNodeDOMElements(context) {
     const content = this.content(context),
-          childNodeDOMElement = document.createTextNode(content);
+          textNode  = document.createTextNode(content),
+          childNodeDOMElement = textNode; ///
 
     this.insertDOMElement(childNodeDOMElement);
   }