highmark-markdown 0.0.383 → 0.0.388

package/src/replacement/contentsLink.js

@@ -0,0 +1,29 @@
+"use strict";
+
+import Replacement from "../replacement";
+import LineReplacement from "../replacement/line";
+import ContentsLinkMarkdownNode from "../node/markdown/contentsLink";
+
+export default class ContentsLinkReplacement extends Replacement {
+  static fromNodeAndTokens(node, tokens) { return super.fromNodeAndTokens(ContentsLinkReplacement, node, tokens); }
+
+  static fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context) {
+    let contentsLinkReplacement = null;
+
+    const node = nestedHeadingMarkdownNode.getNode(),
+          headingMarkdownNode = node;  ///
+
+    if (headingMarkdownNode !== null) {
+      const identifier = headingMarkdownNode.identifier(context),
+            lineMarkdownNode = headingMarkdownNode.getLineMarkdownNode(),
+            lineReplacement = LineReplacement.fromLineMarkdownNode(lineMarkdownNode, context),
+            contentsLinkMarkdownNode = ContentsLinkMarkdownNode.fromLineReplacementAndIdentifier(lineReplacement, identifier),
+            node = contentsLinkMarkdownNode,  ///
+            tokens = lineReplacement.getTokens();
+
+      contentsLinkReplacement = ContentsLinkReplacement.fromNodeAndTokens(node, tokens);
+    }
+
+    return contentsLinkReplacement;
+  }
+}

package/src/replacement/contentsList.js

@@ -0,0 +1,111 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Replacement from "../replacement";
+import ContentsItemReplacement from "./contentsItem";
+import ContentsListMarkdownNode from "../node/markdown/contentsList";
+
+import { nestNodes } from "../utilities/contents";
+import { headingMarkdownNodesFromNode } from "../utilities/query";
+
+const { filter } = arrayUtilities;
+
+export default class ContentsListReplacement extends Replacement {
+  replaceContentsDirectiveSubdivisionReplacement(contentsDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
+    const contentsDirectiveSubDivisionReplacementRemovedNode = contentsDirectiveSubDivisionReplacement.getRemovedNode(),
+          replacedNode = contentsDirectiveSubDivisionReplacementRemovedNode, ///
+          parentNode = divisionMarkdownNode;  ///
+
+    super.replace(replacedNode, parentNode, context)
+  }
+
+  static fromNodeAndTokens(node, tokens) { return Replacement.fromNodeAndTokens(ContentsListReplacement, node, tokens); }
+
+  static fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
+    const contentsItemReplacements = contentsItemReplacementsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+          contentsListMarkdownNode = ContentsListMarkdownNode.fromContentsItemReplacements(contentsItemReplacements),
+          node = contentsListMarkdownNode, ///
+          tokens = [];
+
+    contentsItemReplacements.forEach((contentsItemReplacement) => {
+      contentsItemReplacement.getTokens(tokens);
+    });
+
+    const contentsListReplacement = ContentsListReplacement.fromNodeAndTokens(node, tokens);
+
+    return contentsListReplacement;
+  }
+
+  static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+    let contentsListReplacement = null;
+
+    const headingMarkdownNodes = headingMarkdownNodesFromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context),
+          headingMarkdownNodesLength = headingMarkdownNodes.length;
+
+    if (headingMarkdownNodesLength > 0) {
+      const nestedHeadingMarkdownNodes = nestedHeadingMarkdownNodesFromHeadingMarkdownNodes(headingMarkdownNodes),
+            contentsItemReplacements = contentsItemReplacementsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+            contentsListMarkdownNode = ContentsListMarkdownNode.fromContentsItemReplacements(contentsItemReplacements),
+            node = contentsListMarkdownNode, ///
+            tokens = [];
+
+      contentsItemReplacements.forEach((contentsItemReplacement) => {
+        contentsItemReplacement.getTokens(tokens);
+      });
+
+      contentsListReplacement = ContentsListReplacement.fromNodeAndTokens(node, tokens);
+    }
+
+    return contentsListReplacement;
+  }
+}
+
+Object.assign(ContentsItemReplacement, {  ///
+  ContentsListReplacement
+});
+
+function nestedHeadingMarkdownNodesFromHeadingMarkdownNodes(headingMarkdownNodes) {
+  const nodes = headingMarkdownNodes, ///
+        nestedNode = nestNodes(nodes),
+        childNestedNodes = nestedNode.getChildNestedNodes(),
+        nestedHeadingMarkdownNodes = childNestedNodes;  ///
+
+  return nestedHeadingMarkdownNodes;
+}
+
+function contentsItemReplacementsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
+  const contentsItemReplacements = nestedHeadingMarkdownNodes.map((nestedHeadingMarkdownNode) => {
+    const contentsItemReplacement = ContentsItemReplacement.fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context);
+
+    return contentsItemReplacement;
+  });
+
+  return contentsItemReplacements;
+}
+
+function headingMarkdownNodesFromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+  const headingMarkdownNodes = [],
+        index = divisionMarkdownNodes.indexOf(divisionMarkdownNode),
+        start = index + 1;
+
+  divisionMarkdownNodes = divisionMarkdownNodes.slice(start); ///
+
+  divisionMarkdownNodes.forEach((divisionMarkdownNode) => {
+    const node = divisionMarkdownNode;  ///
+
+    headingMarkdownNodesFromNode(node, headingMarkdownNodes);
+  });
+
+  filter(headingMarkdownNodes, (headingMarkdownNode) => {
+    const { contentsDepth } = context,
+      depth = headingMarkdownNode.getDepth();
+
+    if (depth <= contentsDepth) {
+      return true;
+    }
+  });
+
+  return headingMarkdownNodes;
+}
+

