highmark-markdown 0.0.433 → 0.0.435

package/src/defaultMarkdownStyle.js

@@ -179,11 +179,28 @@ footnotesItem {
 }
 
 indexList {
+  margin: 0;
   list-style-type: none;
 }
 
+indexHeading {
+  font-size: 17pt;
+  line-height: 1;
+  font-weight: normal;
+  font-family: "Computer Modern Sans";
+  text-transform: uppercase;
+}
+
+indexHeading {
+  margin: 13pt 0 0 0;
+
+  :first-child {
+    margin-top: 0;
+  }
+}
+
 indexItem {
-  margin-left: 0;
+  margin: 0;
 }
 
 indexLink {

package/src/elementMap.js

@@ -27,6 +27,7 @@ import { LINE_RULE_NAME,
          STRONG_TEXT_RULE_NAME,
          SUB_DIVISION_RULE_NAME,
          ORDERED_LIST_RULE_NAME,
+         INDEX_HEADING_RULE_NAME,
          BLOCK_LISTING_RULE_NAME,
          CONTENTS_LINK_RULE_NAME,
          CONTENTS_ITEM_RULE_NAME,
@@ -167,6 +168,10 @@ const elementMap = {
     tagName: "ol",
     className: null
   },
+  [INDEX_HEADING_RULE_NAME]: {
+    tagName: "h3",
+    className: "index"
+  },
   [BLOCK_LISTING_RULE_NAME]: {
     tagName: "pre",
     className: "block"

package/src/example/importer.js

@@ -72,6 +72,8 @@ const indexContent = `## Index
 
       introductionContent = `# Introduction
       
+CLI      
+      
 I have tried to make Occam[^occam] as useable as possible but there are limits.
 At the end of the day it is an expert system and some of its parts, not least the verifier, need detailed explanation.
 It is the purpose of this book is to provide these explanations.
@@ -88,6 +90,8 @@ This book explains how this is possible.
 
       gettingStartedContent = `# Getting started
       
+CLI      
+      
 Another short paragraph with a reference to a footnote[^occam].
 
 [^occam]: The word Occam is used somewhat nebulously here.
@@ -104,10 +108,11 @@ This book explains these divers parts and there is a companion book, called The
 @pageNumber
 `,
 
-      installingTheCLIContent = `## Installing the CLI`,
+      installingTheCLIContent = `## Installing the CLI
+`,
 
       gettingToGripsWithTheIDEIContent = `## Getting to grips with the IDE
-      
+            
 * An unordered list to test...
 * ...the indexing.
       

package/src/index/item.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { first } = arrayUtilities;
+
+export default class IndexItem {
+  constructor(lowerCaseLetter, wordOrPhrase, pageNumbers) {
+    this.lowerCaseLetter = lowerCaseLetter;
+    this.wordOrPhrase = wordOrPhrase;
+    this.pageNumbers = pageNumbers;
+  }
+
+  getLowerCaseLetter() {
+    return this.lowerCaseLetter;
+  }
+
+  getWordOrPhrase() {
+    return this.wordOrPhrase;
+  }
+
+  getPageNumbers() {
+    return this.pageNumbers;
+  }
+
+  matchLetter(letter) {
+    const matchesLetter = (this.lowerCaseLetter === letter);
+
+    return matchesLetter;
+  }
+
+  static fromWordOrPhraseAndPageNumbers(wordOrPhrase, pageNumbers) {
+    const lowerCaseWordOrPhrase = wordOrPhrase.toLowerCase(),
+          lowerCaseLetters = [
+            ...lowerCaseWordOrPhrase
+          ],
+          firstLowerCaseLetter = first(lowerCaseLetters),
+          lowerCaseLetter = firstLowerCaseLetter, ///
+          indexItem = new IndexItem(lowerCaseLetter, wordOrPhrase, pageNumbers);
+
+    return indexItem;
+  }
+}

package/src/index/list.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import { stringUtilities } from "necessary";
+
+import IndexItem from "../index/item";
+
+import { indexMapFromDivisionMarkdownNodes } from "../utilities/index";
+
+const { strcmp } = stringUtilities;
+
+export default class IndexList {
+  constructor(indexItems) {
+    this.indexItems = indexItems;
+  }
+
+  getIndexItems() {
+    return this.indexItems;
+  }
+
+  reduceIndexItemByLetter(letter, callback) {
+    const indexItems = this.indexItems.filter((indexItem) => {
+      const indexItemMatchesLetter = indexItem.matchLetter(letter);
+
+      if (indexItemMatchesLetter) {
+        return true;
+      }
+    });
+
+    const result = indexItems.map(callback);
+
+    return result;
+  }
+
+  static fromDivisionMarkdownNodes(divisionMarkdownNodes, context) {
+    const indexMap = indexMapFromDivisionMarkdownNodes(divisionMarkdownNodes, context),
+          indexItems = indexItemsFromIndexMap(indexMap),
+          indexList = new IndexList(indexItems);
+
+    return indexList;
+  }
+}
+
+function indexItemsFromIndexMap(indexMap) {
+  const wordsOrPhrases = Object.keys(indexMap); ///
+
+  wordsOrPhrases.sort((wordOrPhraseA, wordOrPhraseB) => {
+    const lowerCaseWordOrPhraseA = wordOrPhraseA.toLowerCase(),
+          lowerCaseWordOrPhraseB = wordOrPhraseB.toLowerCase(),
+          difference = strcmp(lowerCaseWordOrPhraseB, lowerCaseWordOrPhraseA);
+
+    return difference;
+  });
+
+  const indexItems = wordsOrPhrases.map((wordOrPhrase, index) => {
+    const pageNumbers = indexMap[wordOrPhrase],
+          indexItem = IndexItem.fromWordOrPhraseAndPageNumbers(wordOrPhrase, pageNumbers);
+
+    return indexItem;
+  })
+
+  return indexItems;
+}

package/src/index/{phraseMatcher.js → match.js}

@@ -2,7 +2,7 @@
 
 import { UNDERSCORE, GLOBAL_FLAG, SINGLE_SPACE } from "../constants";
 
-export default class PhraseMatcher {
+export default class IndexMatch {
   constructor(regularExpression, replacement) {
     this.regularExpression = regularExpression;
     this.replacement = replacement;
@@ -22,17 +22,17 @@ export default class PhraseMatcher {
     return plainText;
   }
 
-  static revert(entry) {
-    entry = entry.replace(/_/g, SINGLE_SPACE);
+  static revert(wordOrPhrase) {
+    wordOrPhrase = wordOrPhrase.replace(/_/g, SINGLE_SPACE);
 
-    return entry;
+    return wordOrPhrase;
   }
 
   static fromPhrase(phrase) {
     const regularExpression = new RegExp(phrase, GLOBAL_FLAG),
           replacement = phrase.replace(/\s/g, UNDERSCORE),
-          phraseMatcher = new PhraseMatcher(regularExpression, replacement);
+          indexMatch = new IndexMatch(regularExpression, replacement);
 
-    return phraseMatcher;
+    return indexMatch;
   }
 }

package/src/letters.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const letters = [
+  "a",
+  "b",
+  "c",
+  "d",
+  "e",
+  "f",
+  "g",
+  "h",
+  "i",
+  "j",
+  "k",
+  "l",
+  "m",
+  "n",
+  "o",
+  "p",
+  "q",
+  "r",
+  "s",
+  "t",
+  "u",
+  "v",
+  "w",
+  "x",
+  "y",
+  "z"
+];
+
+export default letters;

package/src/markdown/bnf.js

@@ -260,10 +260,13 @@ const bnf = `
     footnotesItem           ::=  anchor paragraph ;
 
 
+    indexHeading            ::=  line ;
+    
+    
     indexList               ::=  indexItem+ ;
 
 
-    indexItem               ::=  line... indexLink ( comma indexLink )* ;
+    indexItem               ::=  line... comma indexLink ( comma indexLink )* ;
 
 
     indexLink               ::=  [number] ;    

package/src/node/markdown/division.js

@@ -3,8 +3,8 @@
 import { arrayUtilities } from "necessary";
 
 import MarkdownNode from "../../node/markdown";
+import IndexReplacement from "../../replacement/index";
 import FootnoteReplacement from "../../replacement/footnote";
-import IndexListReplacement from "../../replacement/indexList";
 import ContentsListReplacement from "../../replacement/contentsList";
 import FootnotesListReplacement from "../../replacement/footnotesList";
 import FootnoteSubDivisionReplacement from "../../replacement/subDivision/footnote";
@@ -139,10 +139,10 @@ export default class DivisionMarkdownNode extends MarkdownNode {
 
     if (indexDirectiveSubDivisionReplacement !== null) {
       const divisionMarkdownNode = this,  ///
-            indexListReplacement = IndexListReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
+            indexReplacement = IndexReplacement.fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context);
 
-      if (indexListReplacement !== null) {
-        indexListReplacement.replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
+      if (indexReplacement !== null) {
+        indexReplacement.replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context);
 
         indexCreated = true;
       }

package/src/node/markdown/footnotesList.js

@@ -31,22 +31,15 @@ export default class FootnotesListMarkdownNode extends MarkdownNode {
   clone() { return super.clone(this.start); }
 
   static fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start) {
-    let footnotesListMarkdownNode = null;
-
-    const footnotesItemReplacementsLength = footnotesItemReplacements.length;
-
-    if (footnotesItemReplacementsLength > 0) {
-      const ruleName = FOOTNOTES_LIST_RULE_NAME,
-            childNodes = footnotesItemReplacements.map((footnotesItemReplacement) => {
-              const footnotesItemReplacementMode = footnotesItemReplacement.getFootnotesItemMarkdownNode(),
-                    childNode = footnotesItemReplacementMode; ///
-
-              return childNode;
-            }),
-            opacity = null;
-
-      footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
-    }
+    const ruleName = FOOTNOTES_LIST_RULE_NAME,
+          childNodes = footnotesItemReplacements.map((footnotesItemReplacement) => {
+            const footnotesItemReplacementMode = footnotesItemReplacement.getFootnotesItemMarkdownNode(),
+                  childNode = footnotesItemReplacementMode; ///
+
+            return childNode;
+          }),
+          opacity = null,
+          footnotesListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(FootnotesListMarkdownNode, ruleName, childNodes, opacity, start);
 
     return footnotesListMarkdownNode;
   }

package/src/node/markdown/indexHeading.js

@@ -0,0 +1,7 @@
+"use strict";
+
+import MarkdownNode from "../../node/markdown";
+
+export default class IndexHeadingMarkdownNode extends MarkdownNode {
+  static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexHeadingMarkdownNode, ruleName, childNodes, opacity); }
+}

package/src/node/markdown/indexItem.js

@@ -3,5 +3,25 @@
 import MarkdownNode from "../../node/markdown";
 
 export default class IndexItemMarkdownNode extends MarkdownNode {
+  asHTML(indent, context) {
+    indent = this.adjustIndent(indent);
+
+    const childNodesHTML = this.childNodesAsHTML(indent, context),
+          startingTag = this.startingTag(context),
+          closingTag = this.closingTag(context),
+          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
+`;
+
+    return html;
+  }
+
+  childNodesAsHTML(indent, context) {
+    indent = null;
+
+    const childNodesHTML = super.childNodesAsHTML(indent, context);
+
+    return childNodesHTML;
+  }
+
   static fromRuleNameChildNodesAndOpacity(ruleName, childNodes, opacity) { return MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexItemMarkdownNode, ruleName, childNodes, opacity); }
 }

package/src/node/markdown/indexLink.js

@@ -24,13 +24,10 @@ export default class IndexLinkMarkdownNode extends MarkdownNode {
   }
 
   asHTML(indent, context) {
-    indent = this.adjustIndent(indent);
-
     const childNodesHTML = this.childNodesAsHTML(indent, context),
           startingTag = this.startingTag(context),
           closingTag = this.closingTag(context),
-          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
-`;
+          html = `${startingTag}${childNodesHTML}${closingTag}`;
 
     return html;
   }

package/src/node/markdown/indexList.js

@@ -12,22 +12,15 @@ export default class IndexListMarkdownNode extends MarkdownNode {
   }
 
   static fromIndexItemReplacements(indexItemReplacements) {
-    let indexListMarkdownNode = null;
-
-    const indexItemReplacementsLength = indexItemReplacements.length;
-
-    if (indexItemReplacementsLength > 0) {
-      const ruleName = INDEX_LIST_RULE_NAME,
-            childNodes = indexItemReplacements.map((indexItemReplacement) => {
-              const indexItemReplacementNode = indexItemReplacement.getIndexItemMarkdownNode(),
-                    childNode = indexItemReplacementNode;  ///
-
-              return childNode;
-            }),
-            opacity = null;
-
-      indexListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexListMarkdownNode, ruleName, childNodes, opacity);
-    }
+    const ruleName = INDEX_LIST_RULE_NAME,
+          childNodes = indexItemReplacements.map((indexItemReplacement) => {
+            const indexItemReplacementNode = indexItemReplacement.getIndexItemMarkdownNode(),
+                  childNode = indexItemReplacementNode;  ///
+
+            return childNode;
+          }),
+          opacity = null,
+          indexListMarkdownNode = MarkdownNode.fromRuleNameChildNodesAndOpacity(IndexListMarkdownNode, ruleName, childNodes, opacity);
 
     return indexListMarkdownNode;
   }

package/src/node/markdown/line.js

@@ -21,8 +21,9 @@ export default class LineMarkdownNode extends MarkdownNode {
     const childNodesHTML = this.childNodesAsHTML(indent, context),
           startingTag = this.startingTag(context),
           closingTag = this.closingTag(context),
-          html = `${indent}${startingTag}${childNodesHTML}${closingTag}
-`;
+          html = (indent !== null) ?
+                  `${indent}${startingTag}${childNodesHTML}${closingTag}
+`:                  `${startingTag}${childNodesHTML}${closingTag}`;
 
     return html;
   }

package/src/nodeMap.js

@@ -27,6 +27,7 @@ import InlineTextMarkdownNode from "./node/markdown/inlineText";
 import StrongTextMarkdownNode from "./node/markdown/strongText";
 import SubDivisionMarkdownNode from "./node/markdown/subDivision";
 import OrderedListMarkdownNode from "./node/markdown/orderedList";
+import IndexHeadingMarkdownNode from "./node/markdown/indexHeading";
 import BlockListingMarkdownNode from "./node/markdown/blockListing";
 import TableHeadRowMarkdownNode from "./node/markdown/tableHeadRow";
 import TableBodyRowMarkdownNode from "./node/markdown/tableBodyRow";
@@ -87,11 +88,12 @@ import { LINE_RULE_NAME,
          STRONG_TEXT_RULE_NAME,
          SUB_DIVISION_RULE_NAME,
          ORDERED_LIST_RULE_NAME,
-         FOOTNOTE_LINK_RULE_NAME,
+         INDEX_HEADING_RULE_NAME,
          BLOCK_LISTING_RULE_NAME,
          CONTENTS_LINK_RULE_NAME,
          CONTENTS_ITEM_RULE_NAME,
          CONTENTS_LIST_RULE_NAME,
+         FOOTNOTE_LINK_RULE_NAME,
          TABLE_HEAD_ROW_RULE_NAME,
          TABLE_BODY_ROW_RULE_NAME,
          INLINE_LISTING_RULE_NAME,
@@ -148,6 +150,7 @@ const nodeMap = {
   [STRONG_TEXT_RULE_NAME]: StrongTextMarkdownNode,
   [SUB_DIVISION_RULE_NAME]: SubDivisionMarkdownNode,
   [ORDERED_LIST_RULE_NAME]: OrderedListMarkdownNode,
+  [INDEX_HEADING_RULE_NAME]: IndexHeadingMarkdownNode,
   [BLOCK_LISTING_RULE_NAME]: BlockListingMarkdownNode,
   [CONTENTS_LINK_RULE_NAME]: ContentsLinkMarkdownNode,
   [CONTENTS_ITEM_RULE_NAME]: ContentsItemMarkdownNode,

package/src/replacement/footnotesList.js

@@ -44,10 +44,11 @@ export default class FootnotesListReplacement extends Replacement {
       }
     });
 
-    const footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start);
+    const footnotesItemReplacementsLength = footnotesItemReplacements.length;
 
-    if (footnotesListMarkdownNode !== null) {
-      const node = footnotesListMarkdownNode, ///
+    if (footnotesItemReplacementsLength > 0) {
+      const footnotesListMarkdownNode = FootnotesListMarkdownNode.fromFootnotesItemReplacementsAndStart(footnotesItemReplacements, start),
+            node = footnotesListMarkdownNode, ///
             tokens = [];
 
       footnotesItemReplacements.forEach((footnotesItemReplacement) => {

package/src/replacement/index.js

@@ -0,0 +1,98 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import letters from "../letters";
+import IndexList from "../index/list";
+import IndexListReplacement from "../replacement/indexList";
+import IndexHeadingReplacement from "./indexHeading";
+
+import { replaceNodes, replaceTokens } from "../utilities/replacement";
+
+export default class IndexReplacement extends Replacement {
+  constructor(node, tokens, nodes) {
+    super(node, tokens);
+
+    this.nodes = nodes;
+  }
+
+  getNodes() {
+    return this.nodes;
+  }
+
+  getReplacementNodes() {
+    const replacementNodes = this.nodes;  ///
+
+    return replacementNodes;
+  }
+
+  getReplacementTokens() {
+    const tokens = this.getTokens(),
+          replacementTokens = tokens; ///
+
+    return replacementTokens;
+  }
+
+  replace(replacedNode, parentNode, context) {
+    const { tokens } = context,
+          replacementNodes = this.getReplacementNodes(),
+          replacementTokens = this.getReplacementTokens();
+
+    replaceNodes(replacementNodes, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
+  }
+
+  replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
+    const subDivisionMarkdownNode = indexDirectiveSubDivisionReplacement.getSubDivisionMarkdownNode(),
+          replacedNode = subDivisionMarkdownNode, ///
+          parentNode = divisionMarkdownNode;  ///
+
+    this.replace(replacedNode, parentNode, context)
+  }
+
+  static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+    let indexReplacement = null;
+
+    const indexList = IndexList.fromDivisionMarkdownNodes(divisionMarkdownNodes, context),
+          indexReplacements = [];
+
+    letters.forEach((letter) => {
+      const indexListReplacement = IndexListReplacement.fromIndexListAndLetter(indexList, letter, context);
+
+      if (indexListReplacement !== null) {
+        let indexReplacement;
+
+        const indexHeadingReplacement = IndexHeadingReplacement.fromLetter(letter, context);
+
+        indexReplacement = indexHeadingReplacement; ///
+
+        indexReplacements.push(indexReplacement);
+
+        indexReplacement = indexListReplacement;  ///
+
+        indexReplacements.push(indexReplacement);
+      }
+    });
+
+    const indexListReplacementsLength = indexReplacements.length;
+
+    if (indexListReplacementsLength > 0) {
+      const node = null,
+            nodes = [],
+            tokens = [];
+
+      indexReplacements.forEach((indexReplacement) => {
+        const node = indexReplacement.getNode();
+
+        indexReplacement.getTokens(tokens);
+
+        nodes.push(node);
+      });
+
+      indexReplacement = Replacement.fromNodeAndTokens(IndexReplacement, node, tokens, nodes);
+    }
+
+    return indexReplacement;
+  }
+}

package/src/replacement/indexHeading.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import Replacement from "../replacement";
+
+import { INDEX_HEADING_RULE_NAME } from "../ruleNames";
+
+export default class IndexHeadingReplacement extends Replacement {
+  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);
+
+    return indexHeadingReplacement;
+  }
+}

package/src/replacement/indexItem.js

@@ -13,11 +13,12 @@ export default class IndexItemReplacement extends Replacement {
     return indexItemMarkdownNode;
   }
 
-  static fromEntryAndPageNumbers(entry, pageNumbers, context) {
+  static fromIndexItem(indexItem, context) {
     const { nodeFromTokens, tokensFromContent } = context,
-          entryContent = entry, ///
+          wordOrPhrase = indexItem.getWordOrPhrase(),
+          pageNumbers = indexItem.getPageNumbers(),
           pageNumbersContent = pageNumbers.join(COMMA),
-          content = `${entryContent} ${pageNumbersContent}`,
+          content = `${wordOrPhrase},${pageNumbersContent}`,
           startRuleName = INDEX_ITEM_RULE_NAME,
           tokens = tokensFromContent(content),
           node = nodeFromTokens(tokens, startRuleName),

package/src/replacement/indexList.js

@@ -1,36 +1,23 @@
 "use strict";
 
 import Replacement from "../replacement";
-
 import IndexItemReplacement from "../replacement/indexItem";
 import IndexListMarkdownNode from "../node/markdown/indexList";
 
-import { indexMapFromDivisionMarkdownNodes } from "../utilities/index";
-
 export default class IndexListReplacement extends Replacement {
-  replaceIndexDirectiveSubdivisionReplacement(indexDirectiveSubDivisionReplacement, divisionMarkdownNode, context) {
-    const subDivisionMarkdownNode = indexDirectiveSubDivisionReplacement.getSubDivisionMarkdownNode(),
-          replacedNode = subDivisionMarkdownNode, ///
-          parentNode = divisionMarkdownNode;  ///
-
-    super.replace(replacedNode, parentNode, context)
-  }
-
-  static fromDivisionMarkdownNodesAndDivisionMarkdownNode(divisionMarkdownNodes, divisionMarkdownNode, context) {
+  static fromIndexListAndLetter(indexList, letter, context) {
     let indexListReplacement = null;
 
-    const indexMap = indexMapFromDivisionMarkdownNodes(divisionMarkdownNodes, context),
-          entries = Object.keys(indexMap), ///
-          indexItemReplacements = entries.map((entry) => {
-            const pageNumbers = indexMap[entry],
-                  indexItemReplacement = IndexItemReplacement.fromEntryAndPageNumbers(entry, pageNumbers, context);
+    const indexItemReplacements = indexList.reduceIndexItemByLetter(letter, (indexItem) => {
+            const indexItemReplacement = IndexItemReplacement.fromIndexItem(indexItem, context);
 
             return indexItemReplacement;
           }),
-          indexListMarkdownNode = IndexListMarkdownNode.fromIndexItemReplacements(indexItemReplacements);
+          indexItemReplacementsLength = indexItemReplacements.length;
 
-    if (indexListMarkdownNode !== null) {
-      const node = indexListMarkdownNode, ///
+    if (indexItemReplacementsLength > 0) {
+      const indexListMarkdownNode = IndexListMarkdownNode.fromIndexItemReplacements(indexItemReplacements),
+            node = indexListMarkdownNode, ///
             tokens = [];
 
       indexItemReplacements.forEach((indexItemReplacement) => {