highmark-markdown 1.0.173 → 1.0.174

package/src/{replacement → transform}/subDivision/footnote.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import SubDivisionReplacement from "../../replacement/subDivision";
+import SubDivisionTransform from "../division";
 
 import { footnoteMarkdownNodeFromNode } from "../../utilities/query";
 
-export default class FootnoteSubDivisionReplacement extends SubDivisionReplacement {
+export default class FootnoteSubDivisionTransform extends SubDivisionTransform {
   identifier(context) {
     const subDivisionMarkdownNode = this.getSubDivisionMarkdownNode(),
           node = subDivisionMarkdownNode, ///
@@ -15,15 +15,15 @@ export default class FootnoteSubDivisionReplacement extends SubDivisionReplaceme
   }
 
   static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
-    let footnoteSubDivisionReplacement = null;
+    let footnoteSubDivisionTransform = null;
 
     const node = subDivisionMarkdownNode, ///
           footnoteMarkdownNode = footnoteMarkdownNodeFromNode(node);
 
     if (footnoteMarkdownNode !== null) {
-      footnoteSubDivisionReplacement = SubDivisionReplacement.fromSubDivisionMarkdownNode(FootnoteSubDivisionReplacement, subDivisionMarkdownNode, context);
+      footnoteSubDivisionTransform = SubDivisionTransform.fromSubDivisionMarkdownNode(FootnoteSubDivisionTransform, subDivisionMarkdownNode, context);
     }
 
-    return footnoteSubDivisionReplacement;
+    return footnoteSubDivisionTransform;
   }
 }

package/src/transform/subDivision/footnotesDirective.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import SubDivisionTransform from "../division";
+
+import { footnotesDirectiveMarkdownNodeFromNode } from "../../utilities/query";
+
+export default class FootnotesDirectiveSubDivisionTransform extends SubDivisionTransform {
+  static fromSubDivisionMarkdownNode(subDivisionMarkdownNode, context) {
+    let footnotesDirectiveSubDivisionTransform = null;
+
+    const node = subDivisionMarkdownNode, ///
+          footnotesDirectiveMarkdownNode = footnotesDirectiveMarkdownNodeFromNode(node);
+
+    if (footnotesDirectiveMarkdownNode !== null) {
+      footnotesDirectiveSubDivisionTransform = SubDivisionTransform.fromSubDivisionMarkdownNode(FootnotesDirectiveSubDivisionTransform, subDivisionMarkdownNode, context);
+    }
+
+    return footnotesDirectiveSubDivisionTransform;
+  }
+}

package/src/transform/subDivision/includeDirectives.js

@@ -0,0 +1,48 @@
+"use strict";
+
+import DivisionTransform from "../division";
+
+import { includeDirectiveMarkdownNodesFromNode } from "../../utilities/query";
+
+export default class IncludeDirectivesDivisionTransform extends DivisionTransform {
+  constructor(node, tokens, divisionMarkdownNode, includeDirectiveMarkdownNodes) {
+    super(node, tokens, divisionMarkdownNode);
+
+    this.includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodes;
+  }
+
+  getIncludeDirectiveMarkdownNodes() {
+    return this.includeDirectiveMarkdownNodes;
+  }
+
+  removeDivisionMarkdownNode(divisionMarkdownNode, context) {
+    this.includeDirectiveMarkdownNodes.forEach((includeDirectiveMarkdownNode) => {
+      const includeDirectiveTransform = includeDirectiveMarkdownNode.resolve(context);
+
+      if (includeDirectiveTransform !== null) {
+        const divisionMarkdownNode = includeDirectiveTransform.getDivisionMarkdownNode(),
+              divisionMarkdownNodes = includeDirectiveTransform.addDivisionMarkdownNode(context);
+
+        divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+          divisionMarkdownNode.resolveIncludes(divisionMarkdownNode, context);
+        });
+      }
+    });
+
+    this.removeFromTopmostMarkdownNode(divisionMarkdownNode, context);
+  }
+
+  static fromDivisionMarkdownNode(divisionMarkdownNode, context) {
+    let includeDirectivesDivisionTransform = null;
+
+    const node = divisionMarkdownNode, ///
+          includeDirectiveMarkdownNodes = includeDirectiveMarkdownNodesFromNode(node),
+          includeDirectiveMarkdownNodesLength = includeDirectiveMarkdownNodes.length;
+
+    if (includeDirectiveMarkdownNodesLength > 0) {
+      includeDirectivesDivisionTransform = DivisionTransform.fromDivisionMarkdownNode(IncludeDirectivesDivisionTransform, divisionMarkdownNode, includeDirectiveMarkdownNodes, context);
+    }
+
+    return includeDirectivesDivisionTransform;
+  }
+}

package/src/transform/subDivision/indexDirective.js

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