package/src/replacement/footnote.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import { footnoteMarkdownNodsFromNode } from "../utilities/query";
+
+export default class FootnoteReplacement extends Replacement {
+  static fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement) {
+    const node = footnoteSubDivisionReplacement.getNode(),
+          footnoteMarkdownNode = footnoteMarkdownNodsFromNode(node),
+          descendentNode = footnoteMarkdownNode,  ///
+          footnoteReplacement = footnoteSubDivisionReplacement.contract(FootnoteReplacement, descendentNode);
+
+    return footnoteReplacement;
+  }
+}

package/src/replacement/footnotesItem.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import Replacement from "../replacement";
+
+import FootnotesItemMarkdownNode from "../node/markdown/footnotesItem";
+
+const { extract } = arrayUtilities;
+
+export default class FootnotesItemReplacement extends Replacement {
+  static fromNode(node, context) { return Replacement.fromNode(FootnotesItemReplacement, node, context); }
+
+  static fromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context) {
+    let footnotesItemReplacement = null;
+
+    const footnoteReplacement = extract(footnoteReplacements, (footnoteReplacement) => {
+      const node = footnoteReplacement.getNode(),
+            footnoteMarkdownNode = node,  ///
+            footnoteMarkdownNodeIdentifier = footnoteMarkdownNode.identifier(context);
+
+      if (footnoteMarkdownNodeIdentifier === identifier) {
+        return true;
+      }
+    }) || null;
+
+    if (footnoteReplacement !== null) {
+      const node = footnoteReplacement.getNode(),
+            footnoteMarkdownNode = node,  ///
+            footnotesItemMarkdownNode = FootnotesItemMarkdownNode.fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier),
+            ascendantNode = footnotesItemMarkdownNode; ///
+
+      footnotesItemReplacement = footnoteReplacement.expand(FootnotesItemReplacement, ascendantNode);
+    }
+
+    return footnotesItemReplacement;
+  }
+}

package/src/replacement/footnotesList.js

