markdownlint 0.34.0 → 0.36.0

package/lib/md029.js

@@ -2,9 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, listItemMarkerRe, orderedListItemMarkerRe,
-  rangeFromRegExp } = require("../helpers");
-const { flattenedLists } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const listStyleExamples = {
   "one": "1/1/1",
@@ -12,32 +12,37 @@ const listStyleExamples = {
   "zero": "0/0/0"
 };
 
+/**
+ * Gets the value of an ordered list item prefix token.
+ *
+ * @param {import("../helpers/micromark-helpers.cjs").Token} listItemPrefix List item prefix token.
+ * @returns {number} List item value.
+ */
+function getOrderedListItemValue(listItemPrefix) {
+  return Number(getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0].text);
+}
+
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD029", "ol-prefix" ],
   "description": "Ordered list item prefix",
   "tags": [ "ol" ],
-  "parser": "none",
+  "parser": "micromark",
   "function": function MD029(params, onError) {
     const style = String(params.config.style || "one_or_ordered");
-    const filteredLists = flattenedLists().filter((list) => !list.unordered);
-    for (const list of filteredLists) {
-      const { items } = list;
-      let current = 1;
+    for (const listOrdered of filterByTypesCached([ "listOrdered" ])) {
+      const listItemPrefixes = getDescendantsByType(listOrdered, [ "listItemPrefix" ]);
+      let expected = 1;
       let incrementing = false;
       // Check for incrementing number pattern 1/2/3 or 0/1/2
-      if (items.length >= 2) {
-        const first = orderedListItemMarkerRe.exec(items[0].line);
-        const second = orderedListItemMarkerRe.exec(items[1].line);
-        if (first && second) {
-          const [ , firstNumber ] = first;
-          const [ , secondNumber ] = second;
-          if ((secondNumber !== "1") || (firstNumber === "0")) {
-            incrementing = true;
-            if (firstNumber === "0") {
-              current = 0;
-            }
+      if (listItemPrefixes.length >= 2) {
+        const firstValue = getOrderedListItemValue(listItemPrefixes[0]);
+        const secondValue = getOrderedListItemValue(listItemPrefixes[1]);
+        if ((secondValue !== 1) || (firstValue === 0)) {
+          incrementing = true;
+          if (firstValue === 0) {
+            expected = 0;
           }
         }
       }
@@ -45,24 +50,25 @@ module.exports = {
       let listStyle = style;
       if (listStyle === "one_or_ordered") {
         listStyle = incrementing ? "ordered" : "one";
-      }
-      // Force expected value for 0/0/0 and 1/1/1 patterns
-      if (listStyle === "zero") {
-        current = 0;
+      } else if (listStyle === "zero") {
+        expected = 0;
       } else if (listStyle === "one") {
-        current = 1;
+        expected = 1;
       }
       // Validate each list item marker
-      for (const item of items) {
-        const match = orderedListItemMarkerRe.exec(item.line);
-        if (match) {
-          addErrorDetailIf(onError, item.lineNumber,
-            String(current), match[1],
-            "Style: " + listStyleExamples[listStyle], null,
-            rangeFromRegExp(item.line, listItemMarkerRe));
-          if (listStyle === "ordered") {
-            current++;
-          }
+      for (const listItemPrefix of listItemPrefixes) {
+        const actual = getOrderedListItemValue(listItemPrefix);
+        addErrorDetailIf(
+          onError,
+          listItemPrefix.startLine,
+          expected,
+          actual,
+          "Style: " + listStyleExamples[listStyle],
+          undefined,
+          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ]
+        );
+        if (listStyle === "ordered") {
+          expected++;
         }
       }
     }

package/lib/md030.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -17,13 +17,7 @@ module.exports = {
     const olSingle = Number(params.config.ol_single || 1);
     const ulMulti = Number(params.config.ul_multi || 1);
     const olMulti = Number(params.config.ol_multi || 1);
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const lists = filterByTypes(micromarkTokens, [ "listOrdered", "listUnordered" ]);
-    for (const list of lists) {
+    for (const list of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
       const ordered = (list.type === "listOrdered");
       const listItemPrefixes =
         list.children.filter((token) => (token.type === "listItemPrefix"));
@@ -54,8 +48,8 @@ module.exports = {
             startLine,
             expectedSpaces,
             actualSpaces,
-            null,
-            null,
+            undefined,
+            undefined,
             range,
             fixInfo
           );

package/lib/md031.js

@@ -2,42 +2,64 @@
 
 "use strict";
 
-const { addErrorContext, forEachLine, isBlankLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addErrorContext, isBlankLine } = require("../helpers");
+const { getParentOfType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const codeFencePrefixRe = /^(.*?)[`~]/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @typedef {readonly string[]} ReadonlyStringArray */
+
+/**
+ * Adds an error for the top or bottom of a code fence.
+ *
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {ReadonlyStringArray} lines Lines of Markdown content.
+ * @param {number} lineNumber Line number.
+ * @param {boolean} top True iff top fence.
+ * @returns {void}
+ */
+function addError(onError, lines, lineNumber, top) {
+  const line = lines[lineNumber - 1];
+  const [ , prefix ] = line.match(codeFencePrefixRe) || [];
+  const fixInfo = (prefix === undefined) ?
+    null :
+    {
+      "lineNumber": lineNumber + (top ? 0 : 1),
+      "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
+    };
+  addErrorContext(
+    onError,
+    lineNumber,
+    line.trim(),
+    undefined,
+    undefined,
+    undefined,
+    fixInfo
+  );
+}
+
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD031", "blanks-around-fences" ],
   "description": "Fenced code blocks should be surrounded by blank lines",
   "tags": [ "code", "blank_lines" ],
-  "parser": "none",
+  "parser": "micromark",
   "function": function MD031(params, onError) {
     const listItems = params.config.list_items;
     const includeListItems = (listItems === undefined) ? true : !!listItems;
     const { lines } = params;
-    forEachLine(lineMetadata(), (line, i, inCode, onFence, inTable, inItem) => {
-      const onTopFence = (onFence > 0);
-      const onBottomFence = (onFence < 0);
-      if ((includeListItems || !inItem) &&
-          ((onTopFence && !isBlankLine(lines[i - 1])) ||
-           (onBottomFence && !isBlankLine(lines[i + 1])))) {
-        const [ , prefix ] = line.match(codeFencePrefixRe) || [];
-        const fixInfo = (prefix === undefined) ? null : {
-          "lineNumber": i + (onTopFence ? 1 : 2),
-          "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
-        };
-        addErrorContext(
-          onError,
-          i + 1,
-          lines[i].trim(),
-          null,
-          null,
-          null,
-          fixInfo);
+    for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
+      if (includeListItems || !(getParentOfType(codeBlock, [ "listOrdered", "listUnordered" ]))) {
+        if (!isBlankLine(lines[codeBlock.startLine - 2])) {
+          addError(onError, lines, codeBlock.startLine, true);
+        }
+        if (!isBlankLine(lines[codeBlock.endLine]) && !isBlankLine(lines[codeBlock.endLine - 1])) {
+          addError(onError, lines, codeBlock.endLine, false);
+        }
       }
-    });
+    }
   }
 };

package/lib/md032.js

@@ -2,28 +2,13 @@
 
 "use strict";
 
-const { addErrorContext, blockquotePrefixRe, isBlankLine } = require("../helpers");
-const { filterByPredicate, nonContentTokens } = require("../helpers/micromark.cjs");
+const { addErrorContext, isBlankLine } = require("../helpers");
+const { filterByPredicate, getBlockQuotePrefixText, nonContentTokens } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const isList = (token) => (
   (token.type === "listOrdered") || (token.type === "listUnordered")
 );
-const addBlankLineError = (onError, lines, lineIndex, lineNumber) => {
-  const line = lines[lineIndex];
-  const quotePrefix = line.match(blockquotePrefixRe)[0].trimEnd();
-  addErrorContext(
-    onError,
-    lineIndex + 1,
-    line.trim(),
-    null,
-    null,
-    null,
-    {
-      lineNumber,
-      "insertText": `${quotePrefix}\n`
-    }
-  );
-};
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -33,16 +18,12 @@ module.exports = {
   "tags": [ "bullet", "ul", "ol", "blank_lines" ],
   "parser": "micromark",
   "function": function MD032(params, onError) {
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const { lines } = params;
+    const { lines, parsers } = params;
+    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
 
     // For every top-level list...
     const topLevelLists = filterByPredicate(
-      micromarkTokens,
+      parsers.micromark.tokens,
       isList,
       (token) => (
         (isList(token) || (token.type === "htmlFlow")) ? [] : token.children
@@ -51,9 +32,19 @@ module.exports = {
     for (const list of topLevelLists) {
 
       // Look for a blank line above the list
-      const firstIndex = list.startLine - 1;
-      if (!isBlankLine(lines[firstIndex - 1])) {
-        addBlankLineError(onError, lines, firstIndex);
+      const firstLineNumber = list.startLine;
+      if (!isBlankLine(lines[firstLineNumber - 2])) {
+        addErrorContext(
+          onError,
+          firstLineNumber,
+          lines[firstLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, firstLineNumber)
+          }
+        );
       }
 
       // Find the "visual" end of the list
@@ -67,9 +58,20 @@ module.exports = {
       }
 
       // Look for a blank line below the list
-      const lastIndex = endLine - 1;
-      if (!isBlankLine(lines[lastIndex + 1])) {
-        addBlankLineError(onError, lines, lastIndex, lastIndex + 2);
+      const lastLineNumber = endLine;
+      if (!isBlankLine(lines[lastLineNumber])) {
+        addErrorContext(
+          onError,
+          lastLineNumber,
+          lines[lastLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "lineNumber": lastLineNumber + 1,
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, lastLineNumber)
+          }
+        );
       }
     }
   }

package/lib/md033.js

@@ -3,8 +3,8 @@
 "use strict";
 
 const { addError, nextLinesRe } = require("../helpers");
-const { filterByTypes, getHtmlTagInfo } =
-  require("../helpers/micromark.cjs");
+const { getHtmlTagInfo } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -17,12 +17,7 @@ module.exports = {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    for (const token of filterByTypes(micromarkTokens, [ "htmlText" ])) {
+    for (const token of filterByTypesCached([ "htmlText" ], true)) {
       const htmlTagInfo = getHtmlTagInfo(token);
       if (
         htmlTagInfo &&

package/lib/md034.js

@@ -3,8 +3,7 @@
 "use strict";
 
 const { addErrorContext } = require("../helpers");
-const { filterByPredicate, filterByTypes, getHtmlTagInfo, inHtmlFlow, parse } =
-  require("../helpers/micromark.cjs");
+const { filterByPredicate, getHtmlTagInfo, inHtmlFlow } = require("../helpers/micromark-helpers.cjs");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -14,11 +13,6 @@ module.exports = {
   "tags": [ "links", "url" ],
   "parser": "micromark",
   "function": function MD034(params, onError) {
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
     const literalAutolinks = (tokens) => (
       filterByPredicate(
         tokens,
@@ -26,8 +20,6 @@ module.exports = {
           if ((token.type === "literalAutolink") && !inHtmlFlow(token)) {
             // Detect and ignore https://github.com/micromark/micromark/issues/164
             const siblings = token.parent?.children;
-              // Commented-out due to not being able to exercise in test/code coverage
-              // || micromarkTokens;
             const index = siblings?.indexOf(token);
             // @ts-ignore
             const prev = siblings?.at(index - 1);
@@ -45,6 +37,7 @@ module.exports = {
           return false;
         },
         (token) => {
+          // Ignore content of inline HTML tags
           const { children } = token;
           const result = [];
           for (let i = 0; i < children.length; i++) {
@@ -75,31 +68,25 @@ module.exports = {
         }
       )
     );
-    const autoLinks = filterByTypes(micromarkTokens, [ "literalAutolink" ]);
-    if (autoLinks.length > 0) {
-      // Re-parse with correct link/image reference definition handling
-      const document = params.lines.join("\n");
-      const tokens = parse(document, undefined, false);
-      for (const token of literalAutolinks(tokens)) {
-        const range = [
-          token.startColumn,
-          token.endColumn - token.startColumn
-        ];
-        const fixInfo = {
-          "editColumn": range[0],
-          "deleteCount": range[1],
-          "insertText": `<${token.text}>`
-        };
-        addErrorContext(
-          onError,
-          token.startLine,
-          token.text,
-          null,
-          null,
-          range,
-          fixInfo
-        );
-      }
+    for (const token of literalAutolinks(params.parsers.micromark.tokens)) {
+      const range = [
+        token.startColumn,
+        token.endColumn - token.startColumn
+      ];
+      const fixInfo = {
+        "editColumn": range[0],
+        "deleteCount": range[1],
+        "insertText": `<${token.text}>`
+      };
+      addErrorContext(
+        onError,
+        token.startLine,
+        token.text,
+        undefined,
+        undefined,
+        range,
+        fixInfo
+      );
     }
   }
 };

package/lib/md035.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -14,12 +14,7 @@ module.exports = {
   "parser": "micromark",
   "function": function MD035(params, onError) {
     let style = String(params.config.style || "consistent").trim();
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const thematicBreaks = filterByTypes(micromarkTokens, [ "thematicBreak" ]);
+    const thematicBreaks = filterByTypesCached([ "thematicBreak" ]);
     for (const token of thematicBreaks) {
       const { startLine, text } = token;
       if (style === "consistent") {

package/lib/md036.js

@@ -3,14 +3,15 @@
 "use strict";
 
 const { addErrorContext, allPunctuation } = require("../helpers");
-const { filterByTypes, matchAndGetTokensByType } = require("../helpers/micromark.cjs");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
-/** @typedef {import("../helpers/micromark.cjs").TokenType} TokenType */
-/** @type {Map<TokenType, TokenType[]>} */
-const emphasisAndChildrenTypes = new Map([
-  [ "emphasis", [ "emphasisSequence", "emphasisText", "emphasisSequence" ] ],
-  [ "strong", [ "strongSequence", "strongText", "strongSequence" ] ]
-]);
+/** @typedef {import("../helpers/micromark-helpers.cjs").TokenType} TokenType */
+/** @type {TokenType[][]} */
+const emphasisTypes = [
+  [ "emphasis", "emphasisText" ],
+  [ "strong", "strongText" ]
+];
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -24,25 +25,19 @@ module.exports = {
     punctuation = String((punctuation === undefined) ? allPunctuation : punctuation);
     const punctuationRe = new RegExp("[" + punctuation + "]$");
     const paragraphTokens =
-      filterByTypes(params.parsers.micromark.tokens, [ "paragraph" ]).
-        filter((token) =>
+      filterByTypesCached([ "paragraph" ])
+        .filter((token) =>
           (token.parent?.type === "content") && !token.parent?.parent && (token.children.length === 1)
         );
-    for (const paragraphToken of paragraphTokens) {
-      const childToken = paragraphToken.children[0];
-      for (const [ emphasisType, emphasisChildrenTypes ] of emphasisAndChildrenTypes) {
-        if (childToken.type === emphasisType) {
-          const matchingTokens = matchAndGetTokensByType(childToken.children, emphasisChildrenTypes);
-          if (matchingTokens) {
-            const textToken = matchingTokens[1];
-            if (
-              (textToken.children.length === 1) &&
-              (textToken.children[0].type === "data") &&
-              !punctuationRe.test(textToken.text)
-            ) {
-              addErrorContext(onError, textToken.startLine, textToken.text);
-            }
-          }
+    for (const emphasisType of emphasisTypes) {
+      const textTokens = getDescendantsByType(paragraphTokens, emphasisType);
+      for (const textToken of textTokens) {
+        if (
+          (textToken.children.length === 1) &&
+          (textToken.children[0].type === "data") &&
+          !punctuationRe.test(textToken.text)
+        ) {
+          addErrorContext(onError, textToken.startLine, textToken.text);
         }
       }
     }

package/lib/md037.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addError } = require("../helpers");
-const { filterByPredicate, inHtmlFlow } = require("../helpers/micromark.cjs");
+const { filterByPredicate, inHtmlFlow } = require("../helpers/micromark-helpers.cjs");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -15,18 +15,13 @@ module.exports = {
   "function": function MD037(params, onError) {
 
     // Initialize variables
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const { lines } = params;
+    const { lines, parsers } = params;
     const emphasisTokensByMarker = new Map();
     for (const marker of [ "_", "__", "___", "*", "**", "***" ]) {
       emphasisTokensByMarker.set(marker, []);
     }
     const tokens = filterByPredicate(
-      micromarkTokens,
+      parsers.micromark.tokens,
       (token) => token.children.some((child) => child.type === "data")
     );
     for (const token of tokens) {

package/lib/md038.js

@@ -3,8 +3,8 @@
 "use strict";
 
 const { addErrorContext } = require("../helpers");
-const { filterByTypes, inHtmlFlow, tokenIfType } =
-  require("../helpers/micromark.cjs");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const leftSpaceRe = /^\s(?:[^`]|$)/;
 const rightSpaceRe = /[^`]\s$/;
@@ -27,32 +27,21 @@ module.exports = {
   "tags": [ "whitespace", "code" ],
   "parser": "micromark",
   "function": function MD038(params, onError) {
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const codeTexts = filterByTypes(micromarkTokens, [ "codeText" ])
-      .filter((codeText) => !inHtmlFlow(codeText));
+    const codeTexts = filterByTypesCached([ "codeText" ]);
     for (const codeText of codeTexts) {
-      const { children } = codeText;
-      const first = 0;
-      const last = children.length - 1;
-      const startSequence = tokenIfType(children[first], "codeTextSequence");
-      const endSequence = tokenIfType(children[last], "codeTextSequence");
-      const startData =
-        tokenIfType(children[first + 1], "codeTextData") ||
-        tokenIfType(children[first + 2], "codeTextData");
-      const endData =
-        tokenIfType(children[last - 1], "codeTextData") ||
-        tokenIfType(children[last - 2], "codeTextData");
+      const sequences = getDescendantsByType(codeText, [ "codeTextSequence" ]);
+      const startSequence = sequences[0];
+      const endSequence = sequences[sequences.length - 1];
+      const datas = getDescendantsByType(codeText, [ "codeTextData" ]);
+      const startData = datas[0];
+      const endData = datas[datas.length - 1];
       if (startSequence && endSequence && startData && endData) {
         const spaceLeft = leftSpaceRe.test(startData.text);
         const spaceRight = rightSpaceRe.test(endData.text);
         if (spaceLeft || spaceRight) {
           let lineNumber = startSequence.startLine;
-          let range = null;
-          let fixInfo = null;
+          let range = undefined;
+          let fixInfo = undefined;
           if (startSequence.startLine === endSequence.endLine) {
             range = [
               startSequence.startColumn,