markdownlint 0.33.0 → 0.35.0

package/lib/md013.js

@@ -2,30 +2,23 @@
 
 "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.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 */
 module.exports = {
   "names": [ "MD013", "line-length" ],
   "description": "Line length",
   "tags": [ "line_length" ],
+  "parser": "micromark",
   "function": function MD013(params, onError) {
     const lineLength = Number(params.config.line_length || 80);
     const headingLineLength =
@@ -48,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);
@@ -77,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 ]
+        );
       }
-    });
+    }
   }
 };

package/lib/md014.js

@@ -2,52 +2,53 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens } = require("../helpers");
+const { addErrorContext } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const dollarCommandRe = /^(\s*)(\$\s+)/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD014", "commands-show-output" ],
   "description": "Dollar signs used before commands without showing output",
   "tags": [ "code" ],
+  "parser": "micromark",
   "function": function MD014(params, onError) {
-    for (const type of [ "code_block", "fence" ]) {
-      filterTokens(params, type, (token) => {
-        const margin = (token.type === "fence") ? 1 : 0;
-        const dollarInstances = [];
-        let allDollars = true;
-        for (let i = token.map[0] + margin; i < token.map[1] - margin; i++) {
-          const line = params.lines[i];
-          const lineTrim = line.trim();
-          if (lineTrim) {
-            const match = dollarCommandRe.exec(line);
-            if (match) {
-              const column = match[1].length + 1;
-              const length = match[2].length;
-              dollarInstances.push([ i, lineTrim, column, length ]);
-            } else {
-              allDollars = false;
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      const codeFlowValues = filterByTypes(
+        codeBlock.children,
+        [ "codeFlowValue" ]
+      );
+      const dollarMatches = codeFlowValues.
+        map((codeFlowValue) => ({
+          "result": codeFlowValue.text.match(dollarCommandRe),
+          "startColumn": codeFlowValue.startColumn,
+          "startLine": codeFlowValue.startLine,
+          "text": codeFlowValue.text
+        })).
+        filter((dollarMatch) => dollarMatch.result);
+      if (dollarMatches.length === codeFlowValues.length) {
+        for (const dollarMatch of dollarMatches) {
+          // @ts-ignore
+          const column = dollarMatch.startColumn + dollarMatch.result[1].length;
+          // @ts-ignore
+          const length = dollarMatch.result[2].length;
+          addErrorContext(
+            onError,
+            dollarMatch.startLine,
+            dollarMatch.text,
+            undefined,
+            undefined,
+            [ column, length ],
+            {
+              "editColumn": column,
+              "deleteCount": length
             }
-          }
+          );
         }
-        if (allDollars) {
-          for (const instance of dollarInstances) {
-            const [ i, lineTrim, column, length ] = instance;
-            addErrorContext(
-              onError,
-              i + 1,
-              lineTrim,
-              null,
-              null,
-              [ column, length ],
-              {
-                "editColumn": column,
-                "deleteCount": length
-              }
-            );
-          }
-        }
-      });
+      }
     }
   }
 };

package/lib/md018.js

@@ -2,26 +2,38 @@
 
 "use strict";
 
-const { addErrorContext, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addErrorContext } = 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": [ "MD018", "no-missing-space-atx" ],
   "description": "No space after hash on atx style heading",
   "tags": [ "headings", "atx", "spaces" ],
+  "parser": "micromark",
   "function": function MD018(params, onError) {
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      if (!inCode &&
+    const { lines } = params;
+    const ignoreBlockLineNumbers = new Set();
+    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow" ])) {
+      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
+    }
+    for (const [ lineIndex, line ] of lines.entries()) {
+      if (
+        !ignoreBlockLineNumbers.has(lineIndex + 1) &&
         /^#+[^# \t]/.test(line) &&
         !/#\s*$/.test(line) &&
-        !line.startsWith("#️⃣")) {
+        !line.startsWith("#️⃣")
+      ) {
+        // @ts-ignore
         const hashCount = /^#+/.exec(line)[0].length;
         addErrorContext(
           onError,
           lineIndex + 1,
           line.trim(),
-          null,
-          null,
+          undefined,
+          undefined,
           [ 1, hashCount + 1 ],
           {
             "editColumn": hashCount + 1,
@@ -29,6 +41,6 @@ module.exports = {
           }
         );
       }
-    });
+    }
   }
 };

package/lib/md019-md021.js

