highmark-markdown 0.0.225 → 0.0.228

package/src/node/markdown/contentsLink.js

@@ -2,6 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
+import ClonedNode from "../../clonedNode";
 import MarkdownNode from "../../node/markdown";
 
 import { HREF_ATTRIBUTE_NAME } from "../../attributeNames";
@@ -10,12 +11,20 @@ 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);
+  constructor(ruleName, childNodes, opacity, precedence, domElement, tokens, identifier) {
+    super(ruleName, childNodes, opacity, precedence, tokens, domElement);
+
+    this.tokens = tokens;
 
     this.identifier = identifier;
   }
 
+  getTokens(tokens = []) {
+    push(tokens, this.tokens);
+
+    return tokens;
+  }
+
   getIdentifier() {
     return this.identifier;
   }
@@ -32,6 +41,16 @@ export default class ContentsLinkMarkdownNode extends MarkdownNode {
     return attributeValue;
   }
 
+  clone() {
+    const tokens = this.tokens.map((token) => {
+      token = token.clone();  ///
+
+      return token;
+    });
+
+    return super.clone(tokens, this.identifier);
+  }
+
   static fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context) {
     let contentsLinkMarkdownNode = null;
 
@@ -39,124 +58,17 @@ export default class ContentsLinkMarkdownNode extends MarkdownNode {
           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, ///
+      const node = headingMarkdownNode, ///
+            clonedNode = ClonedNode.fromNode(node, context),
+            childNodes = clonedNode.getChildNodes(),
             ruleName = CONTENTS_LINK_RULE_NAME,
             opacity = null,
+            tokens = clonedNode.getTokens(),
             identifier = headingMarkdownNode.identifier(context);
 
-      contentsLinkMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsLinkMarkdownNode, ruleName, childNodes, opacity, identifier);
+      contentsLinkMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsLinkMarkdownNode, ruleName, childNodes, opacity, tokens, 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

@@ -3,20 +3,51 @@
 import MarkdownNode from "../../node/markdown";
 import ContentsItemMarkdownNode from "../../node/markdown/contentsItem";
 
+import { nestNodes } from "../../utilities/contents";
 import { CONTENTS_LIST_RULE_NAME } from "../../ruleNames";
 
 export default class ContentsListMarkdownNode extends MarkdownNode {
+  getTokens(tokens = []) {
+    const childNodes = this.getChildNodes(),
+          contentsItemMarkdownNodes = childNodes;  ///
+
+    contentsItemMarkdownNodes.forEach((contentsItemMarkdownNode) => {
+      contentsItemMarkdownNode.getTokens(tokens);
+    });
+
+    return tokens;
+  }
+
+  static fromHeadingMarkdownNodes(headingMarkdownNodes, context) {
+    const nodes = headingMarkdownNodes, ///
+          nestedNode = nestNodes(nodes),
+          childNestedNodes = nestedNode.getChildNestedNodes(),
+          nestedHeadingMarkdownNodes = childNestedNodes,  ///
+          ruleName = CONTENTS_LIST_RULE_NAME,
+          childNodes = childNodesFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+          opacity = null,
+          contentsListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsListMarkdownNode, ruleName, childNodes, opacity);
+
+    return contentsListMarkdownNode;
+  }
+
   static fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
     const ruleName = CONTENTS_LIST_RULE_NAME,
-          childNodes = nestedHeadingMarkdownNodes.map((nestedHeadingMarkdownNode) => {
-            const contentsItemMarkdownNode = ContentsItemMarkdownNode.fromContentsListMarkdownNodeAndNestedHeadingMarkdownNode(ContentsListMarkdownNode, nestedHeadingMarkdownNode, context),
-                  childNode = contentsItemMarkdownNode; ///
-
-            return childNode;
-          }),
+          childNodes = childNodesFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
           opacity = null,
           contentsListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(ContentsListMarkdownNode, ruleName, childNodes, opacity);
 
     return contentsListMarkdownNode;
   }
 }
