highmark-markdown 0.0.379 → 0.0.382

package/src/replacement.js

@@ -0,0 +1,158 @@
+"use strict";
+
+import { leadingIndexFromNodeAndTokens, trailingIndexFromNodeAndTokens } from "./utilities/node";
+
+export default class Replacement {
+  constructor(node, tokens) {
+    this.node = node;
+    this.tokens = tokens;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getChildNodes() { return this.node.getChildNodes(); }
+
+  contract(descendentNode) {
+    const node = descendentNode,  ///
+          tokens = this.tokens, ///
+          context = { ///
+            tokens
+          },
+          replacement = Replacement.fromNode(node, context);  ///
+
+    return replacement;
+  }
+
+  expand(ascendantNode) {
+    const node = ascendantNode, ///
+          tokens = this.tokens, ///
+          context = {
+            tokens
+          },
+          replacement = Replacement.fromNode(node, context);  ///
+
+    return replacement;
+  }
+
+  clone() {
+    const node = this.node.clone(),
+          replacementTokens = replacementTokensFromNodeAndTokens(node, this.tokens);
+
+    replaceNodeTokens(node, replacementTokens, this.tokens);
+
+    const tokens = replacementTokens, ///
+          replacement = new Replacement(node, tokens);
+
+    return replacement
+  }
+
+  appendTo(markdownNode, 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);
+  }
+
+  static fromNode(node, context) {
+    let { tokens } = context;
+
+    const replacementTokens = replacementTokensFromNodeAndTokens(node, tokens),
+          leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
+          offset = leadingIndex;  ///
+
+    node = node.clone();  ///
+
+    replaceNodeTokens(node, replacementTokens, tokens, offset);
+
+    tokens = replacementTokens; ///
+
+    const replacement = new Replacement(node, tokens);
+
+    return replacement;
+  }
+
+  static fromNodeAndTokens(node, tokens) {
+    const replacement = new Replacement(node, tokens);
+
+    return replacement;
+  }
+}
+
+function replaceNodeTokens(node, replacementTokens, tokens, offset = 0) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    replaceTerminalNodeTokens(terminalNode, replacementTokens, tokens, offset);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, 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) {
+  let index,
+      significantToken;
+
+  significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken !== null) {
+    index = tokens.indexOf(significantToken);
+
+    index -= offset;
+
+    const replacementToken = replacementTokens[index];
+
+    significantToken = replacementToken;  ///
+
+    terminalNode.setSignificantToken(significantToken);
+  }
+}
+
+function replaceNonTerminalNodeTokens(nonTerminalNode, replacementTokens, tokens, offset) {
+  const childNodes = nonTerminalNode.getChildNodes();
+
+  replaceChildNodesTokens(childNodes, replacementTokens, tokens, offset);
+}
+
+function replacementTokensFromNodeAndTokens(node, tokens) {
+  const leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
+        trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
+        start = leadingIndex,  ///
+        end = trailingIndex + 1;
+
+  tokens = tokens.slice(start, end);  ///
+
+  const replacementTokens = tokens.map((token) => {  ///
+    const replacementToken = token.clone();  ///;
+
+    return replacementToken;
+  });
+
+  return replacementTokens;
+}

package/src/utilities/childNodes.js

@@ -82,11 +82,13 @@ export function plainTextFromChildNodes(childNodes, context) {
           plainTexts.push(plainText);
         }
 
-        const childNodes = markdownNode.getChildNodes(),
-              plainText = plainTextFromChildNodes(childNodes, context);
+        {
+          const childNodes = markdownNode.getChildNodes(),
+                plainText = plainTextFromChildNodes(childNodes, context);
 
-        if (plainText !== EMPTY_STRING) {
-          plainTexts.push(plainText);
+          if (plainText !== EMPTY_STRING) {
+            plainTexts.push(plainText);
+          }
         }
       }
     }

package/src/utilities/content.js

@@ -4,6 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import { EMPTY_STRING } from "../constants";
 import { ESCAPED_TOKEN_TYPE } from "../tokenTypes";
