markdownlint 0.33.0 → 0.35.0

package/lib/md001.js

@@ -2,21 +2,30 @@
 
 "use strict";
 
-const { addErrorDetailIf, filterTokens } = require("../helpers");
+const { addErrorDetailIf } = require("../helpers");
+const { getHeadingLevel } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD001", "heading-increment" ],
   "description": "Heading levels should only increment by one level at a time",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD001(params, onError) {
-    let prevLevel = 0;
-    filterTokens(params, "heading_open", function forToken(token) {
-      const level = Number.parseInt(token.tag.slice(1), 10);
-      if (prevLevel && (level > prevLevel)) {
-        addErrorDetailIf(onError, token.lineNumber,
-          "h" + (prevLevel + 1), "h" + level);
+    let prevLevel = Number.MAX_SAFE_INTEGER;
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const level = getHeadingLevel(heading);
+      if (level > prevLevel) {
+        addErrorDetailIf(
+          onError,
+          heading.startLine,
+          `h${prevLevel + 1}`,
+          `h${level}`
+        );
       }
       prevLevel = level;
-    });
+    }
   }
 };

package/lib/md003.js

@@ -2,22 +2,26 @@
 
 "use strict";
 
-const { addErrorDetailIf, filterTokens, headingStyleFor } =
-  require("../helpers");
+const { addErrorDetailIf } = require("../helpers");
+const { getHeadingLevel, getHeadingStyle } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD003", "heading-style" ],
   "description": "Heading style",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD003(params, onError) {
     let style = String(params.config.style || "consistent");
-    filterTokens(params, "heading_open", function forToken(token) {
-      const styleForToken = headingStyleFor(token);
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const styleForToken = getHeadingStyle(heading);
       if (style === "consistent") {
         style = styleForToken;
       }
       if (styleForToken !== style) {
-        const h12 = /h[12]/.test(token.tag);
+        const h12 = getHeadingLevel(heading) <= 2;
         const setextWithAtx =
           (style === "setext_with_atx") &&
             ((h12 && (styleForToken === "setext")) ||
@@ -33,10 +37,14 @@ module.exports = {
           } else if (style === "setext_with_atx_closed") {
             expected = h12 ? "setext" : "atx_closed";
           }
-          addErrorDetailIf(onError, token.lineNumber,
-            expected, styleForToken);
+          addErrorDetailIf(
+            onError,
+            heading.startLine,
+            expected,
+            styleForToken
+          );
         }
       }
-    });
+    }
   }
 };

package/lib/md004.js

@@ -2,11 +2,16 @@
 
 "use strict";
 