package/src/transform/subDivision/pageNumberDirective.js

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

package/src/utilities/content.js

@@ -1,87 +1,6 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-
 import { EMPTY_STRING } from "../constants";
-import { ESCAPED_TOKEN_TYPE } from "../tokenTypes";
-
-const { first, last } = arrayUtilities;
-
-export function contentFromNode(node, context) {
-  let content = EMPTY_STRING;
-
-  let { tokens } = context;
-
-  const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
-        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
-        start = firstSignificantTokenIndex,  ///
-        end = lastSignificantTokenIndex + 1;
-
-  tokens = tokens.slice(start, end);
-
-  tokens.forEach((token) => {
-    const tokenContent = tokenContentFromToken(token);
-
-    content += tokenContent;
-  });
-
-  return content;
-}
-
-export function contentFromNodes(nodes, augmentLeft, augmentRight, context) {
-  let content = EMPTY_STRING;
-
-  let { tokens } = context;
-
-  const lastNode = last(nodes),
-        firstNode = first(nodes),
-        firstSignificantTokenIndex = firstNode.getFirstSignificantTokenIndex(tokens),
-        lastSignificantTokenIndex = lastNode.getLastSignificantTokenIndex(tokens);
-
-  let firstTokenIndex = firstSignificantTokenIndex,  ///
-      lastTokenIndex = lastSignificantTokenIndex; ///
-
-  if (augmentLeft) {
-    const previousTokenIndex = firstTokenIndex - 1;
-
-    if (previousTokenIndex > -1) {
-      const previousToken = tokens[previousTokenIndex],
-            previousTokenSignificant = previousToken.isSignificant();
-
-      if (!previousTokenSignificant) {
-        firstTokenIndex--;
-      }
-    }
-  }
-
-  if (augmentRight) {
-    const tokensLength = tokens.length,
-          nextTokenIndex = lastTokenIndex + 1;
-
-    if (nextTokenIndex < tokensLength) {
-      const nextToken = tokens[nextTokenIndex],
-            nextTokenSignificant = nextToken.isSignificant(),
-            nextTokenEndOfLineToken = nextToken.isEndOfLineToken();
-
-      if (nextTokenEndOfLineToken || !nextTokenSignificant) {
-        lastTokenIndex++;
-      }
-    }
-  }
-
-  const start = firstTokenIndex,  ///
-        end = lastTokenIndex + 1;
-
-  tokens = tokens.slice(start, end);
-
-  tokens.forEach((token) => {
-    const tokenContent = tokenContentFromToken(token);
-
-    content += tokenContent;
-  });
-
-  return content;
-}
 
 export function contentFromNodeAndTokens(node, tokens, offset = 0) {
   let content = EMPTY_STRING;
@@ -108,17 +27,3 @@ export function remainingContentFromNodeTokensAndOffset(node, tokens, offset) {
 
   return remainingContent;
 }
-
-function tokenContentFromToken(token) {
-  let tokenContent = token.getContent();
-
-  const type = token.getType();
-
-  if (type === ESCAPED_TOKEN_TYPE) {
-    const start = 1;
-
-    tokenContent = tokenContent.substring(start);
-  }
-
-  return tokenContent;
-}

package/src/utilities/entities.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { LESS_THAN, GREATER_THAN } from "../constants";
+
+export function replaceEntities(content) {
+  content = content
+              .replace(/<?/g, LESS_THAN)
+              .replace(/>?/g, GREATER_THAN);
+
+  return content;
+}

package/src/utilities/entries.js

@@ -1,12 +1,12 @@
 "use strict";
 
-export function ruleNamesExpressionFromElementMap(elementMap) {
-  const ruleNames = Object.keys(elementMap);
+export function ruleNamesExpressionFromTagNameMap(tagNameMap) {
+  const ruleNames = Object.keys(tagNameMap);
 
   ruleNames.reverse();
 
   const ruleNamesExpression = ruleNames.reduce((ruleNamesExpression, ruleName) => {
-          const { tagName } = elementMap[ruleName];
+          const tagName = tagNameMap[ruleName];
 
           if (tagName !== null) {
             ruleNamesExpression = (ruleNamesExpression === null) ?

package/src/utilities/html.js

@@ -1,11 +1,74 @@
 "use strict";
 
-import { LESS_THAN, GREATER_THAN } from "../constants";
+export function postProcess(divisionMarkdownNodes, context) {
+  debugger
 
-export function replaceEntities(content) {
-  content = content
-              .replace(/<?/g, LESS_THAN)
-              .replace(/>?/g, GREATER_THAN);
 
-  return content;
+  // const footnoteReplacementMap = prepareFootnotes(divisionMarkdownNodes, context),
+  //       markdownNodes = paginate(divisionMarkdownNodes, context);
+  //
+  // divisionMarkdownNodes = divisionMarkdownNodesFromMarkdownNodes(markdownNodes);  ///
+  //
+  // createFootnotes(divisionMarkdownNodes, footnoteReplacementMap, context);
+  //
+  // createContents(divisionMarkdownNodes, context);
+  //
+  // createIndex(divisionMarkdownNodes, context);
 }
+
+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 prepareFootnotes(divisionMarkdownNodes, context) {
+  const footnoteReplacementMap = {};
+
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.prepareFootnotes(footnoteReplacementMap, context);
+  });
+
+  return footnoteReplacementMap;
+}
+
+export default {
+  postProcess
+}

package/src/utilities/markdown.js

@@ -0,0 +1,32 @@
+"use strict";
+
+export 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;
+}
+
+export function resolveEmbeddings(divisionMarkdownNodes, context) {
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    divisionMarkdownNode.resolveEmbeddings(context);
+  });
+}
+
+export default {
+  resolveIncludes,
+  resolveEmbeddings
+};

package/src/utilities/parser.js

@@ -2,6 +2,8 @@
 
 import { rulesUtilities } from "occam-parsers";
 
+import MarkdownNode from "../node/markdown"; ///
+
 const { rulesFromStartRuleAndRuleMap } = rulesUtilities;
 
 export function setNonTerminalNodes(parser, nodeMap) {
@@ -11,8 +13,7 @@ export function setNonTerminalNodes(parser, nodeMap) {
 
   rules.forEach((rule) => {
     const ruleName = rule.getName(),
-          MarkdownNode = nodeMap[ruleName],
-          NonTerminalNode = MarkdownNode; ///
+          NonTerminalNode = nodeMap[ruleName] || MarkdownNode; ///
 
     rule.setNonTerminalNode(NonTerminalNode);
   });

package/src/utilities/query.js

@@ -5,18 +5,17 @@ import { arrayUtilities } from "necessary";
 
 const { push } = arrayUtilities;
 
-const footnoteMarkdownNodeQuery = Query.fromExpressionString("/subDivision/footnote"),
-      indexDirectiveMarkdownNodeQuery = Query.fromExpressionString("/subDivision/directives/indexDirective"),
-      ignoreDirectiveMarkdownNodeQuery = Query.fromExpressionString("/division/subDivision/directives/ignoreDirective"),
-      contentsDirectiveMarkdownNodeQuery = Query.fromExpressionString("/subDivision/directives/contentsDirective"),
-      footnotesDirectiveMarkdownNodeQuery = Query.fromExpressionString("/subDivision/directives/footnotesDirective"),
+const footnoteMarkdownNodeQuery = Query.fromExpressionString("/division/footnote"),
+      indexDirectiveMarkdownNodeQuery = Query.fromExpressionString("/division/directives/indexDirective"),
+      ignoreDirectiveMarkdownNodeQuery = Query.fromExpressionString("/division/directives/ignoreDirective"),
+      contentsDirectiveMarkdownNodeQuery = Query.fromExpressionString("/division/directives/contentsDirective"),
+      footnotesDirectiveMarkdownNodeQuery = Query.fromExpressionString("/division/directives/footnotesDirective"),
       pageNumberDirectiveMarkdownNodeQuery = Query.fromExpressionString("//directives/pageNumber"),  ///
-      headingMarkdownNodesQuery = Query.fromExpressionString("/division/subDivision/primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"),  ///
+      headingMarkdownNodesQuery = Query.fromExpressionString("/division/primaryHeading|secondaryHeading|tertiaryHeading|quaternaryHeading"),  ///
       footnotesMarkdownNodesQuery = Query.fromExpressionString("//footnote|footnoteLink|footnotesDirective"), ///
-      subDivisionMarkdownNodesQuery = Query.fromExpressionString("/division/subDivision"),
       footnoteLinkMarkdownNodesQuery = Query.fromExpressionString("//footnoteLink"),
-      embedDirectiveMarkdownNodesQuery = Query.fromExpressionString("/subDivision/directives/embedDirective"),
-      includeDirectiveMarkdownNodesQuery = Query.fromExpressionString("/subDivision/directives/includeDirective");
+      embedDirectiveMarkdownNodesQuery = Query.fromExpressionString("/division/directives/embedDirective"),
+      includeDirectiveMarkdownNodesQuery = Query.fromExpressionString("/division/directives/includeDirective");
 
 export function nodeQuery(expression) {
   const query = Query.fromExpressionString(expression);
@@ -40,18 +39,6 @@ export function nodesQuery(expression) {
   }
 }
 
-export function nodesFromNodeAndQueries(node, queries) {
-  const nodes = [];
-
-  queries.forEach((query) => {
-    const queryNodes = query.execute(node);
-
-    push(nodes, queryNodes);
-  });
-
-  return nodes;
-}
-
 export function footnoteMarkdownNodeFromNode(node) {
   const footnoteMarkdownNode = nodeFromNodeAndQuery(node, footnoteMarkdownNodeQuery);
 
@@ -100,12 +87,6 @@ export function footnotesMarkdownNodesFromNode(node, footnotesMarkdownNodes = []
   return footnotesMarkdownNodes;
 }
 
-export function subDivisionMarkdownNodesFromNode(node, subDivisionMarkdownNodes = []) {
-  nodesFromNodeAndQuery(node, subDivisionMarkdownNodesQuery, subDivisionMarkdownNodes);
-
-  return subDivisionMarkdownNodes;
-}
-
 export function footnoteLinkMarkdownNodesFromNode(node, linkMarkdownNodes = []) {
   nodesFromNodeAndQuery(node, footnoteLinkMarkdownNodesQuery, linkMarkdownNodes);
 
@@ -133,7 +114,6 @@ export default {
   pageNumberDirectiveMarkdownNodeFromNode,
   headingMarkdownNodesFromNode,
   footnotesMarkdownNodesFromNode,
-  subDivisionMarkdownNodesFromNode,
   footnoteLinkMarkdownNodesFromNode,
   embedDirectiveMarkdownNodesFromNode,
   includeDirectiveMarkdownNodesFromNode

package/lib/classFromOuterNode.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return ClassFromOuterNode;
-    }
-});
-var _html = /*#__PURE__*/ _interop_require_default(require("./node/html"));
-var _topmost = /*#__PURE__*/ _interop_require_default(require("./node/html/topmost"));
-var _ruleNameToClassMap = /*#__PURE__*/ _interop_require_default(require("./ruleNameToClassMap"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function ClassFromOuterNode(outerNode) {
-    var Class;
-    if (outerNode === null) {
-        Class = _topmost.default;
-    } else {
-        var nonTerminalNode = outerNode, ruleName = nonTerminalNode.getRuleName();
-        Class = _ruleNameToClassMap.default[ruleName] || _html.default;
-    }
-    return Class;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9jbGFzc0Zyb21PdXRlck5vZGUuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBIVE1MTm9kZSBmcm9tIFwiLi9ub2RlL2h0bWxcIjtcbmltcG9ydCBUb3Btb3N0SFRNTE5vZGUgZnJvbSBcIi4vbm9kZS9odG1sL3RvcG1vc3RcIjtcbmltcG9ydCBydWxlTmFtZVRvQ2xhc3NNYXAgZnJvbSBcIi4vcnVsZU5hbWVUb0NsYXNzTWFwXCI7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIENsYXNzRnJvbU91dGVyTm9kZShvdXRlck5vZGUpIHtcbiAgbGV0IENsYXNzO1xuXG4gIGlmIChvdXRlck5vZGUgPT09IG51bGwpIHtcbiAgICBDbGFzcyA9IFRvcG1vc3RIVE1MTm9kZTtcbiAgfSBlbHNlIHtcbiAgICBjb25zdCBub25UZXJtaW5hbE5vZGUgPSBvdXRlck5vZGUsICAvLy9cbiAgICAgICAgICBydWxlTmFtZSA9IG5vblRlcm1pbmFsTm9kZS5nZXRSdWxlTmFtZSgpO1xuXG4gICAgQ2xhc3MgPSBydWxlTmFtZVRvQ2xhc3NNYXBbcnVsZU5hbWVdIHx8IEhUTUxOb2RlO1xuICB9XG5cbiAgcmV0dXJuIENsYXNzO1xufVxuIl0sIm5hbWVzIjpbIkNsYXNzRnJvbU91dGVyTm9kZSIsIm91dGVyTm9kZSIsIkNsYXNzIiwiVG9wbW9zdEhUTUxOb2RlIiwibm9uVGVybWluYWxOb2RlIiwicnVsZU5hbWUiLCJnZXRSdWxlTmFtZSIsInJ1bGVOYW1lVG9DbGFzc01hcCIsIkhUTUxOb2RlIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFNQTs7O2VBQXdCQTs7OzJEQUpIOzhEQUNPO3lFQUNHOzs7Ozs7QUFFaEIsU0FBU0EsbUJBQW1CQyxTQUFTO0lBQ2xELElBQUlDO0lBRUosSUFBSUQsY0FBYyxNQUFNO1FBQ3RCQyxRQUFRQyxnQkFBZTtJQUN6QixPQUFPO1FBQ0wsSUFBTUMsa0JBQWtCSCxXQUNsQkksV0FBV0QsZ0JBQWdCRSxXQUFXO1FBRTVDSixRQUFRSywyQkFBa0IsQ0FBQ0YsU0FBUyxJQUFJRyxhQUFRO0lBQ2xEO0lBRUEsT0FBT047QUFDVCJ9