+import { leadingIndexFromNodeAndTokens, trailingIndexFromNodeAndTokens } from "../utilities/node";
 
 const { first, last } = arrayUtilities;
 
@@ -12,13 +13,10 @@ export function contentFromNode(node, context) {
 
   let { tokens } = context;
 
-  const lastSignificantToken = node.getLastSignificantToken(),
-        firstSignificantToken = node.getFirstSignificantToken(),
-        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
-        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken);
-
-  const start = firstSignificantTokenIndex,  ///
-        end = lastSignificantTokenIndex + 1;
+  const leadingIndex = leadingIndexFromNodeAndTokens(node, tokens),
+        trailingIndex = trailingIndexFromNodeAndTokens(node, tokens),
+        start = leadingIndex,  ///
+        end = trailingIndex + 1;
 
   tokens = tokens.slice(start, end);
 
@@ -38,13 +36,11 @@ export function contentFromNodes(nodes, augmentLeft, augmentRight, context) {
 
   const lastNode = last(nodes),
         firstNode = first(nodes),
-        lastSignificantToken = lastNode.getLastSignificantToken(),
-        firstSignificantToken = firstNode.getFirstSignificantToken(),
-        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
-        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken);
+        leadingIndex = leadingIndexFromNodeAndTokens(firstNode, tokens),
+        trailingIndex = trailingIndexFromNodeAndTokens(lastNode, tokens);
 
-  let firstTokenIndex = firstSignificantTokenIndex,  ///
-      lastTokenIndex = lastSignificantTokenIndex; ///
+  let firstTokenIndex = leadingIndex,  ///
+      lastTokenIndex = trailingIndex; ///
 
   if (augmentLeft) {
     const previousTokenIndex = firstTokenIndex - 1;
@@ -91,14 +87,10 @@ export function contentFromNodes(nodes, augmentLeft, augmentRight, context) {
 export function contentFromNodeAndTokens(node, tokens, offset = 0) {
   let content = EMPTY_STRING;
 
-  const firstSignificantToken = node.getFirstSignificantToken(),
-        lastSignificantToken = node.getLastSignificantToken(),
-        firstToken = firstSignificantToken, ///
-        lastToken = lastSignificantToken, ///
-        firstTokenIndex = tokens.indexOf(firstToken) + offset,  ///
-        lastTokenIndex = tokens.indexOf(lastToken);
+  const leadingIndex = leadingIndexFromNodeAndTokens(node, tokens) + offset,
+        trailingIndex = trailingIndexFromNodeAndTokens(node, tokens);
 
-  for (let index = firstTokenIndex; index <= lastTokenIndex; index++) {
+  for (let index = leadingIndex; index <= trailingIndex; index++) {
     const token = tokens[index],
           tokenContent = token.getContent();
 

package/src/utilities/markdown.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { clear, first, push } = arrayUtilities;
+
+export function postprocess(divisionMarkdownNode, context) {
+  const divisionMarkdownNodes = [
+    divisionMarkdownNode
+  ];
+
+  resolveIncludes(divisionMarkdownNodes, context);
+
+  resolveEmbeddings(divisionMarkdownNodes, context);
+
+  paginateAndFootnotes(divisionMarkdownNodes, context);
+
+  createContents(divisionMarkdownNodes, context);
+
+  return divisionMarkdownNodes;
+}
+
+function createContents(divisionMarkdownNodes, context) {
+  divisionMarkdownNodes.some((divisionMarkdownNode) => {
+    const contentsCreated = divisionMarkdownNode.createContents(context);
+
+    if (contentsCreated) {
+      return true;
+    }
+  });
+}
+
+function resolveIncludes(divisionMarkdownNodes, context) {
+  const firstDivisionMarkdownNode = first(divisionMarkdownNodes),
+        divisionMarkdownNode = firstDivisionMarkdownNode; ///
+
+  Object.assign(context, {
+    divisionMarkdownNodes
+  });
+
+  divisionMarkdownNode.resolveIncludes(context);
+
+  delete context.divisionMarkdownNodes;
+
+  return divisionMarkdownNodes;
+}
+
+function resolveEmbeddings(divisionMarkdownNodes, context) {
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.resolveEmbeddings(context);
+  });
+}
+
+function paginateAndFootnotes(divisionMarkdownNodes, context) {
+  const { linesPerPage = null } = context;
+
+  const footnoteNumberMap = {};
+
+  Object.assign(context, {
+    footnoteNumberMap
+  });
+
+  let pageNumber = 1;
+
+  if (linesPerPage === null) {
+    divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+      const footnoteReplacements = divisionMarkdownNode.prepareFootnotes(context);
+
+      divisionMarkdownNode.setPageNumber(pageNumber);
+
+      divisionMarkdownNode.createFootnotes(footnoteReplacements, context);
+
+      pageNumber++;
+    });
+  } else {
+    const paginatedDivisionMarkdownNodes = [];
+
+    divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+      const footnoteReplacements = divisionMarkdownNode.prepareFootnotes(context),
+            divisionMarkdownNodes = divisionMarkdownNode.paginate(context);
+
+      divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+        divisionMarkdownNode.setPageNumber(pageNumber);
+
+        divisionMarkdownNode.createFootnotes(footnoteReplacements, context);
+
+        pageNumber++;
+      });
+
+      push(paginatedDivisionMarkdownNodes, divisionMarkdownNodes);
+    });
+
+    clear(divisionMarkdownNodes);
+
+    push(divisionMarkdownNodes, paginatedDivisionMarkdownNodes);
+  }
+
+  delete context.footnoteNumberMap;
+}
+
+export default {
+  postprocess
+};