@@ -0,0 +1,80 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers/helpers");
+const { getHeadingStyle } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+/**
+ * Validate heading sequence and whitespace length at start or end.
+ *
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("./markdownlint").MicromarkToken} heading ATX heading token.
+ * @param {number} delta Direction to scan.
+ * @returns {void}
+ */
+function validateHeadingSpaces(onError, heading, delta) {
+  const { children, startLine, text } = heading;
+  let index = (delta > 0) ? 0 : (children.length - 1);
+  while (
+    children[index] &&
+    (children[index].type !== "atxHeadingSequence")
+  ) {
+    index += delta;
+  }
+  const headingSequence = children[index];
+  const whitespace = children[index + delta];
+  if (
+    (headingSequence?.type === "atxHeadingSequence") &&
+    (whitespace?.type === "whitespace") &&
+    (whitespace.text.length > 1)
+  ) {
+    const column = whitespace.startColumn + 1;
+    const length = whitespace.endColumn - column;
+    addErrorContext(
+      onError,
+      startLine,
+      text.trim(),
+      delta > 0,
+      delta < 0,
+      [ column, length ],
+      {
+        "editColumn": column,
+        "deleteCount": length
+      }
+    );
+  }
+}
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule[] */
+module.exports = [
+  {
+    "names": [ "MD019", "no-multiple-space-atx" ],
+    "description": "Multiple spaces after hash on atx style heading",
+    "tags": [ "headings", "atx", "spaces" ],
+    "parser": "micromark",
+    "function": function MD019(params, onError) {
+      const atxHeadings = filterByTypesCached([ "atxHeading" ])
+        .filter((heading) => getHeadingStyle(heading) === "atx");
+      for (const atxHeading of atxHeadings) {
+        validateHeadingSpaces(onError, atxHeading, 1);
+      }
+    }
+  },
+  {
+    "names": [ "MD021", "no-multiple-space-closed-atx" ],
+    "description": "Multiple spaces inside hashes on closed atx style heading",
+    "tags": [ "headings", "atx_closed", "spaces" ],
+    "parser": "micromark",
+    "function": function MD021(params, onError) {
+      const atxClosedHeadings = filterByTypesCached([ "atxHeading" ])
+        .filter((heading) => getHeadingStyle(heading) === "atx_closed");
+      for (const atxClosedHeading of atxClosedHeadings) {
+        validateHeadingSpaces(onError, atxClosedHeading, 1);
+        validateHeadingSpaces(onError, atxClosedHeading, -1);
+      }
+    }
+  }
+];

package/lib/md020.js

@@ -2,16 +2,25 @@
 
 "use strict";
 
-const { addErrorContext, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addErrorContext } = 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": [ "MD020", "no-missing-space-closed-atx" ],
   "description": "No space inside hashes on closed atx style heading",
   "tags": [ "headings", "atx_closed", "spaces" ],
+  "parser": "micromark",
   "function": function MD020(params, onError) {
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      if (!inCode) {
+    const { lines } = params;
+    const ignoreBlockLineNumbers = new Set();
+    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow" ])) {
+      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
+    }
+    for (const [ lineIndex, line ] of lines.entries()) {
+      if (!ignoreBlockLineNumbers.has(lineIndex + 1)) {
         const match =
           /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
         if (match) {
@@ -28,7 +37,7 @@ module.exports = {
           const leftHashLength = leftHash.length;
           const rightHashLength = rightHash.length;
           const left = !leftSpaceLength;
-          const right = !rightSpaceLength || rightEscape;
+          const right = !rightSpaceLength || !!rightEscape;
           const rightEscapeReplacement = rightEscape ? `${rightEscape} ` : "";
           if (left || right) {
             const range = left ?
@@ -57,6 +66,6 @@ module.exports = {
           }
         }
       }
-    });
+    }
   }
 };

package/lib/md022.js

@@ -2,10 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, blockquotePrefixRe, isBlankLine } =
-  require("../helpers");
-const { filterByTypes, getHeadingLevel, inHtmlFlow } =
-  require("../helpers/micromark.cjs");
+const { addErrorDetailIf, blockquotePrefixRe, isBlankLine } = require("../helpers");
+const { getHeadingLevel } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const defaultLines = 1;
 
@@ -31,19 +30,18 @@ const getBlockQuote = (str, count) => (
     .repeat(count)
 );
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD022", "blanks-around-headings" ],
   "description": "Headings should be surrounded by blank lines",
   "tags": [ "headings", "blank_lines" ],
