highmark-markdown 1.0.173 → 1.0.174

package/src/replacement/subDivision/indexDirective.js

@@ -1,20 +0,0 @@
-"use strict";
-
-import SubDivisionReplacement from "../../replacement/subDivision";
-
-import { indexDirectiveMarkdownNodeFromNode } from "../../utilities/query";
-
-export default class IndexDirectiveSubDivisionReplacement extends SubDivisionReplacement {
-  static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
-    let indexDirectiveSubDivisionReplacement = null;
-
-    const node = subDivisionMarkdownNode, ///
-          indexDirectiveMarkdownNode = indexDirectiveMarkdownNodeFromNode(node);
-
-    if (indexDirectiveMarkdownNode !== null) {
-      indexDirectiveSubDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(IndexDirectiveSubDivisionReplacement, subDivisionMarkdownNode, context);
-    }
-
-    return indexDirectiveSubDivisionReplacement;
-  }
-}

package/src/replacement/subDivision/pageNumberDirective.js

@@ -1,20 +0,0 @@
-"use strict";
-
-import SubDivisionReplacement from "../../replacement/subDivision";
-
-import { pageNumberDirectiveMarkdownNodeFromNode } from "../../utilities/query";
-
-export default class PageNumberDirectiveSubDivisionReplacement extends SubDivisionReplacement {
-  static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
-    let pageNumberDirectiveSubDivisionReplacement = null;
-
-    const node = subDivisionMarkdownNode, ///
-          pageNumberDirectiveMarkdownNode = pageNumberDirectiveMarkdownNodeFromNode(node);
-
-    if (pageNumberDirectiveMarkdownNode !== null) {
-      pageNumberDirectiveSubDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(PageNumberDirectiveSubDivisionReplacement, subDivisionMarkdownNode, context);
-    }
-
-    return pageNumberDirectiveSubDivisionReplacement;
-  }
-}

package/src/replacement/subDivision.js

@@ -1,41 +0,0 @@
-"use strict";
-
-import Replacement from "../replacement";
-
-export default class SubDivisionReplacement extends Replacement {
-  constructor(node, tokens, subDivisionMarkdownNode) {
-    super(node, tokens);
-
-    this.subDivisionMarkdownNode = subDivisionMarkdownNode;
-  }
-
-  getSubDivisionMarkdownNode() {
-    return this.subDivisionMarkdownNode;
-  }
-
-  appendToDivisionMarkdownNode(divisionMarkdownNode, context) {
-    const parentNode = divisionMarkdownNode;  ///
-
-    super.appendTo(parentNode, context);
-  }
-
-  prependToDivisionMarkdownNode(divisionMarkdownNode, context) {
-    const parentNode = divisionMarkdownNode;  ///
-
-    super.prependTo(parentNode, context);
-  }
-
-  removeFromDivisionMarkdownNode(divisionMarkdownNode, context) {
-    const removedNode = this.subDivisionMarkdownNode, ///
-          parentNode = divisionMarkdownNode;
-
-    super.removeFrom(removedNode, parentNode, context);
-  }
-
-  static fromSubDivisionMarkdownNode(Class, subDivisionMarkdownNode, ...remainingArguments) {
-    const node = subDivisionMarkdownNode, ///
-          subDivisionReplacement = Replacement.fromNode(Class, node, subDivisionMarkdownNode, ...remainingArguments);
-
-    return subDivisionReplacement;
-  }
-}

package/src/replacement.js