package/src/utilities/node.js

@@ -0,0 +1,158 @@
+"use strict";
+
+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;
+
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    leadingIndex = leadingIndexFromTerminalNodeAndTokens(terminalNode, tokens);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    leadingIndex = leadingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens);
+  }
+
+  return leadingIndex;
+}
+
+export function trailingIndexFromNodeAndTokens(node, tokens) {
+  let trailingIndex;
+
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    trailingIndex = trailingIndexFromTerminalNodeAndTokens(terminalNode, tokens);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    trailingIndex = trailingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens);
+  }
+
+  return trailingIndex;
+}
+
+function leadingIndexFromTerminalNodeAndTokens(terminalNode, tokens) {
+  let leadingIndex;
+
+  const significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken === null) {
+    leadingIndex = -1;
+  } else {
+    const significantTokenIndex = tokens.indexOf(significantToken);
+
+    leadingIndex = significantTokenIndex; ///
+  }
+
+  return leadingIndex;
+}
+
+function trailingIndexFromTerminalNodeAndTokens(terminalNode, tokens) {
+  let trailingIndex;
+
+  const significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken === null) {
+    trailingIndex = -1;
+  } else {
+    const significantTokenIndex = tokens.indexOf(significantToken);
+
+    trailingIndex = significantTokenIndex; ///
+  }
+
+  return trailingIndex;
+}
+
+function leadingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens) {
+  let leadingIndex;
+
+  const childNodes = nonTerminalNode.getChildNodes();
+
+  forwardsSome(childNodes, (childNode) => {
+    const node = childNode;
+
+    leadingIndex = leadingIndexFromNodeAndTokens(node, tokens);
+
+    if (leadingIndex !== -1) {
+      return true;
+    }
+  });
+
+  return leadingIndex;
+}
+
+function trailingIndexFromNonTerminalNodeAndTokens(nonTerminalNode, tokens) {
+  let trailingIndex;
+
+  const childNodes = nonTerminalNode.getChildNodes();
+
+  backwardsSome(childNodes, (childNode) => {
+    const node = childNode;
+
+    trailingIndex = trailingIndexFromNodeAndTokens(node, tokens);
+
+    if (trailingIndex !== -1) {
+      return true;
+    }
+  });
+
+  return trailingIndex;
+}
+

package/src/utilities/query.js