-const { addErrorDetailIf, listItemMarkerRe, unorderedListStyleFor } =
-  require("../helpers");
-const { flattenedLists } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { getDescendantsByType, getTokenParentOfType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
-const expectedStyleToMarker = {
+const markerToStyle = {
+  "-": "dash",
+  "+": "plus",
+  "*": "asterisk"
+};
+const styleToMarker = {
   "dash": "-",
   "plus": "+",
   "asterisk": "*"
@@ -16,60 +21,65 @@ const differentItemStyle = {
   "plus": "asterisk",
   "asterisk": "dash"
 };
-const validStyles = Object.keys(expectedStyleToMarker);
+const validStyles = new Set([
+  "asterisk",
+  "consistent",
+  "dash",
+  "plus",
+  "sublist"
+]);
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD004", "ul-style" ],
   "description": "Unordered list style",
   "tags": [ "bullet", "ul" ],
+  "parser": "micromark",
   "function": function MD004(params, onError) {
     const style = String(params.config.style || "consistent");
-    let expectedStyle = style;
+    let expectedStyle = validStyles.has(style) ? style : "dash";
     const nestingStyles = [];
-    for (const list of flattenedLists()) {
-      if (list.unordered) {
-        if (expectedStyle === "consistent") {
-          expectedStyle = unorderedListStyleFor(list.items[0]);
+    for (const listUnordered of filterByTypesCached([ "listUnordered" ])) {
+      let nesting = 0;
+      if (style === "sublist") {
+        /** @type {import("../helpers/micromark.cjs").Token | null} */
+        let parent = listUnordered;
+        // @ts-ignore
+        while ((parent = getTokenParentOfType(parent, [ "listOrdered", "listUnordered" ]))) {
+          nesting++;
         }
-        for (const item of list.items) {
-          const itemStyle = unorderedListStyleFor(item);
-          if (style === "sublist") {
-            const nesting = list.nesting;
-            if (!nestingStyles[nesting]) {
-              nestingStyles[nesting] =
-                (itemStyle === nestingStyles[nesting - 1]) ?
-                  differentItemStyle[itemStyle] :
-                  itemStyle;
-            }
-            expectedStyle = nestingStyles[nesting];
-          }
-          if (!validStyles.includes(expectedStyle)) {
-            expectedStyle = validStyles[0];
-          }
-          let range = null;
-          let fixInfo = null;
-          const match = item.line.match(listItemMarkerRe);
-          if (match) {
-            const column = match.index + 1;
-            const length = match[0].length;
-            range = [ column, length ];
-            fixInfo = {
-              "editColumn": match[1].length + 1,
-              "deleteCount": 1,
-              "insertText": expectedStyleToMarker[expectedStyle]
-            };
+      }
+      const listItemMarkers = getDescendantsByType(listUnordered, [ "listItemPrefix", "listItemMarker" ]);
+      for (const listItemMarker of listItemMarkers) {
+        const itemStyle = markerToStyle[listItemMarker.text];
+        if (style === "sublist") {
+          if (!nestingStyles[nesting]) {
+            nestingStyles[nesting] =
+              (itemStyle === nestingStyles[nesting - 1]) ?
+                differentItemStyle[itemStyle] :
+                itemStyle;
           }
-          addErrorDetailIf(
-            onError,
-            item.lineNumber,
-            expectedStyle,
-            itemStyle,
-            null,
-            null,
-            range,
-            fixInfo
-          );
+          expectedStyle = nestingStyles[nesting];
+        } else if (expectedStyle === "consistent") {
+          expectedStyle = itemStyle;
         }
+        const column = listItemMarker.startColumn;
+        const length = listItemMarker.endColumn - listItemMarker.startColumn;
+        addErrorDetailIf(
+          onError,
+          listItemMarker.startLine,
+          expectedStyle,
+          itemStyle,
+          undefined,
+          undefined,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length,
+            "insertText": styleToMarker[expectedStyle]
+          }
+        );
       }
     }
   }

package/lib/md005.js

@@ -3,18 +3,17 @@
 "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 */
 module.exports = {
   "names": [ "MD005", "list-indent" ],
   "description": "Inconsistent indentation for list items at the same level",
   "tags": [ "bullet", "ul", "indentation" ],
+  "parser": "micromark",
   "function": function MD005(params, onError) {
-    const lists = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "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;
@@ -30,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,41 +3,42 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes, getTokenParentOfType, inHtmlFlow } =
-  require("../helpers/micromark.cjs");
-
-/**
- * @typedef {import("../helpers/micromark.cjs").Token} Token
- */
+const { getTokenParentOfType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("markdownlint-micromark").TokenType[] */
 const unorderedListTypes =
   [ "blockQuotePrefix", "listItemPrefix", "listUnordered" ];
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("markdownlint-micromark").TokenType[] */
 const unorderedParentTypes =
   [ "blockQuote", "listOrdered", "listUnordered" ];
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD007", "ul-indent" ],
   "description": "Unordered list indentation",
   "tags": [ "bullet", "ul", "indentation" ],
+  "parser": "micromark",
   "function": function MD007(params, onError) {
     const indent = Number(params.config.indent || 2);
     const startIndented = !!params.config.start_indented;
     const startIndent = Number(params.config.start_indent || indent);
     const unorderedListNesting = new Map();
     let lastBlockQuotePrefix = null;
-    const tokens = filterByTypes(
-      params.parsers.micromark.tokens,
-      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 {Token | null} */
+        /** @type {import("../helpers/micromark.cjs").Token | null} */
         let current = token;
         while (
+          // @ts-ignore
           (current = getTokenParentOfType(current, unorderedParentTypes))
         ) {
           if (current.type === "listUnordered") {
@@ -52,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,70 +2,78 @@
 
 "use strict";
 
-const { addError, filterTokens, forEachLine, includesSorted,
-  numericSortAscending } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addError } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD009", "no-trailing-spaces" ],
   "description": "Trailing spaces",
   "tags": [ "whitespace" ],
+  "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;
@@ -79,8 +87,9 @@ module.exports = {
           {
             "editColumn": column,
             "deleteCount": trailingSpaces
-          });
+          }
+        );
       }
-    });
+    }
   }
 };

package/lib/md010.js

@@ -2,16 +2,19 @@
 
 "use strict";
 
-const { addError, filterTokens, forEachLine, withinAnyRange } =
-  require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+const { addError, withinAnyRange } = require("../helpers");
+const { getDescendantsByType, getExclusionsForToken } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const tabRe = /\t+/g;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD010", "no-hard-tabs" ],
   "description": "Hard tabs",
   "tags": [ "whitespace", "hard_tab" ],
+  "parser": "micromark",
   "function": function MD010(params, onError) {
     const codeBlocks = params.config.code_blocks;
     const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
@@ -23,38 +26,53 @@ 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 ]);
-        }
+    const exclusions = [];
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.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,
-              null,
-              [ column, length ],
-              {
-                "editColumn": column,
-                "deleteCount": length,
-                "insertText": "".padEnd(length * spaceMultiplier)
-              }
-            );
-          }
+    for (const codeToken of codeTokens) {
+      const exclusionsForToken = getExclusionsForToken(params.lines, codeToken);
+      if (codeToken.type === "codeFenced") {
+        exclusionsForToken.pop();
+        exclusionsForToken.shift();
+      }
+      exclusions.push(...exclusionsForToken);
+    }
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
+      let match = null;
+      while ((match = tabRe.exec(line)) !== null) {
+        const column = match.index + 1;
+        const length = match[0].length;
+        if (!withinAnyRange(exclusions, lineIndex + 1, column, length)) {
+          addError(
+            onError,
+            lineIndex + 1,
+            "Column: " + column,
+            undefined,
+            [ column, length ],
+            {
+              "editColumn": column,
+              "deleteCount": length,
+              "insertText": "".padEnd(length * spaceMultiplier)
+            }
+          );
         }
       }