@@ -1,185 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import { appendNode,
-         prependNode,
-         removeNode,
-         replaceNode,
-         addNodesAfter,
-         appendTokens,
-         prependTokens,
-         removeTokens,
-         replaceTokens,
-         addTokensAfter,
-         overwriteClonedNodeTokens,
-         clonedTokensFromNodeAndTokens, } from "./utilities/replacement";
-
-const { push } = arrayUtilities;
-
-export default class Replacement {
-  constructor(node, tokens) {
-    this.node = node;
-    this.tokens = tokens;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getTokens(tokens = []) {
-    push(tokens, this.tokens);
-
-    return this.tokens;
-  }
-
-  contract(Class, descendentNode, ...remainingArguments) {
-    if (descendentNode === undefined) {
-      descendentNode = Class; ///
-
-      Class = Replacement;  ///
-    }
-
-    const node = descendentNode,  ///
-          tokens = this.tokens, ///
-          context = { ///
-            tokens
-          },
-          replacement = Class.fromNode(node, ...remainingArguments, context);
-
-    return replacement;
-  }
-
-  expand(Class, ascendantNode, ...remainingArguments) {
-    if (ascendantNode === undefined) {
-      ascendantNode = Class;
-
-      Class = Replacement;  ///
-    }
-
-    const node = ascendantNode, ///
-          tokens = this.tokens, ///
-          context = {
-            tokens
-          },
-          replacement = Class.fromNode(node, ...remainingArguments, context);
-
-    return replacement;
-  }
-
-  appendTo(parentNode, context) {
-    const { tokens } = context,
-          appendedNode = this.node,  ///
-          appendedTokens = this.tokens;  ///
-
-    appendNode(appendedNode, parentNode);
-
-    appendTokens(appendedTokens, parentNode, tokens);
-  }
-
-  prependTo(parentNode, context) {
-    const { tokens } = context,
-          prependedNode = this.node,  ///
-          prependedTokens = this.tokens;  ///
-
-    prependNode(prependedNode, parentNode);
-
-    prependTokens(prependedTokens, parentNode, tokens);
-  }
-
-  addAfter(existingNode, parentNode, context) {
-    const { tokens } = context,
-          markdownNode = this.node, ///
-          removedChildNodes = markdownNode.removeChildNodes(),
-          addedTokens = this.tokens,  ///
-          addedNodes = removedChildNodes;  ///
-
-    addNodesAfter(existingNode, addedNodes, parentNode);
-
-    addTokensAfter(existingNode, addedTokens, tokens);
-  }
-
-  replace(replacedNode, parentNode, context) {
-    const { tokens } = context,
-          replacementNode = this.node, ///
-          replacementTokens = this.tokens; ///
-
-    replaceNode(replacementNode, replacedNode, parentNode);
-
-    replaceTokens(replacementTokens, replacedNode, tokens);
-  }
-
-  removeFrom(removedNode, parentNode, context) {
-    const { tokens } = context;
-
-    removeTokens(removedNode, tokens);
-
-    removeNode(removedNode, parentNode);
-  }
-
-  clone(...remainingArguments) {
-    const clonedNode = this.node.clone(),
-          clonedTokens = clonedTokensFromNodeAndTokens(this.node, this.tokens);
-
-    overwriteClonedNodeTokens(clonedNode, clonedTokens, this.tokens);
-
-    const Class = this.constructor, ///
-          node = clonedNode,  ///
-          tokens = clonedTokens, ///
-          replacement = new Class(node, tokens, ...remainingArguments);
-
-    return replacement
-  }
-
-  static fromNode(Class, node, ...remainingArguments) {
-    let context = remainingArguments.pop();
-
-    if (context === undefined) {
-      context = node; ///
-
-      node = Class; ///
-
-      Class = Replacement;  ///
-    }
-
-    let { tokens } = context;
-
-    const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
-          clonedNode = node.clone();
-
-    let clonedTokens;
-
-    if (firstSignificantTokenIndex === null) {
-      clonedTokens = [];
-    } else {
-      const offset = firstSignificantTokenIndex;  ///
-
-      clonedTokens = clonedTokensFromNodeAndTokens(node, tokens);
-
-      overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset);
-    }
-
-    node = clonedNode;  ///
-
-    tokens = clonedTokens; ///
-
-    const replacement = new Class(node, tokens, ...remainingArguments);
-
-    return replacement;
-  }
-
-  static fromNodeAndTokens(Class, node, tokens, ...remainingArguments) {
-    if (tokens === undefined) {
-      tokens = node;  ///
-
-      node = Class; ///
-
-      Class = Replacement;  ///
-    }
-
-    const replacement = new Class(node, tokens, ...remainingArguments);
-
-    return replacement;
-  }
-}
-