+
+function childNodesFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
+  const childNodes = nestedHeadingMarkdownNodes.map((nestedHeadingMarkdownNode) => {
+    const contentsItemMarkdownNode = ContentsItemMarkdownNode.fromContentsListMarkdownNodeAndNestedHeadingMarkdownNode(ContentsListMarkdownNode, nestedHeadingMarkdownNode, context),
+          childNode = contentsItemMarkdownNode; ///
+
+    return childNode;
+  });
+
+  return childNodes;
+}

package/src/node/markdown/division.js

@@ -6,10 +6,9 @@ import MarkdownNode from "../../node/markdown";
 import ContentsListMarkdownNode from "../../node/markdown/contentsList";
 import FootnotesListMarkdownNode from "../../node/markdown/footnotesList";
 
-import { nestNodes } from "../../utilities/contents";
-import { replaceTokens } from "../../utilities/tokens";
 import { renumberLinkMarkdownNodes } from "../../utilities/footnotes";
-import { headingMarkdownNodesFromNode, contentsMarkdownNodeFromNode, footnotesMarkdownNodesFromNode } from "../../utilities/query";
+import { replaceNode, replaceTokens } from "../../utilities/replace";
+import { ignoreMarkdownNodeFromNode, headingMarkdownNodesFromNode, contentsMarkdownNodeFromNode, footnotesMarkdownNodesFromNode } from "../../utilities/query";
 
 const { filter } = arrayUtilities;
 
@@ -34,6 +33,14 @@ export default class DivisionMarkdownNode extends MarkdownNode {
     return className;
   }
 