-    });
+    }
   }
 };

package/lib/md011.js

@@ -2,20 +2,31 @@
 
 "use strict";
 
-const { addError, forEachLine, withinAnyRange } = require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
+const { addError, withinAnyRange } = require("../helpers");
+const { addRangeToSet, getExclusionsForToken } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const reversedLinkRe =
   /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD011", "no-reversed-links" ],
   "description": "Reversed link syntax",
   "tags": [ "links" ],
+  "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 exclusions = [];
+    for (const codeText of filterByTypesCached([ "codeText" ])) {
+      exclusions.push(...getExclusionsForToken(params.lines, codeText));
+    }
+    for (const [ lineIndex, line ] of params.lines.entries()) {
+      if (!codeBlockLineNumbers.has(lineIndex + 1)) {
         let match = null;
         while ((match = reversedLinkRe.exec(line)) !== null) {
           const [ reversedLink, preChar, linkText, linkDestination ] = match;
@@ -24,7 +35,7 @@ module.exports = {
           if (
             !linkText.endsWith("\\") &&
             !linkDestination.endsWith("\\") &&
-            !withinAnyRange(exclusions, lineIndex, index, length)
+            !withinAnyRange(exclusions, lineIndex + 1, index, length)
           ) {
             addError(
               onError,
@@ -41,6 +52,6 @@ module.exports = {
           }
         }
       }
-    });
+    }
   }
 };

package/lib/md012.js

@@ -2,17 +2,27 @@
 
 "use strict";
 
-const { addErrorDetailIf, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD012", "no-multiple-blanks" ],
   "description": "Multiple consecutive blank lines",
   "tags": [ "whitespace", "blank_lines" ],
+  "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(
@@ -20,13 +30,14 @@ module.exports = {
           lineIndex + 1,
           maximum,
           count,
-          null,
-          null,
-          null,
+          undefined,
+          undefined,
+          undefined,
           {
             "deleteCount": -1
-          });
+          }
+        );
       }
-    });
+    }
   }
 };