package/src/ruleNameToClassMap.js

@@ -1,38 +0,0 @@
-"use strict";
-
-import CommaHTMLNode from "./node/html/comma";
-import AnchorHTMLNode from "./node/html/anchor";
-import ClassNameHTMLNode from "./node/html/className";
-import BlockLineHTMLNode from "./node/html/blockLine";
-import OrderedItemHTMLNode from "./node/html/item/ordered";
-import ContentsLinkHTMLNode from "./node/html/contentsLink";
-import BlockListingHTMLNode from "./node/html/blockListing";
-import BlockListingHEndHTMLNode from "./node/html/blockListingEnd";
-import BlockListingHStartHTMLNode from "./node/html/blockListingStart";
-import PageNumberDirectiveHTMLNode from "./node/html/directive/pageNumber";
-
-import { COMMA_RULE_NAME,
-         ANCHOR_RULE_NAME,
-         CLASS_NAME_RULE_NAME,
-         BLOCK_LINE_RULE_NAME,
-         ORDERED_ITEM_RULE_NAME,
-         CONTENTS_LINK_RULE_NAME,
-         BLOCK_LISTING_RULE_NAME,
-         BLOCK_LISTING_END_RULE_NAME,
-         BLOCK_LISTING_START_RULE_NAME,
-         PAGE_NUMBER_DIRECTIVE_RULE_NAME } from "./ruleNames";
-
-const ruleNameToClassMap = {
-  [COMMA_RULE_NAME]: CommaHTMLNode,
-  [ANCHOR_RULE_NAME]: AnchorHTMLNode,
-  [CLASS_NAME_RULE_NAME]: ClassNameHTMLNode,
-  [BLOCK_LINE_RULE_NAME]: BlockLineHTMLNode,
-  [ORDERED_ITEM_RULE_NAME]: OrderedItemHTMLNode,
-  [CONTENTS_LINK_RULE_NAME]: ContentsLinkHTMLNode,
-  [BLOCK_LISTING_RULE_NAME]: BlockListingHTMLNode,
-  [BLOCK_LISTING_END_RULE_NAME]: BlockListingHEndHTMLNode,
-  [BLOCK_LISTING_START_RULE_NAME]: BlockListingHStartHTMLNode,
-  [PAGE_NUMBER_DIRECTIVE_RULE_NAME]: PageNumberDirectiveHTMLNode
-}
-
-export default ruleNameToClassMap;

package/src/utilities/childNodes.js

