markdownlint 0.34.0 → 0.36.0

package/lib/md005.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addError, addErrorDetailIf } = require("../helpers");
-const { filterByTypes, inHtmlFlow } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -13,16 +13,7 @@ module.exports = {
   "tags": [ "bullet", "ul", "indentation" ],
   "parser": "micromark",
   "function": function MD005(params, onError) {
-    // 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" ]
-    ).filter((list) => !inHtmlFlow(list));
-    for (const list of lists) {
+    for (const list of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
       const expectedIndent = list.startColumn - 1;
       let expectedEnd = 0;
       let endMatching = false;
@@ -38,8 +29,8 @@ module.exports = {
             lineNumber,
             expectedIndent,
             actualIndent,
-            null,
-            null,
+            undefined,
+            undefined,
             range
             // No fixInfo; MD007 handles this scenario better
           );

package/lib/md007.js

@@ -3,8 +3,8 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes, getTokenParentOfType, inHtmlFlow } =
-  require("../helpers/micromark.cjs");
+const { getParentOfType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("markdownlint-micromark").TokenType[] */
@@ -26,24 +26,20 @@ module.exports = {
     const indent = Number(params.config.indent || 2);
     const startIndented = !!params.config.start_indented;
     const startIndent = Number(params.config.start_indent || indent);
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
     const unorderedListNesting = new Map();
     let lastBlockQuotePrefix = null;
-    const tokens = filterByTypes(micromarkTokens, unorderedListTypes);
+    const tokens = filterByTypesCached(unorderedListTypes);
     for (const token of tokens) {
       const { endColumn, parent, startColumn, startLine, type } = token;
       if (type === "blockQuotePrefix") {
         lastBlockQuotePrefix = token;
       } else if (type === "listUnordered") {
         let nesting = 0;
-        /** @type {import("../helpers/micromark.cjs").Token | null} */
+        /** @type {import("../helpers/micromark-helpers.cjs").Token | null} */
         let current = token;
         while (
-          (current = getTokenParentOfType(current, unorderedParentTypes))
+          // @ts-ignore
+          (current = getParentOfType(current, unorderedParentTypes))
         ) {
           if (current.type === "listUnordered") {
             nesting++;
@@ -57,7 +53,7 @@ module.exports = {
         if (nesting >= 0) {
           unorderedListNesting.set(token, nesting);
         }
-      } else if (!inHtmlFlow(token)) {
+      } else {
         // listItemPrefix
         const nesting = unorderedListNesting.get(parent);
         if (nesting !== undefined) {

package/lib/md009.js

@@ -2,9 +2,9 @@
 
 "use strict";
 
-const { addError, filterTokens, forEachLine, includesSorted,
-  numericSortAscending } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addError } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -12,63 +12,68 @@ module.exports = {
   "names": [ "MD009", "no-trailing-spaces" ],
   "description": "Trailing spaces",
   "tags": [ "whitespace" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD009(params, onError) {
     let brSpaces = params.config.br_spaces;
     brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);
     const listItemEmptyLines = !!params.config.list_item_empty_lines;
     const strict = !!params.config.strict;
-    const listItemLineNumbers = [];
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine + 1, codeBlock.endLine - 1);
+    }
+    for (const codeBlock of filterByTypesCached([ "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
+    const listItemLineNumbers = new Set();
     if (listItemEmptyLines) {
-      filterTokens(params, "list_item_open", (token) => {
-        for (let i = token.map[0]; i < token.map[1]; i++) {
-          listItemLineNumbers.push(i + 1);
+      for (const listBlock of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
+        addRangeToSet(listItemLineNumbers, listBlock.startLine, listBlock.endLine);
+        let trailingIndent = true;
+        for (let i = listBlock.children.length - 1; i >= 0; i--) {
+          const child = listBlock.children[i];
+          switch (child.type) {
+            case "content":
+              trailingIndent = false;
+              break;
+            case "listItemIndent":
+              if (trailingIndent) {
+                listItemLineNumbers.delete(child.startLine);
+              }
+              break;
+            case "listItemPrefix":
+              trailingIndent = true;
+              break;
+            default:
+              break;
+          }
         }
-      });
-      listItemLineNumbers.sort(numericSortAscending);
+      }
     }
-    const paragraphLineNumbers = [];
-    const codeInlineLineNumbers = [];
+    const paragraphLineNumbers = new Set();
+    const codeInlineLineNumbers = new Set();
     if (strict) {
-      filterTokens(params, "paragraph_open", (token) => {
-        for (let i = token.map[0]; i < token.map[1] - 1; i++) {
-          paragraphLineNumbers.push(i + 1);
-        }
-      });
-      const addLineNumberRange = (start, end) => {
-        for (let i = start; i < end; i++) {
-          codeInlineLineNumbers.push(i);
-        }
-      };
-      filterTokens(params, "inline", (token) => {
-        let start = 0;
-        for (const child of token.children) {
-          if (start > 0) {
-            addLineNumberRange(start, child.lineNumber);
-            start = 0;
-          }
-          if (child.type === "code_inline") {
-            start = child.lineNumber;
-          }
-        }
-        if (start > 0) {
-          addLineNumberRange(start, token.map[1]);
-        }
-      });
+      for (const paragraph of filterByTypesCached([ "paragraph" ])) {
+        addRangeToSet(paragraphLineNumbers, paragraph.startLine, paragraph.endLine - 1);
+      }
+      for (const codeText of filterByTypesCached([ "codeText" ])) {
+        addRangeToSet(codeInlineLineNumbers, codeText.startLine, codeText.endLine - 1);
+      }
     }
     const expected = (brSpaces < 2) ? 0 : brSpaces;
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
       const lineNumber = lineIndex + 1;
       const trailingSpaces = line.length - line.trimEnd().length;
       if (
         trailingSpaces &&
-        !inCode &&
-        !includesSorted(listItemLineNumbers, lineNumber) &&
+        !codeBlockLineNumbers.has(lineNumber) &&
+        !listItemLineNumbers.has(lineNumber) &&
         (
           (expected !== trailingSpaces) ||
           (strict &&
-            (!includesSorted(paragraphLineNumbers, lineNumber) ||
-             includesSorted(codeInlineLineNumbers, lineNumber)))
+            (!paragraphLineNumbers.has(lineNumber) ||
+             codeInlineLineNumbers.has(lineNumber)))
         )
       ) {
         const column = line.length - trailingSpaces + 1;
@@ -82,8 +87,9 @@ module.exports = {
           {
             "editColumn": column,
             "deleteCount": trailingSpaces
-          });
+          }
+        );
       }
-    });
+    }
   }
 };

package/lib/md010.js

@@ -2,9 +2,9 @@
 
 "use strict";
 
-const { addError, filterTokens, forEachLine, withinAnyRange } =
-  require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+const { addError, hasOverlap } = require("../helpers");
+const { getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const tabRe = /\t+/g;
 
@@ -14,7 +14,7 @@ module.exports = {
   "names": [ "MD010", "no-hard-tabs" ],
   "description": "Hard tabs",
   "tags": [ "whitespace", "hard_tab" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD010(params, onError) {
     const codeBlocks = params.config.code_blocks;
     const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
@@ -26,38 +26,57 @@ module.exports = {
     const spaceMultiplier = (spacesPerTab === undefined) ?
       1 :
       Math.max(0, Number(spacesPerTab));
-    const exclusions = includeCode ? [] : codeBlockAndSpanRanges();
-    filterTokens(params, "fence", (token) => {
-      const language = token.info.trim().toLowerCase();
-      if (ignoreCodeLanguages.has(language)) {
-        for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
-          exclusions.push([ i, 0, params.lines[i].length ]);
-        }
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark-helpers.cjs").TokenType[] */
+    const exclusionTypes = [];
+    if (includeCode) {
+      if (ignoreCodeLanguages.size > 0) {
+        exclusionTypes.push("codeFenced");
+      }
+    } else {
+      exclusionTypes.push("codeFenced", "codeIndented", "codeText");
+    }
+    const codeTokens = filterByTypesCached(exclusionTypes).filter((token) => {
+      if ((token.type === "codeFenced") && (ignoreCodeLanguages.size > 0)) {
+        const fenceInfos = getDescendantsByType(token, [ "codeFencedFence", "codeFencedFenceInfo" ]);
+        return fenceInfos.every((fenceInfo) => ignoreCodeLanguages.has(fenceInfo.text.toLowerCase()));
       }
+      return true;
     });
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      if (includeCode || !inCode) {
-        let match = null;
-        while ((match = tabRe.exec(line)) !== null) {
-          const { index } = match;
-          const column = index + 1;
-          const length = match[0].length;
-          if (!withinAnyRange(exclusions, lineIndex, index, length)) {
-            addError(
-              onError,
-              lineIndex + 1,
-              "Column: " + column,
-              undefined,
-              [ column, length ],
-              {
-                "editColumn": column,
-                "deleteCount": length,
-                "insertText": "".padEnd(length * spaceMultiplier)
-              }
-            );
-          }
+    const codeRanges = codeTokens.map((token) => {
+      const { type, startLine, startColumn, endLine, endColumn } = token;
+      const codeFenced = (type === "codeFenced");
+      return {
+        "startLine": startLine + (codeFenced ? 1 : 0),
+        "startColumn": codeFenced ? 0 : startColumn,
+        "endLine": endLine - (codeFenced ? 1 : 0),
+        "endColumn": codeFenced ? Number.MAX_SAFE_INTEGER : endColumn
+      };
+    });
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
+      let match = null;
+      while ((match = tabRe.exec(line)) !== null) {
+        const lineNumber = lineIndex + 1;
+        const column = match.index + 1;
+        const length = match[0].length;
+        /** @type {import("../helpers").FileRange} */
+        const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
+        if (!codeRanges.some((codeRange) => hasOverlap(codeRange, range))) {
+          addError(
+            onError,
+            lineNumber,
+            "Column: " + column,
+            undefined,
+            [ column, length ],
+            {
+              "editColumn": column,
+              "deleteCount": length,
+              "insertText": "".padEnd(length * spaceMultiplier)
+            }
+          );
         }
       }
-    });
+    }
   }
 };

package/lib/md011.js

@@ -2,8 +2,9 @@
 
 "use strict";
 
-const { addError, forEachLine, withinAnyRange } = require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+const { addError, hasOverlap } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const reversedLinkRe =
   /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g;
@@ -14,36 +15,44 @@ module.exports = {
   "names": [ "MD011", "no-reversed-links" ],
   "description": "Reversed link syntax",
   "tags": [ "links" ],
-  "parser": "none",
+  "parser": "micromark",
   "function": function MD011(params, onError) {
-    const exclusions = codeBlockAndSpanRanges();
-    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
-      if (!inCode && !onFence) {
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
+    const codeTexts = filterByTypesCached([ "codeText" ]);
+    for (const [ lineIndex, line ] of params.lines.entries()) {
+      const lineNumber = lineIndex + 1;
+      if (!codeBlockLineNumbers.has(lineNumber)) {
         let match = null;
         while ((match = reversedLinkRe.exec(line)) !== null) {
           const [ reversedLink, preChar, linkText, linkDestination ] = match;
-          const index = match.index + preChar.length;
-          const length = match[0].length - preChar.length;
           if (
             !linkText.endsWith("\\") &&
-            !linkDestination.endsWith("\\") &&
-            !withinAnyRange(exclusions, lineIndex, index, length)
+            !linkDestination.endsWith("\\")
           ) {
-            addError(
-              onError,
-              lineIndex + 1,
-              reversedLink.slice(preChar.length),
-              undefined,
-              [ index + 1, length ],
-              {
-                "editColumn": index + 1,
-                "deleteCount": length,
-                "insertText": `[${linkText}](${linkDestination})`
-              }
-            );
+            const column = match.index + preChar.length + 1;
+            const length = match[0].length - preChar.length;
+            /** @type {import("../helpers").FileRange} */
+            const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
+            if (!codeTexts.some((codeText) => hasOverlap(codeText, range))) {
+              addError(
+                onError,
+                lineNumber,
+                reversedLink.slice(preChar.length),
+                undefined,
+                [ column, length ],
+                {
+                  "editColumn": column,
+                  "deleteCount": length,
+                  "insertText": `[${linkText}](${linkDestination})`
+                }
+              );
+            }
           }
         }
       }
-    });
+    }
   }
 };

package/lib/md012.js

@@ -2,8 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -11,11 +12,17 @@ module.exports = {
   "names": [ "MD012", "no-multiple-blanks" ],
   "description": "Multiple consecutive blank lines",
   "tags": [ "whitespace", "blank_lines" ],
-  "parser": "none",
+  "parser": "micromark",
   "function": function MD012(params, onError) {
     const maximum = Number(params.config.maximum || 1);
+    const { lines } = params;
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
     let count = 0;
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+    for (const [ lineIndex, line ] of lines.entries()) {
+      const inCode = codeBlockLineNumbers.has(lineIndex + 1);
       count = (inCode || (line.trim().length > 0)) ? 0 : count + 1;
       if (maximum < count) {
         addErrorDetailIf(
@@ -23,13 +30,14 @@ module.exports = {
           lineIndex + 1,
           maximum,
           count,
-          null,
-          null,
-          null,
+          undefined,
+          undefined,
+          undefined,
           {
             "deleteCount": -1
-          });
+          }
+        );
       }
-    });
+    }
   }
 };

package/lib/md013.js

@@ -2,25 +2,15 @@
 
 "use strict";
 
-const { addErrorDetailIf, filterTokens, forEachHeading, forEachLine,
-  includesSorted } = require("../helpers");
-const { lineMetadata, referenceLinkImageData } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { getReferenceLinkImageData } = require("./cache");
+const { addRangeToSet, getDescendantsByType } = require("../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const longLineRePrefix = "^.{";
 const longLineRePostfixRelaxed = "}.*\\s.*$";
 const longLineRePostfixStrict = "}.+$";
-const linkOrImageOnlyLineRe = /^[es]*(?:lT?L|I)[ES]*$/;
 const sternModeRe = /^(?:[#>\s]*\s)?\S*$/;
-const tokenTypeMap = {
-  "em_open": "e",
-  "em_close": "E",
-  "image": "I",
-  "link_open": "l",
-  "link_close": "L",
-  "strong_open": "s",
-  "strong_close": "S",
-  "text": "T"
-};
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -28,7 +18,7 @@ module.exports = {
   "names": [ "MD013", "line-length" ],
   "description": "Line length",
   "tags": [ "line_length" ],
-  "parser": "markdownit",
+  "parser": "micromark",
   "function": function MD013(params, onError) {
     const lineLength = Number(params.config.line_length || 80);
     const headingLineLength =
@@ -51,26 +41,41 @@ module.exports = {
     const includeTables = (tables === undefined) ? true : !!tables;
     const headings = params.config.headings;
     const includeHeadings = (headings === undefined) ? true : !!headings;
-    const headingLineNumbers = [];
-    forEachHeading(params, (heading) => {
-      headingLineNumbers.push(heading.lineNumber);
-    });
-    const linkOnlyLineNumbers = [];
-    filterTokens(params, "inline", (token) => {
-      let childTokenTypes = "";
-      for (const child of token.children) {
-        if (child.type !== "text" || child.content !== "") {
-          childTokenTypes += tokenTypeMap[child.type] || "x";
-        }
+    const headingLineNumbers = new Set();
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      addRangeToSet(headingLineNumbers, heading.startLine, heading.endLine);
+    }
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
+    const tableLineNumbers = new Set();
+    for (const table of filterByTypesCached([ "table" ])) {
+      addRangeToSet(tableLineNumbers, table.startLine, table.endLine);
+    }
+    const linkLineNumbers = new Set();
+    for (const link of filterByTypesCached([ "autolink", "image", "link", "literalAutolink" ])) {
+      addRangeToSet(linkLineNumbers, link.startLine, link.endLine);
+    }
+    const paragraphDataLineNumbers = new Set();
+    for (const paragraph of filterByTypesCached([ "paragraph" ])) {
+      for (const data of getDescendantsByType(paragraph, [ "data" ])) {
+        addRangeToSet(paragraphDataLineNumbers, data.startLine, data.endLine);
       }
-      if (linkOrImageOnlyLineRe.test(childTokenTypes)) {
-        linkOnlyLineNumbers.push(token.lineNumber);
+    }
+    const linkOnlyLineNumbers = new Set();
+    for (const lineNumber of linkLineNumbers) {
+      if (!paragraphDataLineNumbers.has(lineNumber)) {
+        linkOnlyLineNumbers.add(lineNumber);
       }
-    });
-    const { definitionLineIndices } = referenceLinkImageData();
-    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable) => {
+    }
+    const definitionLineIndices = new Set(getReferenceLinkImageData().definitionLineIndices);
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
       const lineNumber = lineIndex + 1;
-      const isHeading = includesSorted(headingLineNumbers, lineNumber);
+      const isHeading = headingLineNumbers.has(lineNumber);
+      const inCode = codeBlockLineNumbers.has(lineNumber);
+      const inTable = tableLineNumbers.has(lineNumber);
       const length = inCode ?
         codeLineLength :
         (isHeading ? headingLineLength : lineLength);
@@ -80,20 +85,21 @@ module.exports = {
       if ((includeCodeBlocks || !inCode) &&
           (includeTables || !inTable) &&
           (includeHeadings || !isHeading) &&
-          !includesSorted(definitionLineIndices, lineIndex) &&
+          !definitionLineIndices.has(lineIndex) &&
           (strict ||
            (!(stern && sternModeRe.test(line)) &&
-            !includesSorted(linkOnlyLineNumbers, lineNumber))) &&
+            !linkOnlyLineNumbers.has(lineNumber))) &&
           lengthRe.test(line)) {
         addErrorDetailIf(
           onError,
           lineNumber,
           length,
           line.length,
-          null,
-          null,
-          [ length + 1, line.length - length ]);
+          undefined,
+          undefined,
+          [ length + 1, line.length - length ]
+        );
       }
-    });
+    }
   }
 };