highmark-markdown 0.0.383 → 0.0.388

package/src/replacement.js

@@ -1,6 +1,11 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import { leadingIndexFromNodeAndTokens, trailingIndexFromNodeAndTokens } from "./utilities/node";
+import { removeNode, appendNode, removeTokens, appendTokens, replaceNode, replaceNodes, replaceTokens } from "./utilities/replacement";
+
+const { push } = arrayUtilities;
 
 export default class Replacement {
   constructor(node, tokens) {
@@ -12,110 +17,156 @@ export default class Replacement {
     return this.node;
   }
 
-  getTokens() {
+  getTokens(tokens = []) {
+    push(tokens, this.tokens);
+
     return this.tokens;
   }
 
   getChildNodes() { return this.node.getChildNodes(); }
 
-  contract(descendentNode) {
+  contract(Class, descendentNode) {
+    if (descendentNode === undefined) {
+      descendentNode = Class; ///
+
+      Class = Replacement;  ///
+    }
+
     const node = descendentNode,  ///
           tokens = this.tokens, ///
           context = { ///
             tokens
           },
-          replacement = Replacement.fromNode(node, context);  ///
+          replacement = Class.fromNode(node, context);  ///
 
     return replacement;
   }
 
-  expand(ascendantNode) {
+  expand(Class, ascendantNode) {
+    if (ascendantNode === undefined) {
+      ascendantNode = Class;
+
+      Class = Replacement;  ///
+    }
+
     const node = ascendantNode, ///
           tokens = this.tokens, ///
           context = {
             tokens
           },
-          replacement = Replacement.fromNode(node, context);  ///
+          replacement = Class.fromNode(node, context);  ///
 
     return replacement;
   }
 
-  clone() {
-    const node = this.node.clone(),
-          replacementTokens = replacementTokensFromNodeAndTokens(node, this.tokens);
+  appendTo(parentNode, context) {
+    const { tokens } = context,
+          replacementNode = this.node,  ///
+          replacementTokens = this.tokens;  ///
 
-    replaceNodeTokens(node, replacementTokens, this.tokens);
+    appendNode(replacementNode, parentNode);
 
-    const tokens = replacementTokens, ///
-          replacement = new Replacement(node, tokens);
+    appendTokens(replacementTokens, parentNode, tokens);
+  }
 
-    return replacement
+  replace(replacedNode, parentNode, context) {
+    const { tokens } = context,
+          replacementNode = this.node, ///
+          replacementTokens = this.tokens; ///
+
+    replaceNode(replacementNode, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
   }
 
-  appendTo(markdownNode, context) {
+  replaceEx(replacedNode, parentNode, context) {
     const { tokens } = context,
-          node = markdownNode, ///
-          trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
-          replacement = this.clone(),  ///
-          replacementNode = replacement.getNode(),
-          replacementTokens = replacement.getTokens(),
-          childNode = replacementNode, ///
-          start = trailingIndex + 1,
-          deleteCount = 0;
-
-    markdownNode.appendChildNode(childNode);
-
-    tokens.splice(start, deleteCount, ...replacementTokens);
+          replacementChildNodes = this.getChildNodes(), ///
+          replacementTokens = this.tokens,  ///
+          replacementNodes = replacementChildNodes; ///
+
+    replaceNodes(replacementNodes, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
   }
 
-  static fromNode(node, context) {
+  removeFrom(removedNode, parentNode, context) {
+    const { tokens } = context;
+
+    removeTokens(removedNode, tokens);
+
+    removeNode(removedNode, parentNode);
+  }
+
+  clone(...remainingArguments) {
+    const node = this.node.clone(),
+          clonedTokens = clonedTokensFromNodeAndTokens(node, this.tokens);
+
+    overwriteNodeTokens(node, clonedTokens, this.tokens);
+
+    const Class = this.constructor,
+          tokens = clonedTokens, ///
+          replacement = new Class(node, tokens, ...remainingArguments);
+
+    return replacement
+  }
+
+  static fromNode(Class, node, context, ...remainingArguments) {
+    if (context === undefined) {
+      context = node; ///
+
+      node = Class; ///
+
+      Class = Replacement;  ///
+    }
+
     let { tokens } = context;
 
-    const replacementTokens = replacementTokensFromNodeAndTokens(node, tokens),
+    const clonedTokens = clonedTokensFromNodeAndTokens(node, tokens),
           leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
           offset = leadingIndex;  ///
 
     node = node.clone();  ///
 
-    replaceNodeTokens(node, replacementTokens, tokens, offset);
+    overwriteNodeTokens(node, clonedTokens, tokens, offset);
 
-    tokens = replacementTokens; ///
+    tokens = clonedTokens; ///
 
-    const replacement = new Replacement(node, tokens);
+    const replacement = new Class(node, tokens, ...remainingArguments);
 
     return replacement;
   }
 
-  static fromNodeAndTokens(node, tokens) {
-    const replacement = new Replacement(node, tokens);
+  static fromNodeAndTokens(Class, node, tokens, ...remainingArguments) {
+    if (tokens === undefined) {
+      tokens = node;  ///
+
+      node = Class; ///
+
+      Class = Replacement;  ///
+    }
+
+    const replacement = new Class(node, tokens, ...remainingArguments);
 
     return replacement;
   }
 }
 
-function replaceNodeTokens(node, replacementTokens, tokens, offset = 0) {
+function overwriteNodeTokens(node, clonedTokens, tokens, offset = 0) {
   const nodeTerminalNode = node.isTerminalNode();
 
   if (nodeTerminalNode) {
     const terminalNode = node;  ///
 
-    replaceTerminalNodeTokens(terminalNode, replacementTokens, tokens, offset);
+    overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset);
   } else {
     const nonTerminalNode = node;  ///
 
-    replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, tokens, offset);
+    overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset);
   }
 }
 
-function replaceChildNodesTokens(childNodes, replacementTokens, tokens, offset) {
-  childNodes.forEach((childNode) => {
-    const node = childNode; ///
-
-    replaceNodeTokens(node, replacementTokens, tokens, offset);
-  });
-}
-
-function replaceTerminalNodeTokens(terminalNode, replacementTokens, tokens, offset) {
+function overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset) {
   let index,
       significantToken;
 
@@ -126,21 +177,25 @@ function replaceTerminalNodeTokens(terminalNode, replacementTokens, tokens, offs
 
     index -= offset;
 
-    const replacementToken = replacementTokens[index];
+    const clonedToken = clonedTokens[index];
 
-    significantToken = replacementToken;  ///
+    significantToken = clonedToken;  ///
 
     terminalNode.setSignificantToken(significantToken);
   }
 }
 
-function replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, tokens, offset) {
+function overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset) {
   const childNodes = nonTerminalNode.getChildNodes();
 
-  replaceChildNodesTokens(childNodes, replacementTokens, tokens, offset);
+  childNodes.forEach((childNode) => {
+    const node = childNode; ///
+
+    overwriteNodeTokens(node, clonedTokens, tokens, offset);
+  });
 }
 
-function replacementTokensFromNodeAndTokens(node, tokens) {
+function clonedTokensFromNodeAndTokens(node, tokens) {
   const leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
         trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
         start = leadingIndex,  ///
@@ -148,11 +203,11 @@ function replacementTokensFromNodeAndTokens(node, tokens) {
 
   tokens = tokens.slice(start, end);  ///
 
-  const replacementTokens = tokens.map((token) => {  ///
-    const replacementToken = token.clone();  ///;
+  const clonedTokens = tokens.map((token) => {  ///
+    const clonedToken = token.clone();
 
-    return replacementToken;
+    return clonedToken;
   });
 
-  return replacementTokens;
+  return clonedTokens;
 }

package/src/ruleNames.js

@@ -28,7 +28,7 @@ export const BLOCK_LISTING_RULE_NAME = "blockListing";
 export const CONTENTS_LINK_RULE_NAME = "contentsLink";
 export const CONTENTS_ITEM_RULE_NAME = "contentsItem";
 export const CONTENTS_LIST_RULE_NAME = "contentsList";
-export const FOOTNOTE_ITEM_RULE_NAME = "footnoteItem";
+export const FOOTNOTES_ITEM_RULE_NAME = "footnotesItem";
 export const TABLE_HEAD_ROW_RULE_NAME = "tableHeadRow";
 export const TABLE_BODY_ROW_RULE_NAME = "tableBodyRow";
 export const INLINE_LISTING_RULE_NAME = "inlineListing";
@@ -84,7 +84,7 @@ const ruleNames = {
   CONTENTS_LINK_RULE_NAME,
   CONTENTS_ITEM_RULE_NAME,
   CONTENTS_LIST_RULE_NAME,
-  FOOTNOTE_ITEM_RULE_NAME,
+  FOOTNOTES_ITEM_RULE_NAME,
   TABLE_HEAD_ROW_RULE_NAME,
   TABLE_BODY_ROW_RULE_NAME,
   INLINE_LISTING_RULE_NAME,

package/src/utilities/markdown.js

@@ -2,14 +2,10 @@
 
 import { arrayUtilities } from "necessary";
 
-const { clear, first, push } = arrayUtilities;
+const { clear, push } = arrayUtilities;
 
 export function postprocess(divisionMarkdownNode, context) {
-  const divisionMarkdownNodes = [
-    divisionMarkdownNode
-  ];
-
-  resolveIncludes(divisionMarkdownNodes, context);
+  const divisionMarkdownNodes = resolveIncludes(divisionMarkdownNode, context);
 
   resolveEmbeddings(divisionMarkdownNodes, context);
 
@@ -30,9 +26,13 @@ function createContents(divisionMarkdownNodes, context) {
   });
 }
 
-function resolveIncludes(divisionMarkdownNodes, context) {
-  const firstDivisionMarkdownNode = first(divisionMarkdownNodes),
-        divisionMarkdownNode = firstDivisionMarkdownNode; ///
+function resolveIncludes(divisionMarkdownNode, context) {
+  const divisionMarkdownNodes = [],
+        divisionMarkdownNodeIgnored = divisionMarkdownNode.isIgnored();
+
+  if (!divisionMarkdownNodeIgnored) {
+    divisionMarkdownNodes.push(divisionMarkdownNode);
+  }
 
   Object.assign(context, {
     divisionMarkdownNodes

package/src/utilities/node.js

@@ -4,54 +4,6 @@ import { arrayUtilities } from "necessary";
 
 const { forwardsSome, backwardsSome } = arrayUtilities;
 
-export function removeNode(removedNode, parentNode) {
-  const removedChildNode = removedNode; ///
-
-  parentNode.removeChildNode(removedChildNode);
-}
-
-export function removeNodes(removedNodes, parentNode) {
-  const removedChildNodes = removedNodes; ///
-
-  parentNode.removeChildNodes(removedChildNodes);
-}
-
-export function removeTokens(removedNode, tokens) {
-  const nonTerminalNode = removedNode,  ///
-        leadingIndex = leadingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens),
-        trailingIndex = trailingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens),
-        start = leadingIndex, ///
-        end = trailingIndex + 1,
-        deleteCount = end - start;
-
-  tokens.splice(start, deleteCount);
-}
-
-export function replaceNode(replacementNode, replacedNode, parentNode) {
-  const replacedChildNode = replacedNode,  ///
-        replacementChildNode = replacementNode; ///
-
-  parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
-}
-
-export function replaceNodes(replacementNodes, replacedNode, parentNode) {
-  const replacedChildNode = replacedNode,  ///
-        replacementChildNodes = replacementNodes; ///
-
-  parentNode.replaceChildNodes(replacedChildNode, replacementChildNodes);
-}
-
-export function replaceTokens(replacementTokens, replacedNode, tokens) {
-  const nonTerminalNode = replacedNode,  ///
-        leadingIndex = leadingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens),
-        trailingIndex = trailingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens),
-        start = leadingIndex, ///
-        end = trailingIndex + 1,
-        deleteCount = end - start;
-
-  tokens.splice(start, deleteCount, ...replacementTokens);
-}
-
 export function leadingIndexFromNodeAndTokens(node, tokens) {
   let leadingIndex;
 

package/src/utilities/replacement.js

@@ -0,0 +1,66 @@
+"use strict";
+
+import { leadingIndexFromNodeAndTokens, trailingIndexFromNodeAndTokens } from "../utilities/node";
+
+export function appendNode(replacementNode, parentNode) {
+  const childNode = replacementNode;  ///
+
+  parentNode.appendChildNode(childNode);
+}
+
+export function removeNode(removedNode, parentNode) {
+  const removedChildNode = removedNode; ///
+
+  parentNode.removeChildNode(removedChildNode);
+}
+
+export function removeNodes(removedNodes, parentNode) {
+  const removedChildNodes = removedNodes; ///
+
+  parentNode.removeChildNodes(removedChildNodes);
+}
+
+export function replaceNode(replacementNode, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNode = replacementNode; ///
+
+  parentNode.replaceChildNode(replacedChildNode, replacementChildNode);
+}
+
+export function replaceNodes(replacementNodes, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNodes = replacementNodes; ///
+
+  parentNode.replaceChildNodes(replacedChildNode, replacementChildNodes);
+}
+
+export function appendTokens(replacementTokens, parentNode, tokens) {
+  const node = parentNode, ///
+        trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
+        start = trailingIndex + 1,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...replacementTokens);
+}
+
+export function removeTokens(removedNode, tokens) {
+  const node = removedNode,  ///
+        leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
+        trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
+        start = leadingIndex, ///
+        end = trailingIndex + 1,
+        deleteCount = end - start;
+
+  tokens.splice(start, deleteCount);
+}
+
+export function replaceTokens(replacementTokens, replacedNode, tokens) {
+  const node = replacedNode,  ///
+        leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
+        trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
+        start = leadingIndex, ///
+        end = trailingIndex + 1,
+        deleteCount = end - start;
+
+  tokens.splice(start, deleteCount, ...replacementTokens);
+}