+  isIgnored() {
+    const node = this,
+          ignoreMarkdownNode = ignoreMarkdownNodeFromNode(node),
+          ignored = (ignoreMarkdownNode !== null);
+
+    return ignored;
+  }
+
   findParentNode(childNode, node = this) {
     let parentNode = null;
 
@@ -63,53 +70,48 @@ export default class DivisionMarkdownNode extends MarkdownNode {
   }
 
   createContents(context) {
+    let contentsCreated = false;
+
     const node = this,  ///
           contentsMarkdownNode = contentsMarkdownNodeFromNode(node);
 
-    if (contentsMarkdownNode === null) {
-      return;
-    }
+    if (contentsMarkdownNode !== null) {
+      const headingMarkdownNodes = headingMarkdownNodesFromNode(node),
+            minimumPosition = contentsMarkdownNode.minimumPosition(context),
+            maximumLevel = contentsMarkdownNode.maximumLevel(context);
 
-    const headingMarkdownNodes = headingMarkdownNodesFromNode(node),
-          minimumPosition = contentsMarkdownNode.minimumPosition(context),
-          maximumLevel = contentsMarkdownNode.maximumLevel(context);
+      filter(headingMarkdownNodes, (headingMarkdownNode) => {
+        const level = headingMarkdownNode.getLevel(),
+              position = headingMarkdownNode.position(context);
 
-    filter(headingMarkdownNodes, (headingMarkdownNode) => {
-      const level = headingMarkdownNode.getLevel(),
-            position = headingMarkdownNode.position(context);
+        if ((level <= maximumLevel) && (position > minimumPosition)) {
+          return true;
+        }
+      });
 
-      if ((level <= maximumLevel) && (position > minimumPosition)) {
-        return true;
-      }
-    });
+      const headingMarkdownNodesLength = headingMarkdownNodes.length;
 
-    const headingMarkdownNodesLength = headingMarkdownNodes.length;
-
-    if (headingMarkdownNodesLength === 0) {
-      return;
-    }
-
-    const nodes = headingMarkdownNodes, ///
-          nestedNode = nestNodes(nodes),
-          childNestedNodes = nestedNode.getChildNestedNodes(),
-          replacementTokens = [],
-          nestedHeadingMarkdownNodes = childNestedNodes;  ///
+      if (headingMarkdownNodesLength === 0) {
+        return;
+      }
 
-    Object.assign(context, {
-      replacementTokens
-    });
+      const {tokens} = context,
+            contentsListMarkdownNode = ContentsListMarkdownNode.fromHeadingMarkdownNodes(headingMarkdownNodes, context),
+            contentsListMarkdownNodeTokens = contentsListMarkdownNode.getTokens(),
+            childNode = contentsMarkdownNode,  ///
+            parentNode = this.findParentNode(childNode),
+            replacedNode = contentsMarkdownNode, ///
+            replacementNode = contentsListMarkdownNode,  ///
+            replacementTokens = contentsListMarkdownNodeTokens; ///
 
-    const contentsListMarkdownNode = ContentsListMarkdownNode.fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
-          childNode = contentsMarkdownNode,  ///
-          parentNode = this.findParentNode(childNode),
-          replacedChildNode = contentsMarkdownNode,  ///
-          replacementChildNode = contentsListMarkdownNode; ///
+      replaceNode(replacementNode, replacedNode, parentNode);
 
-    parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+      replaceTokens(replacementTokens, replacedNode, tokens);
 
-    replaceTokens(replacedChildNode, replacementTokens, context);
+      contentsCreated = true;
+    }
 
-    delete context.replacementTokens;
+    return contentsCreated;
   }
 
   createFootnotes(context) {

package/src/node/markdown/ignore.js

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

package/src/node/markdown/import.js

@@ -4,49 +4,42 @@ import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
 
-import { replaceTokens } from "../../utilities/tokens";
-
-const { fourth } = arrayUtilities;
+const { push, fourth } = arrayUtilities;
 
 export default class ImportMarkdownNode extends MarkdownNode {
-  resolveImports(parentNode, context) {
+  resolveImports(context) {
     let html = null;
 
     const { importer = null } = context;
 
     if (importer !== null) {
-      const { tokens } = context,
-            filePath = this.filePath(context);
+      const filePath = this.filePath(context);
 
       importer(filePath, context);
 
-      const { node: importedNode = null,
-              tokens: importedTokens = null,
-              className: divisionClassName = null } = context;
-
-      Object.assign(context, {
-        tokens
-      });
+      const { importedNode = null,
+              importedTokens = null,
+              importedClassName = null } = context;
 
-      delete context.node;
-      delete context.className;
+      delete context.importedNode;
+      delete context.importedTokens;
+      delete context.importedClassName;
 
       if (importedNode !== null) {
-        const replacedChildNode = this, ///
-              replacementTokens = importedTokens, ///
-              replacementChildNode = importedNode;  ///
-
-        parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+        const { tokens, divisionMarkdownNodes } = context,
+              divisionMarkdownNode = importedNode,  ///
+              divisionClassName = importedClassName,  ///
+              ignored = divisionMarkdownNode.isIgnored();
 
-        replaceTokens(replacedChildNode, replacementTokens, context);
-
-        parentNode = this;  ///
+        divisionMarkdownNode.setDivisionClassName(divisionClassName);
 
-        const divisionMarkdownNode = importedNode;  ///
+        if (!ignored) {
+          push(tokens, importedTokens);
 
-        divisionMarkdownNode.setDivisionClassName(divisionClassName);
+          divisionMarkdownNodes.push(divisionMarkdownNode);
+        }
 
-        divisionMarkdownNode.resolveImports(parentNode, context);
+        divisionMarkdownNode.resolveImports(context);
       }
     }
 

package/src/node/markdown/link.js

@@ -70,6 +70,8 @@ export default class LinkMarkdownNode extends MarkdownNode {
     this.addDOMElement(domElement);
   }
 
+  clone() { return super.clone(this.number); }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) {
     const number = null,
           linkMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(LinkMarkdownNode, ruleName, childNodes, opacity, number);

package/src/node/markdown.js

@@ -94,9 +94,7 @@ class MarkdownNode extends NonTerminalNode {
     return attributeValue;
   }
 
-  resolveImports(parentNode, context) {
-    parentNode = this;  ///\
-
+  resolveImports(context) {
     const childNodes = this.getChildNodes();
 
     childNodes.forEach((childNode) => {
@@ -106,7 +104,7 @@ class MarkdownNode extends NonTerminalNode {
         const nonTerminalNode = childNode,  ///
               markdownNode = nonTerminalNode; ///
 
-        markdownNode.resolveImports(parentNode, context);
+        markdownNode.resolveImports(context);
       }
     });
   }

package/src/nodeMap.js

@@ -8,6 +8,7 @@ import ErrorMarkdownNode from "./node/markdown/error";
 import AnchorMarkdownNode from "./node/markdown/anchor";
 import MarkerMarkdownNode from "./node/markdown/marker";
 import BulletMarkdownNode from "./node/markdown/bullet";
+import IgnoreMarkdownNode from "./node/markdown/ignore";
 import ImportMarkdownNode from "./node/markdown/import";
 import ImportsMarkdownNode from "./node/markdown/imports";
 import ContentsMarkdownNode from "./node/markdown/contents";
@@ -61,6 +62,7 @@ import { LINK_RULE_NAME,
          ANCHOR_RULE_NAME,
          MARKER_RULE_NAME,
          BULLET_RULE_NAME,
+         IGNORE_RULE_NAME,
          IMPORT_RULE_NAME,
          IMPORTS_RULE_NAME,
          CONTENTS_RULE_NAME,
@@ -115,6 +117,7 @@ const nodeMap = {
   [ANCHOR_RULE_NAME]: AnchorMarkdownNode,
   [MARKER_RULE_NAME]: MarkerMarkdownNode,
   [BULLET_RULE_NAME]: BulletMarkdownNode,
+  [IGNORE_RULE_NAME]: IgnoreMarkdownNode,
   [IMPORT_RULE_NAME]: ImportMarkdownNode,
   [IMPORTS_RULE_NAME]: ImportsMarkdownNode,
   [CONTENTS_RULE_NAME]: ContentsMarkdownNode,

package/src/ruleNames.js

@@ -8,6 +8,7 @@ export const ERROR_RULE_NAME = "error";
 export const ANCHOR_RULE_NAME = "anchor";
 export const MARKER_RULE_NAME = "marker";
 export const BULLET_RULE_NAME = "bullet";
+export const IGNORE_RULE_NAME = "ignore";
 export const IMPORT_RULE_NAME = "import";
 export const IMPORTS_RULE_NAME = "imports";
 export const CONTENTS_RULE_NAME = "contents";
@@ -65,6 +66,7 @@ const ruleNames = {
   ANCHOR_RULE_NAME,
   MARKER_RULE_NAME,
   BULLET_RULE_NAME,
+  IGNORE_RULE_NAME,
   IMPORT_RULE_NAME,
   IMPORTS_RULE_NAME,
   CONTENTS_RULE_NAME,

package/src/style/selector.js

@@ -5,6 +5,7 @@ import elementMap from "../elementMap";
 
 import { nodeQuery } from "../utilities/query";
 import { EMPTY_STRING } from "../constants";
+import { DIVISION_RULE_NAME } from "../ruleNames";
 import { remainingContentFromNodeTokensAndOffset } from "../utilities/content";
 
 const { STRONG_TEXT_RULE_NAME,
@@ -62,47 +63,52 @@ function contentFromNodeAndTokens(node, tokens) {
   const ruleNameTerminalNode = ruleNameTerminalNodeQuery(node);
 
   if (ruleNameTerminalNode !== null) {
-    content = EMPTY_STRING;
-
     const ruleNameTerminalNodeContent = ruleNameTerminalNode.getContent(),
-          ruleName = ruleNameTerminalNodeContent, ///
-          ruleNameValuesIncludesRuleName = ruleNameValues.includes(ruleName);
+          ruleName = ruleNameTerminalNodeContent; ///
 
-    if (ruleNameValuesIncludesRuleName) {
-      const { tagName, className } = elementMap[ruleName];
+    if (ruleName === DIVISION_RULE_NAME) {
+      content = null;
+    } else {
+      content = EMPTY_STRING;
 
-      if (tagName !== null) {
-        content = `${content}${tagName}`;
-      }
+      const ruleNameValuesIncludesRuleName = ruleNameValues.includes(ruleName);
 
-      switch (ruleName) {
-        case ORDERED_LIST_ITEM_RULE_NAME: {
-          content = `${orderedListTagName} > ${content}`;
+      if (ruleNameValuesIncludesRuleName) {
+        const { tagName, className } = elementMap[ruleName];
 
-          break;
+        if (tagName !== null) {
+          content = `${content}${tagName}`;
         }
 
-        case UNORDERED_LIST_ITEM_RULE_NAME: {
-          content = `${unorderedListTagName} > ${content}`;
+        switch (ruleName) {
+          case ORDERED_LIST_ITEM_RULE_NAME: {
+            content = `${orderedListTagName} > ${content}`;
 
-          break;
-        }
+            break;
+          }
+
+          case UNORDERED_LIST_ITEM_RULE_NAME: {
+            content = `${unorderedListTagName} > ${content}`;
+
+            break;
+          }
 
-        case STRONGLY_EMPHASISED_TEXT_RULE_NAME: {
-          content = `${content} > ${strongTextTagName}`;
+          case STRONGLY_EMPHASISED_TEXT_RULE_NAME: {
+            content = `${content} > ${strongTextTagName}`;
 
-          break;
+            break;
+          }
         }
-      }
 
-      if (className !== null) {
-        content = `${content}.${className}`;
-      }
+        if (className !== null) {
+          content = `${content}.${className}`;
+        }
 
-      const offset = 1,
-            remainingContent = remainingContentFromNodeTokensAndOffset(node, tokens, offset);
+        const offset = 1,
+              remainingContent = remainingContentFromNodeTokensAndOffset(node, tokens, offset);
 
-      content = `${content}${remainingContent}`;
+        content = `${content}${remainingContent}`;
+      }
     }
   } else {
     const offset = 0,

package/src/utilities/query.js

@@ -6,6 +6,7 @@ import { arrayUtilities } from "necessary";
 const { first, push } = arrayUtilities;
 
 const linkMarkdownNodesQuery = Query.fromExpression(`//link`),
+      ignoreMarkdownNodeQuery = Query.fromExpression(`//ignore`),
       headingMarkdownNodesQuery = Query.fromExpression(`//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading`),
       contentsMarkdownNodeQuery = Query.fromExpression(`//contents`),
       footnoteMarkdownNodesQuery = Query.fromExpression(`//footnote`),
@@ -49,6 +50,12 @@ export function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
   return linkMarkdownNodes;
 }
 
+export function ignoreMarkdownNodeFromNode(node) {
+  const ignoreMarkdownNode = nodeFromNodeAndQuery(node, ignoreMarkdownNodeQuery);
+
+  return ignoreMarkdownNode;
+}
+
 export function contentsMarkdownNodeFromNode(node) {
   const contentsMarkdownNode = nodeFromNodeAndQuery(node, contentsMarkdownNodeQuery);
 
@@ -93,6 +100,7 @@ export function linkReferenceOrFootnotesMarkdownNodesFromNode(node, linkReferenc
 
 export default {
   linkMarkdownNodesFromNode,
+  ignoreMarkdownNodeFromNode,
   contentsMarkdownNodeFromNode,
   footnotesMarkdownNodeFromNode,
   headingMarkdownNodesFromNode,

package/src/utilities/{tokens.js → replace.js}

@@ -1,8 +1,14 @@
 "use strict";
 
-export function replaceTokens(replacedChildNode, replacementTokens, context) {
-  const { tokens } = context,
-        nonTerminalNode = replacedChildNode,  ///
+export function replaceNode(replacementNode, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNode = replacementNode; ///
+
+  parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+}
+
+export function replaceTokens(replacementTokens, replacedNode, tokens) {
+  const nonTerminalNode = replacedNode,  ///
         lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
         firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
         lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),