+  "parser": "micromark",
   "function": function MD022(params, onError) {
     const getLinesAbove = getLinesFunction(params.config.lines_above);
     const getLinesBelow = getLinesFunction(params.config.lines_below);
-    const { lines, parsers } = params;
-    const headings = filterByTypes(
-      parsers.micromark.tokens,
-      [ "atxHeading", "setextHeading" ]
-    ).filter((heading) => !inHtmlFlow(heading));
-    for (const heading of headings) {
+    const { lines } = params;
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
       const { startLine, endLine } = heading;
       const line = lines[startLine - 1].trim();
 
@@ -65,7 +63,7 @@ module.exports = {
           actualAbove,
           "Above",
           line,
-          null,
+          undefined,
           {
             "insertText": getBlockQuote(
               lines[startLine - 2],
@@ -93,7 +91,7 @@ module.exports = {
           actualBelow,
           "Below",
           line,
-          null,
+          undefined,
           {
             "lineNumber": endLine + 1,
             "insertText": getBlockQuote(

package/lib/md023.js

@@ -2,37 +2,39 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens } = require("../helpers");
-
-const spaceBeforeHeadingRe = /^(\s+|[>\s]+\s\s)[^>\s]/;
+const { addErrorContext } = require("../helpers");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD023", "heading-start-left" ],
   "description": "Headings must start at the beginning of the line",
   "tags": [ "headings", "spaces" ],
+  "parser": "micromark",
   "function": function MD023(params, onError) {
-    filterTokens(params, "heading_open", function forToken(token) {
-      const { lineNumber, line } = token;
-      const match = line.match(spaceBeforeHeadingRe);
-      if (match) {
-        const [ prefixAndFirstChar, prefix ] = match;
-        let deleteCount = prefix.length;
-        const prefixLengthNoSpace = prefix.trimEnd().length;
-        if (prefixLengthNoSpace) {
-          deleteCount -= prefixLengthNoSpace - 1;
-        }
+    const headings = filterByTypesCached([ "atxHeading", "linePrefix", "setextHeading" ]);
+    for (let i = 0; i < headings.length - 1; i++) {
+      if (
+        (headings[i].type === "linePrefix") &&
+        (headings[i + 1].type !== "linePrefix") &&
+        (headings[i].startLine === headings[i + 1].startLine)
+      ) {
+        const { endColumn, startColumn, startLine } = headings[i];
+        const length = endColumn - startColumn;
         addErrorContext(
           onError,
-          lineNumber,
-          line,
-          null,
-          null,
-          [ 1, prefixAndFirstChar.length ],
+          startLine,
+          params.lines[startLine - 1],
+          true,
+          false,
+          [ startColumn, length ],
           {
-            "editColumn": prefixLengthNoSpace + 1,
-            "deleteCount": deleteCount
-          });
+            "editColumn": startColumn,
+            "deleteCount": length
+          }
+        );
       }
-    });
+    }
   }
 };

package/lib/md024.js

@@ -2,20 +2,26 @@
 
 "use strict";
 
-const { addErrorContext, forEachHeading } = require("../helpers");
+const { addErrorContext } = require("../helpers");
+const { getHeadingLevel, getHeadingText } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD024", "no-duplicate-heading" ],
   "description": "Multiple headings with the same content",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD024(params, onError) {
     const siblingsOnly = !!params.config.siblings_only || false;
     const knownContents = [ null, [] ];
     let lastLevel = 1;
     let knownContent = knownContents[lastLevel];
-    forEachHeading(params, (heading, content) => {
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const headingText = getHeadingText(heading);
       if (siblingsOnly) {
-        const newLevel = heading.tag.slice(1);
+        const newLevel = getHeadingLevel(heading);
         while (lastLevel < newLevel) {
           lastLevel++;
           knownContents[lastLevel] = [];
@@ -27,16 +33,16 @@ module.exports = {
         knownContent = knownContents[newLevel];
       }
       // @ts-ignore
-      if (knownContent.includes(content)) {
+      if (knownContent.includes(headingText)) {
         addErrorContext(
           onError,
-          heading.lineNumber,
-          heading.line.trim()
+          heading.startLine,
+          headingText.trim()
         );
       } else {
         // @ts-ignore
-        knownContent.push(content);
+        knownContent.push(headingText);
       }
-    });
+    }
   }
 };

package/lib/md025.js

@@ -2,31 +2,39 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens, frontMatterHasTitle } =
-  require("../helpers");
+const { addErrorContext, frontMatterHasTitle } = require("../helpers");
+const { getHeadingLevel, getHeadingText } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD025", "single-title", "single-h1" ],
   "description": "Multiple top-level headings in the same document",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD025(params, onError) {
     const level = Number(params.config.level || 1);
-    const tag = "h" + level;
     const foundFrontMatterTitle =
       frontMatterHasTitle(
         params.frontMatterLines,
         params.config.front_matter_title
       );
     let hasTopLevelHeading = false;
-    filterTokens(params, "heading_open", function forToken(token) {
-      if (token.tag === tag) {
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const headingLevel = getHeadingLevel(heading);
+      if (headingLevel === level) {
         if (hasTopLevelHeading || foundFrontMatterTitle) {
-          addErrorContext(onError, token.lineNumber,
-            token.line.trim());
-        } else if (token.lineNumber === 1) {
+          const headingText = getHeadingText(heading);
+          addErrorContext(
+            onError,
+            heading.startLine,
+            headingText
+          );
+        } else if (heading.startLine === 1) {
           hasTopLevelHeading = true;
         }
       }
-    });
+    }
   }
 };

package/lib/md026.js

@@ -4,13 +4,15 @@
 
 const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
   endOfLineHtmlEntityRe, escapeForRegExp } = require("../helpers");
-const { filterByTypes } = require("../helpers/micromark.cjs");
-
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD026", "no-trailing-punctuation" ],
   "description": "Trailing punctuation in heading",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD026(params, onError) {
     let punctuation = params.config.punctuation;
     punctuation = String(
@@ -18,10 +20,7 @@ module.exports = {
     );
     const trailingPunctuationRe =
       new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
-    const headings = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "atxHeadingText", "setextHeadingText" ]
-    );
+    const headings = filterByTypesCached([ "atxHeadingText", "setextHeadingText" ]);
     for (const heading of headings) {
       const { endColumn, endLine, text } = heading;
       const match = trailingPunctuationRe.exec(text);