@@ -5,12 +5,14 @@ import { arrayUtilities } from "necessary";
 
 const { first, push } = arrayUtilities;
 
-const ignoreDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/ignoreDirective"),
+const footnoteMarkdownNodeQuery = Query.fromExpression("//footnote"),
+      ignoreDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/ignoreDirective"),
       contentsDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/contentsDirective"),
       footnotesDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/footnotesDirective"),
+      pageNumberDirectiveMarkdownNodeQuery = Query.fromExpression("//directives/pageNumber"),
       linkMarkdownNodesQuery = Query.fromExpression("//link"),
       headingMarkdownNodesQuery = Query.fromExpression("//primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"),
-      footnoteMarkdownNodesQuery = Query.fromExpression("//footnote"),
+      subDivisionMarkdownNodesQuery = Query.fromExpression("//subDivision"),
       embedDirectiveMarkdownNodesQuery = Query.fromExpression("//directives/embedDirective"),
       includeDirectiveMarkdownNodesQuery = Query.fromExpression("//directives/includeDirective"),
       linkReferenceOrFootnotesDirectiveMarkdownNodesQuery = Query.fromExpression("//link|reference|footnotesDirective");
@@ -44,6 +46,12 @@ export function nodesQuery(expression) {
   }
 }
 
+export function footnoteMarkdownNodsFromNode(node) {
+  const footnoteMarkdownNode = nodeFromNodeAndQuery(node, footnoteMarkdownNodeQuery);
+
+  return footnoteMarkdownNode;
+}
+
 export function ignoreDirectiveMarkdownNodeFromNode(node) {
   const ignoreDirectiveMarkdownNode = nodeFromNodeAndQuery(node, ignoreDirectiveMarkdownNodeQuery);
 
@@ -62,6 +70,12 @@ export function footnotesDirectiveMarkdownNodeFromNode(node) {
   return footnotesDirectiveMarkdownNode;
 }
 
+export function pageNumberDirectiveMarkdownNodeFromNode(node) {
+  const pageNumberDirectiveMarkdownNode = nodeFromNodeAndQuery(node, pageNumberDirectiveMarkdownNodeQuery);
+
+  return pageNumberDirectiveMarkdownNode;
+}
+
 export function linkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
   nodesFromNodeAndQuery(node, linkMarkdownNodesQuery, linkMarkdownNodes);
 
@@ -74,10 +88,10 @@ export function headingMarkdownNodesFromNode(node, headingMarkdownNodes = []) {
   return headingMarkdownNodes;
 }
 
-export function footnoteMarkdownNodesFromNode(node, footnoteMarkdownNodes = []) {
-  nodesFromNodeAndQuery(node, footnoteMarkdownNodesQuery, footnoteMarkdownNodes);
+export function subDivisionMarkdownNodesFromNode(node, subDivisionMarkdownNodes = []) {
+  nodesFromNodeAndQuery(node, subDivisionMarkdownNodesQuery, subDivisionMarkdownNodes);
 
-  return footnoteMarkdownNodes;
+  return subDivisionMarkdownNodes;
 }
 
 export function embedDirectiveMarkdownNodesFromNode(node, embedDirectiveMarkdownNodes = []) {
@@ -99,12 +113,14 @@ export function linkReferenceOrFootnotesDirectiveMarkdownNodesFromNode(node, lin
 }
 
 export default {
+  footnoteMarkdownNodsFromNode,
   ignoreDirectiveMarkdownNodeFromNode,
   contentsDirectiveMarkdownNodeFromNode,
   footnotesDirectiveMarkdownNodeFromNode,
+  pageNumberDirectiveMarkdownNodeFromNode,
   linkMarkdownNodesFromNode,
   headingMarkdownNodesFromNode,
-  footnoteMarkdownNodesFromNode,
+  subDivisionMarkdownNodesFromNode,
   embedDirectiveMarkdownNodesFromNode,
   includeDirectiveMarkdownNodesFromNode,
   linkReferenceOrFootnotesDirectiveMarkdownNodesFromNode