@@ -1,178 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import { EMPTY_STRING } from "../constants";
-import { contentFromNodes } from "../utilities/content";
-
-const { first, last, clear } = arrayUtilities;
-
-export function htmlFromMarkdownNode(markdownNode, context) {
-  const htmls = [],
-        plainTextMarkdownNodes = [];
-
-  markdownNode.forEachChildNode((childNode) => {
-    const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-    if (childNodeNonTerminalNode) {
-      const nonTerminalNode = childNode,  ///
-            markdownNode = nonTerminalNode, ///
-            markdownNodePlainTextMarkdownNode = markdownNode.isPlainTextMarkdownNode();
-
-      if (markdownNodePlainTextMarkdownNode) {
-        const plainTextMarkdownNode = markdownNode; ///
-
-        plainTextMarkdownNodes.push(plainTextMarkdownNode);
-      } else {
-        const content = contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context);
-
-        if (content !== null) {
-          const html = content; ///
-
-          htmls.push(html);
-        }
-
-        const indent = null,
-              html = markdownNode.asHTML(indent, context);
-
-        if (html !== null) {
-          htmls.push(html);
-        }
-      }
-    }
-  });
-
-  const content = contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context);
-
-  if (content !== null) {
-    const html = content; ///
-
-    htmls.push(html);
-  }
-
-  const html = htmls.join(EMPTY_STRING);
-
-  return html;
-}
-
-export function plainTextFromMarkdownNode(markdownNode, context) {
-  const plainTexts = [],
-        plainTextMarkdownNodes = [];
-
-  markdownNode.forEachChildNode((childNode) => {
-    const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-    if (childNodeNonTerminalNode) {
-      const nonTerminalNode = childNode,  ///
-            markdownNode = nonTerminalNode, ///
-            markdownNodePlainTextMarkdownNode = markdownNode.isPlainTextMarkdownNode();
-
-      if (markdownNodePlainTextMarkdownNode) {
-        const plainTextMarkdownNode = markdownNode; ///
-
-        plainTextMarkdownNodes.push(plainTextMarkdownNode);
-      } else {
-        const content = contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context);
-
-        if (content !== null) {
-          const plainText = content;  ///
-
-          plainTexts.push(plainText);
-        }
-
-        {
-          const plainText = plainTextFromMarkdownNode(markdownNode, context);
-
-          if (plainText !== EMPTY_STRING) {
-            plainTexts.push(plainText);
-          }
-        }
-      }
-    }
-  });
-
-  const content = contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context);
-
-  if (content !== null) {
-    const plainText = content;  ///
-
-    plainTexts.push(plainText);
-  }
-
-  const plainText = plainTexts.join(EMPTY_STRING);
-
-  return plainText;
-}
-
-export function domElementsFromMarkdownNode(markdownNode, context) {
-  const domElements = [],
-        plainTextMarkdownNodes = [];
-
-  markdownNode.forEachChildNode((childNode) => {
-    const childNodeNonTerminalNode = childNode.isNonTerminalNode();
-
-    if (childNodeNonTerminalNode) {
-      const nonTerminalNode = childNode,  ///
-            markdownNode = nonTerminalNode, ///
-            markdownNodePlainTextMarkdownNode = markdownNode.isPlainTextMarkdownNode();
-
-      if (markdownNodePlainTextMarkdownNode) {
-        const plainTextMarkdownNode = markdownNode; ///
-
-        plainTextMarkdownNodes.push(plainTextMarkdownNode);
-      } else {
-        const content = contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context);
-
-        if (content !== null) {
-          const textNode = document.createTextNode(content),
-                domElement = textNode;  ///
-
-          domElements.push(domElement);
-        }
-
-        const domElement = markdownNode.createDOMElement(context);
-
-        markdownNode.setDOMElement(domElement);
-
-        domElements.push(domElement);
-      }
-    }
-  });
-
-  const content = contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context);
-
-  if (content !== null) {
-    const textNode = document.createTextNode(content),
-          domElement = textNode;  ///
-
-    domElements.push(domElement);
-  }
-
-  return domElements;
-}
-
-function contentFromPlainTextMarkdownNodes(plainTextMarkdownNodes, markdownNode, context) {
-  let content = null;
-
-  const plainTextMarkdownNodesLength = plainTextMarkdownNodes.length;
-
-  if (plainTextMarkdownNodesLength > 0) {
-    const childNodes = plainTextMarkdownNodes, ///
-          startChildNode = first(childNodes),
-          endChildNode = last(childNodes),
-          startChildNodeIndex = markdownNode.indexOfChildNode(startChildNode),
-          endChildNodeIndex = markdownNode.indexOfChildNode(endChildNode),
-          multiplicity = markdownNode.getMultiplicity(),
-          lastChildNodeIndex = multiplicity - 1,
-          firstChildNodeIndex = 0,
-          augmentLeft = (endChildNodeIndex !== firstChildNodeIndex),
-          augmentRight = (startChildNodeIndex !== lastChildNodeIndex),  ///
-          nodes = childNodes; ///
-
-    content = contentFromNodes(nodes, augmentLeft, augmentRight, context);
-
-    clear(plainTextMarkdownNodes);
-  }
-
-  return content;
-}

