highmark-markdown 1.0.173 → 1.0.174

package/src/{replacement → transform}/contentsList.js

@@ -1,9 +1,9 @@
 "use strict";
 
+import { Transform } from "occam-dom";
 import { arrayUtilities } from "necessary";
 
-import Replacement from "../replacement";
-import ContentsItemReplacement from "./contentsItem";
+import ContentsItemTransform from "../transform/contentsItem";
 import ContentsListMarkdownNode from "../node/markdown/contentsList";
 
 import { nestNodes } from "../utilities/contents";
@@ -11,9 +11,9 @@ import { headingMarkdownNodesFromNode } from "../utilities/query";
 
 const { filter } = arrayUtilities;
 
-class ContentsListReplacement extends Replacement {
-  replaceContentsDirectiveSubdivisionReplacement(contentsDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
-    const subDivisionMarkdownNode = contentsDirectiveSubDivisionReplacement.getSubDivisionMarkdownNode(),
+class ContentsListTransform extends Transform {
+  replaceContentsDirectiveSubdivisionTransform(contentsDirectiveSubDivisionTransform, divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = contentsDirectiveSubDivisionTransform.getSubDivisionMarkdownNode(),
           replacedNode = subDivisionMarkdownNode, ///
           parentNode = divisionMarkdownNode;  ///
 
@@ -21,49 +21,49 @@ class ContentsListReplacement extends Replacement {
   }
 
   static fromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
-    const contentsItemReplacements = contentsItemReplacementsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
-          contentsListMarkdownNode = ContentsListMarkdownNode.fromContentsItemReplacements(contentsItemReplacements),
+    const contentsItemTransforms = contentsItemTransformsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+          contentsListMarkdownNode = ContentsListMarkdownNode.fromContentsItemTransforms(contentsItemTransforms),
           node = contentsListMarkdownNode, ///
           tokens = [];
 
-    contentsItemReplacements.forEach((contentsItemReplacement) => {
-      contentsItemReplacement.getTokens(tokens);
+    contentsItemTransforms.forEach((contentsItemTransform) => {
+      contentsItemTransform.getTokens(tokens);
     });
 
-    const contentsListReplacement = Replacement.fromNodeAndTokens(ContentsListReplacement, node, tokens);
+    const contentsListTransform = Transform.fromNodeAndTokens(ContentsListTransform, node, tokens);
 
-    return contentsListReplacement;
+    return contentsListTransform;
   }
 
   static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
-    let contentsListReplacement = null;
+    let contentsListTransform = 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),
+            contentsItemTransforms = contentsItemTransformsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context),
+            contentsListMarkdownNode = ContentsListMarkdownNode.fromContentsItemTransforms(contentsItemTransforms),
             node = contentsListMarkdownNode, ///
             tokens = [];
 
-      contentsItemReplacements.forEach((contentsItemReplacement) => {
-        contentsItemReplacement.getTokens(tokens);
+      contentsItemTransforms.forEach((contentsItemTransform) => {
+        contentsItemTransform.getTokens(tokens);
       });
 
-      contentsListReplacement = Replacement.fromNodeAndTokens(ContentsListReplacement, node, tokens);
+      contentsListTransform = Transform.fromNodeAndTokens(ContentsListTransform, node, tokens);
     }
 
-    return contentsListReplacement;
+    return contentsListTransform;
   }
 }
 
-Object.assign(ContentsItemReplacement, {  ///
-  ContentsListReplacement
+Object.assign(ContentsItemTransform, {  ///
+  ContentsListTransform
 });
 
-export default ContentsListReplacement;
+export default ContentsListTransform;
 
 function nestedHeadingMarkdownNodesFromHeadingMarkdownNodes(headingMarkdownNodes) {
   const nodes = headingMarkdownNodes, ///
@@ -74,14 +74,14 @@ function nestedHeadingMarkdownNodesFromHeadingMarkdownNodes(headingMarkdownNodes
   return nestedHeadingMarkdownNodes;
 }
 
-function contentsItemReplacementsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
-  const contentsItemReplacements = nestedHeadingMarkdownNodes.map((nestedHeadingMarkdownNode) => {
-    const contentsItemReplacement = ContentsItemReplacement.fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context);
+function contentsItemTransformsFromNestedHeadingMarkdownNodes(nestedHeadingMarkdownNodes, context) {
+  const contentsItemTransforms = nestedHeadingMarkdownNodes.map((nestedHeadingMarkdownNode) => {
+    const contentsItemTransform = ContentsItemTransform.fromNestedHeadingMarkdownNode(nestedHeadingMarkdownNode, context);
 
-    return contentsItemReplacement;
+    return contentsItemTransform;
   });
 
-  return contentsItemReplacements;
+  return contentsItemTransforms;
 }
 
 function headingMarkdownNodesFromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {

package/src/transform/division.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { Transform } from "occam-dom";
+
+export default class DivisionTransform extends Transform {
+  constructor(node, tokens, divisionMarkdownNode) {
+    super(node, tokens);
+
+    this.divisionMarkdownNode = divisionMarkdownNode;
+  }
+
+  getDivisionMarkdownNode() {
+    return this.divisionMarkdownNode;
+  }
+
+  appendToTopmostMarkdownNode(topmostMarkdownNode, context) {
+    const parentNode = topmostMarkdownNode;  ///
+
+    super.appendTo(parentNode, context);
+  }
+
+  prependToTopmostMarkdownNode(topmostMarkdownNode, context) {
+    const parentNode = topmostMarkdownNode;  ///
+
+    super.prependTo(parentNode, context);
+  }
+
+  removeFromTopmostMarkdownNode(topmostMarkdownNode, context) {
+    const removedNode = this.divisionMarkdownNode, ///
+          parentNode = topmostMarkdownNode;
+
+    super.removeFrom(removedNode, parentNode, context);
+  }
+
+  static fromDivisionMarkdownNode(Class, divisionMarkdownNode, ...remainingArguments) {
+    const node = divisionMarkdownNode, ///
+          divisionTransform = Transform.fromNode(Class, node, divisionMarkdownNode, ...remainingArguments);
+
+    return divisionTransform;
+  }
+}

package/src/{replacement → transform}/embedDirective.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
 
 import { subDivisionMarkdownNodesFromNode } from "../utilities/query";
 
-export default class EmbedDirectiveReplacement extends Replacement {
+export default class EmbedDirectiveTransform extends Transform {
   addAfterSubDivisionMarkdownNode(subDivisionMarkdownNode, divisionMarkdownNode, subDivisionMarkdownNodes, context) {
     const existingNode = subDivisionMarkdownNode, ///
           parentNode = divisionMarkdownNode;  ///
@@ -27,8 +27,8 @@ export default class EmbedDirectiveReplacement extends Replacement {
 
   static fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens) {
     const node = divisionMarkdownNode,  ///
-          embedDirectiveReplacement = Replacement.fromNodeAndTokens(EmbedDirectiveReplacement, node, tokens);
+          embedDirectiveTransform = Transform.fromNodeAndTokens(EmbedDirectiveTransform, node, tokens);
 
-    return embedDirectiveReplacement;
+    return embedDirectiveTransform;
   }
 }

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

@@ -1,10 +1,10 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
 
 import { footnoteMarkdownNodeFromNode } from "../utilities/query";
 
-export default class FootnoteReplacement extends Replacement {
+export default class FootnoteTransform extends Transform {
   constructor(node, tokens, number) {
     super(node, tokens);
 
@@ -39,15 +39,15 @@ export default class FootnoteReplacement extends Replacement {
     return footnoteMarkdownNode;
   }
 
-  static fromNode(node, ...remainingArguments) { return Replacement.fromNode(FootnoteReplacement, node, ...remainingArguments); }
+  static fromNode(node, ...remainingArguments) { return Transform.fromNode(FootnoteTransform, node, ...remainingArguments); }
 
-  static fromFootnoteSubDivisionReplacement(footnoteSubDivisionReplacement) {
-    const node = footnoteSubDivisionReplacement.getNode(),
+  static fromFootnoteSubDivisionTransform(footnoteSubDivisionTransform) {
+    const node = footnoteSubDivisionTransform.getNode(),
           footnoteMarkdownNode = footnoteMarkdownNodeFromNode(node),
           descendentNode = footnoteMarkdownNode,  ///
           number = null,
-          footnoteReplacement = footnoteSubDivisionReplacement.contract(FootnoteReplacement, descendentNode, number);
+          footnoteTransform = footnoteSubDivisionTransform.contract(FootnoteTransform, descendentNode, number);
 
-    return footnoteReplacement;
+    return footnoteTransform;
   }
 }

package/src/transform/footnotesItem.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { Transform } from "occam-dom";
+
+import FootnotesItemMarkdownNode from "../node/markdown/footnotesItem";
+
+export default class FootnotesItemTransform extends Transform {
+  getFootnotesItemMarkdownNode() {
+    const node = this.getNode(),
+          footnotesItemMarkdownNode = node; ///
+
+    return footnotesItemMarkdownNode;
+  }
+
+  static fromNode(node, context) { return Transform.fromNode(FootnotesItemTransform, node, context); }
+
+  static fromFootnoteTransformAndIdentifier(footnoteTransform, identifier) {
+      const footnoteMarkdownNode = footnoteTransform.getFootnoteMarkdownNode(),
+            footnotesItemMarkdownNode = FootnotesItemMarkdownNode.fromFootnotesMarkdownNodeAndIdentifier(footnoteMarkdownNode, identifier),
+            ascendantNode = footnotesItemMarkdownNode, ///
+            footnotesItemTransform = footnoteTransform.expand(FootnotesItemTransform, ascendantNode);
+
+    return footnotesItemTransform;
+  }
+}

package/src/transform/footnotesList.js

@@ -0,0 +1,79 @@
+"use strict";
+
+import { Transform } from "occam-dom";
+
+import FootnotesItemTransform from "../transform/footnotesItem";
+import FootnotesListMarkdownNode from "../node/markdown/footnotesList";
+
+import { footnoteLinkMarkdownNodesFromNode } from "../utilities/query";
+
+export default class FootnotesListTransform extends Transform {
+  replaceFootnotesDirectiveSubDivisionTransform(footnotesDirectiveSubDivisionTransform, divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = footnotesDirectiveSubDivisionTransform.getSubDivisionMarkdownNode(),
+          replacedNode = subDivisionMarkdownNode, ///
+          parentNode = divisionMarkdownNode;  ///
+
+    super.replace(replacedNode, parentNode, context)
+  }
+
+  static fromDivisionMarkdownNodeAndFootnoteTransformMap(divisionMarkdownNode, footnoteTransformMap, context) {
+    let footnotesListTransform = null;
+
+    const node = divisionMarkdownNode,  ///
+          start = startFromFootnoteTransformMap(footnoteTransformMap),
+          footnoteLinkMarkdownNodes = footnoteLinkMarkdownNodesFromNode(node),
+          footnotesItemTransforms = [];
+
+    let number = start;
+
+    footnoteLinkMarkdownNodes.forEach((footnoteLinkMarkdownNode) => {
+      const identifier = footnoteLinkMarkdownNode.identifier(context),
+            footnoteTransform = footnoteTransformMap[identifier] || null;
+
+      if (footnoteTransform !== null) {
+        const footnoteTransformUnnumbered = footnoteTransform.isUnnumbered();
+
+        if (footnoteTransformUnnumbered) {
+          const footnotesItemTransform = FootnotesItemTransform.fromFootnoteTransformAndIdentifier(footnoteTransform, identifier, context);
+
+          footnotesItemTransforms.push(footnotesItemTransform);
+
+          footnoteTransform.setNumber(number);
+
+          number++;
+        }
+      }
+    });
+
+    const footnotesItemTransformsLength = footnotesItemTransforms.length;
+
+    if (footnotesItemTransformsLength > 0) {
+      const footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemTransformsAndStart(footnotesItemTransforms, start),
+            node = footnotesListMarkdownNode, ///
+            tokens = [];
+
+      footnotesItemTransforms.forEach((footnotesItemTransform) => {
+        footnotesItemTransform.getTokens(tokens);
+      });
+
+      footnotesListTransform = Transform.fromNodeAndTokens(FootnotesListTransform, node, tokens);
+    }
+
+    return footnotesListTransform;
+  }
+}
+
+function startFromFootnoteTransformMap(footnoteTransformMap) {
+  const footnoteTransforms = Object.values(footnoteTransformMap),  ///
+        numberedFootnoteTransforms = footnoteTransforms.filter((footnoteTransform) => {
+          const footnoteTransformNumbered = footnoteTransform.isNumbered();
+
+          if (footnoteTransformNumbered) {
+            return true;
+          }
+        }),
+        numberedFootnoteTransformsLength = numberedFootnoteTransforms.length,
+        start = numberedFootnoteTransformsLength + 1;
+
+  return start;
+}

package/src/{replacement → transform}/includeDirective.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
 
 import { subDivisionMarkdownNodesFromNode } from "../utilities/query";
 
-export default class IncludeDirectiveReplacement extends Replacement {
+export default class IncludeDirectiveTransform extends Transform {
   addDivisionMarkdownNode(context) {
     const divisionMarkdownNode = this.getDivisionMarkdownNode(),
           ignored = divisionMarkdownNode.isIgnored();
@@ -42,8 +42,8 @@ export default class IncludeDirectiveReplacement extends Replacement {
 
   static fromDivisionMarkdownNodeAndTokens(divisionMarkdownNode, tokens) {
     const node = divisionMarkdownNode,  ///
-          includeDirectiveReplacement = Replacement.fromNodeAndTokens(IncludeDirectiveReplacement, node, tokens);
+          includeDirectiveTransform = Transform.fromNodeAndTokens(IncludeDirectiveTransform, node, tokens);
 
-    return includeDirectiveReplacement;
+    return includeDirectiveTransform;
   }
 }

package/src/transform/index.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import { Transform, transformUtilities } from "occam-dom";
+
+import letters from "../letters";
+import IndexList from "../index/list";
+import IndexListTransform from "../transform/indexList";
+import IndexHeadingTransform from "../transform/indexHeading";
+
+const { replaceNodes, replaceTokens } = transformUtilities;
+
+export default class IndexTransform extends Transform {
+  constructor(node, tokens, nodes) {
+    super(node, tokens);
+
+    this.nodes = nodes;
+  }
+
+  getNodes() {
+    return this.nodes;
+  }
+
+  replace(replacedNode, parentNode, context) {
+    let tokens;
+
+    tokens = this.getTokens();
+
+    const replacementNodes = this.nodes,  ///
+          replacementTokens = tokens; ///
+
+    ({ tokens } = context);
+
+    replaceNodes(replacementNodes, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
+  }
+
+  replaceIndexDirectiveSubdivisionTransform(indexDirectiveSubDivisionTransform, divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = indexDirectiveSubDivisionTransform.getSubDivisionMarkdownNode(),
+          replacedNode = subDivisionMarkdownNode, ///
+          parentNode = divisionMarkdownNode;  ///
+
+    this.replace(replacedNode, parentNode, context)
+  }
+
+  static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+    let indexTransform = null;
+
+    const indexList = IndexList.fromDivisionMarkdownNodes(divisionMarkdownNodes, context),
+          indexTransforms = [];
+
+    letters.forEach((letter) => {
+      const indexListTransform = IndexListTransform.fromIndexListAndLetter(indexList, letter, context);
+
+      if (indexListTransform !== null) {
+        let indexTransform;
+
+        const indexHeadingTransform = IndexHeadingTransform.fromLetter(letter, context);
+
+        indexTransform = indexHeadingTransform; ///
+
+        indexTransforms.push(indexTransform);
+
+        indexTransform = indexListTransform;  ///
+
+        indexTransforms.push(indexTransform);
+      }
+    });
+
+    const indexListTransformsLength = indexTransforms.length;
+
+    if (indexListTransformsLength > 0) {
+      const node = null,
+            nodes = [],
+            tokens = [];
+
+      indexTransforms.forEach((indexTransform) => {
+        const node = indexTransform.getNode();
+
+        indexTransform.getTokens(tokens);
+
+        nodes.push(node);
+      });
+
+      indexTransform = Transform.fromNodeAndTokens(IndexTransform, node, tokens, nodes);
+    }
+
+    return indexTransform;
+  }
+}

package/src/{replacement → transform}/indexAnchor.js

@@ -1,11 +1,12 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
+
 import AnchorMarkdownNode from "../node/markdown/anchor";
 
 import { INDEX_PREPEND } from "../prepends";
 
-export default class IndexAnchorReplacement extends Replacement {
+export default class IndexAnchorTransform extends Transform {
   getAnchorMarkdownNode() {
     const node = this.getNode(),
           anchorMarkdownNode = node;  ///
@@ -19,8 +20,8 @@ export default class IndexAnchorReplacement extends Replacement {
           anchorMarkdownNode = AnchorMarkdownNode.fromPrependAndIdentifier(prepend, identifier),
           node = anchorMarkdownNode,  ///
           tokens = [],
-          indexAnchorReplacement = Replacement.fromNodeAndTokens(IndexAnchorReplacement, node, tokens);
+          indexAnchorTransform = Transform.fromNodeAndTokens(IndexAnchorTransform, node, tokens);
 
-    return indexAnchorReplacement;
+    return indexAnchorTransform;
   }
 }

package/src/{replacement → transform}/indexHeading.js

@@ -1,18 +1,18 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
 
 import { INDEX_HEADING_RULE_NAME } from "../ruleNames";
 
-export default class IndexHeadingReplacement extends Replacement {
+export default class IndexHeadingTransform extends Transform {
   static fromLetter(letter, context) {
     const { nodeFromTokens, tokensFromContent } = context,  ///
           startRuleName = INDEX_HEADING_RULE_NAME,
           content = `${letter}`,
           tokens = tokensFromContent(content),
           node = nodeFromTokens(tokens, startRuleName),
-          indexHeadingReplacement = Replacement.fromNodeAndTokens(IndexHeadingReplacement, node, tokens);
+          indexHeadingTransform = Transform.fromNodeAndTokens(IndexHeadingTransform, node, tokens);
 
-    return indexHeadingReplacement;
+    return indexHeadingTransform;
   }
 }

package/src/{replacement → transform}/indexItem.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
 
 import { COMMA } from "../constants";
 import { INDEX_ITEM_RULE_NAME } from "../ruleNames";
 
-export default class IndexItemReplacement extends Replacement {
+export default class IndexItemTransform extends Transform {
   getIndexItemMarkdownNode() {
     const node = this.getNode(),
           indexItemMarkdownNode = node; ///
@@ -22,8 +22,8 @@ export default class IndexItemReplacement extends Replacement {
           startRuleName = INDEX_ITEM_RULE_NAME,
           tokens = tokensFromContent(content),
           node = nodeFromTokens(tokens, startRuleName),
-          indexItemReplacement = Replacement.fromNodeAndTokens(IndexItemReplacement, node, tokens);
+          indexItemTransform = Transform.fromNodeAndTokens(IndexItemTransform, node, tokens);
 
-    return indexItemReplacement;
+    return indexItemTransform;
   }
 }

package/src/transform/indexList.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { Transform } from "occam-dom";
+
+import IndexItemTransform from "../transform/indexItem";
+import IndexListMarkdownNode from "../node/markdown/indexList";
+
+export default class IndexListTransform extends Transform {
+  static fromIndexListAndLetter(indexList, letter, context) {
+    let indexListTransform = null;
+
+    const indexItemTransforms = indexList.reduceIndexItemByLetter(letter, (indexItem) => {
+            const indexItemTransform = IndexItemTransform.fromIndexItem(indexItem, context);
+
+            return indexItemTransform;
+          }),
+          indexItemTransformsLength = indexItemTransforms.length;
+
+    if (indexItemTransformsLength > 0) {
+      const indexListMarkdownNode = IndexListMarkdownNode.fromIndexItemTransforms(indexItemTransforms),
+            node = indexListMarkdownNode, ///
+            tokens = [];
+
+      indexItemTransforms.forEach((indexItemTransform) => {
+        indexItemTransform.getTokens(tokens);
+      });
+
+      indexListTransform = Transform.fromNodeAndTokens(IndexListTransform, node, tokens);
+    }
+
+    return indexListTransform;
+  }
+}

package/src/{replacement → transform}/line.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import Replacement from "../replacement";
+import { Transform } from "occam-dom";
 
-export default class LineReplacement extends Replacement {
+export default class LineTransform extends Transform {
   getLineMarkdownNode() {
     const node = this.getNode(),
           lineMarkdownNode = node;  ///
@@ -12,8 +12,8 @@ export default class LineReplacement extends Replacement {
 
   static fromLineMarkdownNode(lineMarkdownNode, context) {
     const node = lineMarkdownNode,  ///
-          lineReplacement = Replacement.fromNode(LineReplacement, node, context);
+          lineTransform = Transform.fromNode(LineTransform, node, context);
 
-    return lineReplacement;
+    return lineTransform;
   }
 }

package/src/transform/subDivision/contentsDirective.js

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

package/src/transform/subDivision/embedDirectives.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import SubDivisionTransform from "../division";
+
+import { embedDirectiveMarkdownNodesFromNode } from "../../utilities/query";
+
+const { backwardsForEach } = arrayUtilities;
+
+export default class EmbedDirectivesSubDivisionTransform extends SubDivisionTransform {
+  constructor(node, tokens, divisionMarkdownNode, embedDirectiveMarkdownNodes) {
+    super(node, tokens, divisionMarkdownNode);
+
+    this.embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodes;
+  }
+
+  getEmbedDirectiveMarkdownNodes() {
+    return this.embedDirectiveMarkdownNodes;
+  }
+
+  replaceSubDivisionMarkdownNode(divisionMarkdownNode, context) {
+    // const subDivisionMarkdownNodes = [],
+    //       divisionMarkdownNode = this.getDivisionMarkdownNode();
+    //
+    // backwardsForEach(this.embedDirectiveMarkdownNodes, (embedDirectiveMarkdownNode) => {
+    //   const embedDirectiveTransform = embedDirectiveMarkdownNode.resolve(context);
+    //
+    //   if (embedDirectiveTransform !== null) {
+    //     embedDirectiveTransform.addAfterSubDivisionMarkdownNode(divisionMarkdownNode, divisionMarkdownNode, subDivisionMarkdownNodes, context);
+    //   }
+    // });
+    //
+    // this.removeFromDivisionMarkdownNode(divisionMarkdownNode, context);
+
+    return subDivisionMarkdownNodes;
+  }
+
+  static fromSubDivisionMarkdownNode(divisionMarkdownNode, context) {
+    let embedDirectivesSubDivisionTransform = null;
+
+    const node = divisionMarkdownNode, ///
+          embedDirectiveMarkdownNodes = embedDirectiveMarkdownNodesFromNode(node),
+          embedDirectiveMarkdownNodesLength = embedDirectiveMarkdownNodes.length;
+
+    if (embedDirectiveMarkdownNodesLength > 0) {
+      embedDirectivesSubDivisionTransform = SubDivisionTransform.fromSubDivisionMarkdownNode(EmbedDirectivesSubDivisionTransform, divisionMarkdownNode, embedDirectiveMarkdownNodes, context);
+    }
+
+    return embedDirectivesSubDivisionTransform;
+  }
+}