@@ -0,0 +1,73 @@
+"use strict";
+
+import Replacement from "../replacement";
+import FootnotesItemReplacement from "../replacement/footnotesItem";
+import FootnotesListMarkdownNode from "../node/markdown/footnotesList";
+
+import { linkMarkdownNodesFromNode } from "../utilities/query";
+
+export default class FootnotesListReplacement extends Replacement {
+  appendToDivisionMarkdownNode(divisionMarkdownNode, context) {
+    const parentNode = divisionMarkdownNode; ///
+
+    super.appendTo(parentNode, context);
+  }
+
+  static fromNodeAndTokens(node, tokens) { return Replacement.fromNodeAndTokens(FootnotesListReplacement, node, tokens); }
+
+  static fromFootnoteReplacementsAndDivisionMarkdownNode(footnoteReplacements, divisionMarkdownNode, context) {
+    let footnotesListReplacement = null;
+
+    const { footnoteNumberMap } = context;
+
+    const node = divisionMarkdownNode,  ///
+          footnoteNumbers = Object.values(footnoteNumberMap),
+          linkMarkdownNodes = linkMarkdownNodesFromNode(node),
+          footnoteNumbersLength = footnoteNumbers.length,
+          footnotesItemReplacements = [];
+
+    let count = 0;
+
+    linkMarkdownNodes.forEach((linkMarkdownNode) => {
+      const identifier = linkMarkdownNode.identifier(context);
+
+      let footnoteNumber = footnoteNumberMap[identifier] || null;
+
+      if (footnoteNumber === null) {
+        const footnotesItemReplacement = FootnotesItemReplacement.fromFootnoteReplacementsAndIdentifier(footnoteReplacements, identifier, context);
+
+        if (footnotesItemReplacement !== null) {
+          footnotesItemReplacements.push(footnotesItemReplacement);
+
+          count++;
+
+          footnoteNumber = footnoteNumbersLength + count;
+
+          footnoteNumberMap[identifier] = footnoteNumber;
+        }
+      }
+
+      if (footnoteNumber !== null) {
+        const number = footnoteNumber;  ///
+
+        linkMarkdownNode.setNumber(number);
+      }
+    });
+
+    const start = footnoteNumbersLength + 1,
+          footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start);
+
+    if (footnotesListMarkdownNode !== null) {
+      const node = footnotesListMarkdownNode, ///
+            tokens = [];
+
+      footnotesItemReplacements.forEach((footnotesItemReplacement) => {
+        footnotesItemReplacement.getTokens(tokens);
+      });
+
+      footnotesListReplacement = FootnotesListReplacement.fromNodeAndTokens(node, tokens);
+    }
+
+    return footnotesListReplacement;
+  }
+}

package/src/replacement/imported.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+export default class ImportedReplacement extends Replacement {
+  replaceEmbedDirectiveMarkdownNode(embedDirectiveMarkdownNode, parentNode, context) {
+    const replacedNode = embedDirectiveMarkdownNode; ///
+
+    super.replaceEx(replacedNode, parentNode, context);
+  }
+
+  static fromNodeAndTokens(node, tokens) { return Replacement.fromNodeAndTokens(ImportedReplacement, node, tokens); }
+}

package/src/replacement/line.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+export default class LineReplacement extends Replacement {
+  static fromNode(node, context) { return Replacement.fromNode(LineReplacement, node, context); }
+
+  static fromLineMarkdownNode(lineMarkdownNode, context) {
+    const node = lineMarkdownNode,  ///
+          lineReplacement = LineReplacement.fromNode(node, context);
+
+    return lineReplacement;
+  }
+}

package/src/replacement/subDivision/contentsDirective.js

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

package/src/replacement/subDivision/footnote.js

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

package/src/replacement/subDivision/footnotesDirective.js

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

package/src/replacement/subDivision/pageNumberDirective.js

@@ -0,0 +1,20 @@
+"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

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