package/src/utilities/processing.js

@@ -1,122 +0,0 @@
-"use strict";
-
-export function postprocess(divisionMarkdownNode, context) {
-  let divisionMarkdownNodes;
-
-  divisionMarkdownNodes = resolveIncludes(divisionMarkdownNode, context);
-
-  resolveEmbeddings(divisionMarkdownNodes, context);
-
-  const footnoteReplacementMap = prepareFootnotes(divisionMarkdownNodes, context),
-        markdownNodes = paginate(divisionMarkdownNodes, context);
-
-  divisionMarkdownNodes = divisionMarkdownNodesFromMarkdownNodes(markdownNodes);  ///
-
-  createFootnotes(divisionMarkdownNodes, footnoteReplacementMap, context);
-
-  createContents(divisionMarkdownNodes, context);
-
-  createIndex(divisionMarkdownNodes, context);
-
-  return markdownNodes;
-}
-
-function paginate(divisionMarkdownNodes, context) {
-  const pageNumber = 1,
-        markdownNOdes = [];
-
-  Object.assign(context, {
-    pageNumber
-  });
-
-  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
-    divisionMarkdownNode.paginate(markdownNOdes, context);
-  });
-
-  delete context.pageNumber;
-
-  return markdownNOdes;
-}
-
-function createIndex(divisionMarkdownNodes, context) {
-  divisionMarkdownNodes.some((divisionMarkdownNode) => {
-    const indexCreated = divisionMarkdownNode.createIndex(divisionMarkdownNodes, context);
-
-    if (indexCreated) {
-      return true;
-    }
-  });
-}
-
-function createContents(divisionMarkdownNodes, context) {
-  divisionMarkdownNodes.some((divisionMarkdownNode) => {
-    const contentsCreated = divisionMarkdownNode.createContents(divisionMarkdownNodes, context);
-
-    if (contentsCreated) {
-      return true;
-    }
-  });
-}
-
-function createFootnotes(divisionMarkdownNodes, footnoteReplacementMap, context) {
-  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
-    divisionMarkdownNode.createFootnotes(footnoteReplacementMap, context);
-  });
-}
-
-function resolveIncludes(divisionMarkdownNode, context) {
-  const divisionMarkdownNodes = [];
-
-  Object.assign(context, {
-    divisionMarkdownNodes
-  });
-
-  const divisionMarkdownNodeIgnored = divisionMarkdownNode.isIgnored();
-
-  if (!divisionMarkdownNodeIgnored) {
-    divisionMarkdownNodes.push(divisionMarkdownNode);
-  }
-
-  divisionMarkdownNode.resolveIncludes(context);
-
-  delete context.divisionMarkdownNodes;
-
-  return divisionMarkdownNodes;
-}
-
-function prepareFootnotes(divisionMarkdownNodes, context) {
-  const footnoteReplacementMap = {};
-
-  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
-    divisionMarkdownNode.prepareFootnotes(footnoteReplacementMap, context);
-  });
-
-  return footnoteReplacementMap;
-}
-
-function resolveEmbeddings(divisionMarkdownNodes, context) {
-  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
-    divisionMarkdownNode.resolveEmbeddings(context);
-  });
-}
-
-export function divisionMarkdownNodesFromMarkdownNodes(markdownNodes) {
-  const divisionMarkdownNodes = markdownNodes.reduce((divisionMarkdownNodes, markdownNode) => {
-    const markdownNodeDivisionMarkdownNode = markdownNode.isDivisionMarkdownNode();
-
-    if (markdownNodeDivisionMarkdownNode) {
-      const divisionMarkdownNode = markdownNode;  ///
-
-      divisionMarkdownNodes.push(divisionMarkdownNode);
-    }
-
-    return divisionMarkdownNodes;
-  }, []);
-
-  return divisionMarkdownNodes;
-}
-
-export default {
-  postprocess,
-  divisionMarkdownNodesFromMarkdownNodes
-}