markdownlint 0.30.0 → 0.31.1

package/lib/markdownlint.js

@@ -520,7 +520,7 @@ function getEnabledRulesPerLineNumber(
  * @param {boolean} handleRuleFailures Whether to handle exceptions in rules.
  * @param {boolean} noInlineConfig Whether to allow inline configuration.
  * @param {number} resultVersion Version of the LintResults object to return.
- * @param {Function} callback Callback (err, result) function.
+ * @param {LintContentCallback} callback Callback (err, result) function.
  * @returns {void}
  */
 function lintContent(
@@ -809,7 +809,7 @@ function lintContent(
  * @param {number} resultVersion Version of the LintResults object to return.
  * @param {Object} fs File system implementation.
  * @param {boolean} synchronous Whether to execute synchronously.
- * @param {Function} callback Callback (err, result) function.
+ * @param {LintContentCallback} callback Callback (err, result) function.
  * @returns {void}
  */
 function lintFile(
@@ -859,7 +859,7 @@ function lintFile(
  *
  * @param {Options | null} options Options object.
  * @param {boolean} synchronous Whether to execute synchronously.
- * @param {Function} callback Callback (err, result) function.
+ * @param {LintCallback} callback Callback (err, result) function.
  * @returns {void}
  */
 function lintInput(options, synchronous, callback) {
@@ -1022,7 +1022,7 @@ function markdownlintPromise(options) {
  * @returns {LintResults} Results object.
  */
 function markdownlintSync(options) {
-  let results = {};
+  let results = null;
   lintInput(options, true, function callback(error, res) {
     if (error) {
       throw error;
@@ -1176,6 +1176,7 @@ function readConfig(file, parsers, fs, callback) {
   }
   // Read file
   file = helpers.expandTildePath(file, require("node:os"));
+  // eslint-disable-next-line n/prefer-promises/fs
   fs.readFile(file, "utf8", (err, content) => {
     if (err) {
       // @ts-ignore
@@ -1416,12 +1417,21 @@ module.exports = markdownlint;
  * @property {string} [insertText] Text to insert (after deleting).
  */
 
+/**
+ * Called with the result of linting a string or document.
+ *
+ * @callback LintContentCallback
+ * @param {Error | null} error Error iff failed.
+ * @param {LintError[]} [result] Result iff successful.
+ * @returns {void}
+ */
+
 /**
  * Called with the result of the lint function.
  *
  * @callback LintCallback
- * @param {Error | null} err Error object or null.
- * @param {LintResults} [results] Lint results.
+ * @param {Error | null} error Error object iff failed.
+ * @param {LintResults} [results] Lint results iff succeeded.
  * @returns {void}
  */
 

package/lib/md032.js

@@ -4,8 +4,7 @@
 
 const { addErrorContext, blockquotePrefixRe, isBlankLine } =
   require("../helpers");
-const { filterByPredicate, flattenedChildren } =
-  require("../helpers/micromark.cjs");
+const { filterByPredicate } = require("../helpers/micromark.cjs");
 
 const nonContentTokens = new Set([
   "blockQuoteMarker",
@@ -47,7 +46,9 @@ module.exports = {
     const topLevelLists = filterByPredicate(
       parsers.micromark.tokens,
       isList,
-      (token) => (isList(token) ? [] : token.children)
+      (token) => (
+        (isList(token) || (token.type === "htmlFlow")) ? [] : token.children
+      )
     );
     for (const list of topLevelLists) {
 
@@ -59,7 +60,11 @@ module.exports = {
 
       // Find the "visual" end of the list
       let endLine = list.endLine;
-      for (const child of flattenedChildren(list).reverse()) {
+      const flattenedChildren = filterByPredicate(
+        list.children,
+        () => true
+      );
+      for (const child of flattenedChildren.reverse()) {
         if (!nonContentTokens.has(child.type)) {
           endLine = child.endLine;
           break;

package/lib/md033.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addError } = require("../helpers");
-const { filterByHtmlTokens, getHtmlTagInfo } =
+const { filterByTypes, getHtmlTagInfo } =
   require("../helpers/micromark.cjs");
 
 const nextLinesRe = /[\r\n][\s\S]*$/;
@@ -16,7 +16,8 @@ module.exports = {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    for (const token of filterByHtmlTokens(params.parsers.micromark.tokens)) {
+    const { tokens } = params.parsers.micromark;
+    for (const token of filterByTypes(tokens, [ "htmlText" ])) {
       const htmlTagInfo = getHtmlTagInfo(token);
       if (
         htmlTagInfo &&

package/lib/md034.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addErrorContext } = require("../helpers");
-const { filterByPredicate, getHtmlTagInfo, parse } =
+const { filterByPredicate, filterByTypes, getHtmlTagInfo, parse } =
   require("../helpers/micromark.cjs");
 
 module.exports = {
@@ -11,42 +11,40 @@ module.exports = {
   "description": "Bare URL used",
   "tags": [ "links", "url" ],
   "function": function MD034(params, onError) {
-    const literalAutolinks = (tokens) => (
-      filterByPredicate(
-        tokens,
-        (token) => token.type === "literalAutolink",
-        (token) => {
-          const { children } = token;
-          const result = [];
-          for (let i = 0; i < children.length; i++) {
-            const openToken = children[i];
-            const openTagInfo = getHtmlTagInfo(openToken);
-            if (openTagInfo && !openTagInfo.close) {
-              let count = 1;
-              for (let j = i + 1; j < children.length; j++) {
-                const closeToken = children[j];
-                const closeTagInfo = getHtmlTagInfo(closeToken);
-                if (closeTagInfo && (openTagInfo.name === closeTagInfo.name)) {
-                  if (closeTagInfo.close) {
-                    count--;
-                    if (count === 0) {
-                      i = j;
-                      break;
-                    }
-                  } else {
-                    count++;
-                  }
+    const literalAutolinks = (tokens) => {
+      const flattened = filterByPredicate(tokens, () => true);
+      const result = [];
+      for (let i = 0; i < flattened.length; i++) {
+        const current = flattened[i];
+        const openTagInfo = getHtmlTagInfo(current);
+        if (openTagInfo && !openTagInfo.close) {
+          let count = 1;
+          for (let j = i + 1; j < flattened.length; j++) {
+            const candidate = flattened[j];
+            const closeTagInfo = getHtmlTagInfo(candidate);
+            if (closeTagInfo && (openTagInfo.name === closeTagInfo.name)) {
+              if (closeTagInfo.close) {
+                count--;
+                if (count === 0) {
+                  i = j;
+                  break;
                 }
+              } else {
+                count++;
               }
-            } else {
-              result.push(openToken);
             }
           }
-          return result;
+        } else {
+          result.push(current);
         }
-      )
+      }
+      return result.filter((token) => token.type === "literalAutolink");
+    };
+    const autoLinks = filterByTypes(
+      params.parsers.micromark.tokens,
+      [ "literalAutolink" ]
     );
-    if (literalAutolinks(params.parsers.micromark.tokens).length > 0) {
+    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);

package/lib/md037.js

@@ -3,9 +3,7 @@
 "use strict";
 
 const { addError } = require("../helpers");
-
-const emphasisStartTextRe = /^(\S{1,3})(\s+)\S/;
-const emphasisEndTextRe = /\S(\s+)(\S{1,3})$/;
+const { filterByPredicate } = require("../helpers/micromark.cjs");
 
 module.exports = {
   "names": [ "MD037", "no-space-in-emphasis" ],
@@ -19,16 +17,11 @@ module.exports = {
     for (const marker of [ "_", "__", "___", "*", "**", "***" ]) {
       emphasisTokensByMarker.set(marker, []);
     }
-    const pending = [ ...parsers.micromark.tokens ];
-    let token = null;
-    while ((token = pending.shift())) {
-
-      // Use reparsed children of htmlFlow tokens
-      if (token.type === "htmlFlow") {
-        pending.unshift(...token.htmlFlowChildren);
-        continue;
-      }
-      pending.push(...token.children);
+    const tokens = filterByPredicate(
+      parsers.micromark.tokens,
+      (token) => token.children.some((child) => child.type === "data")
+    );
+    for (const token of tokens) {
 
       // Build lists of bare tokens for each emphasis marker type
       for (const emphasisTokens of emphasisTokensByMarker.values()) {
@@ -45,51 +38,51 @@ module.exports = {
       }
 
       // Process bare tokens for each emphasis marker type
-      for (const emphasisTokens of emphasisTokensByMarker.values()) {
+      for (const entry of emphasisTokensByMarker.entries()) {
+        const [ marker, emphasisTokens ] = entry;
         for (let i = 0; i + 1 < emphasisTokens.length; i += 2) {
 
           // Process start token of start/end pair
           const startToken = emphasisTokens[i];
-          const startText =
-            lines[startToken.startLine - 1].slice(startToken.startColumn - 1);
-          const startMatch = startText.match(emphasisStartTextRe);
+          const startLine = lines[startToken.startLine - 1];
+          const startSlice = startLine.slice(startToken.endColumn - 1);
+          const startMatch = startSlice.match(/^\s+\S/);
           if (startMatch) {
-            const [ startContext, startMarker, startSpaces ] = startMatch;
-            if ((startMarker === startToken.text) && (startSpaces.length > 0)) {
-              addError(
-                onError,
-                startToken.startLine,
-                undefined,
-                startContext,
-                [ startToken.startColumn, startContext.length ],
-                {
-                  "editColumn": startToken.endColumn,
-                  "deleteCount": startSpaces.length
-                }
-              );
-            }
+            const [ startSpaceCharacter ] = startMatch;
+            const startContext = `${marker}${startSpaceCharacter}`;
+            addError(
+              onError,
+              startToken.startLine,
+              undefined,
+              startContext,
+              [ startToken.startColumn, startContext.length ],
+              {
+                "editColumn": startToken.endColumn,
+                "deleteCount": startSpaceCharacter.length - 1
+              }
+            );
           }
 
           // Process end token of start/end pair
           const endToken = emphasisTokens[i + 1];
-          const endText =
-            lines[endToken.startLine - 1].slice(0, endToken.endColumn - 1);
-          const endMatch = endText.match(emphasisEndTextRe);
+          const endLine = lines[endToken.startLine - 1];
+          const endSlice = endLine.slice(0, endToken.startColumn - 1);
+          const endMatch = endSlice.match(/\S\s+$/);
           if (endMatch) {
-            const [ endContext, endSpace, endMarker ] = endMatch;
-            if ((endMarker === endToken.text) && (endSpace.length > 0)) {
-              addError(
-                onError,
-                endToken.startLine,
-                undefined,
-                endContext,
-                [ endToken.endColumn - endContext.length, endContext.length ],
-                {
-                  "editColumn": endToken.startColumn - endSpace.length,
-                  "deleteCount": endSpace.length
-                }
-              );
-            }
+            const [ endSpaceCharacter ] = endMatch;
+            const endContext = `${endSpaceCharacter}${marker}`;
+            addError(
+              onError,
+              endToken.startLine,
+              undefined,
+              endContext,
+              [ endToken.endColumn - endContext.length, endContext.length ],
+              {
+                "editColumn":
+                  endToken.startColumn - (endSpaceCharacter.length - 1),
+                "deleteCount": endSpaceCharacter.length - 1
+              }
+            );
           }
         }
       }

package/lib/md043.js

@@ -11,52 +11,54 @@ module.exports = {
   "tags": [ "headings", "headers" ],
   "function": function MD043(params, onError) {
     const requiredHeadings = params.config.headings || params.config.headers;
+    if (!Array.isArray(requiredHeadings)) {
+      // Nothing to check; avoid doing any work
+      return;
+    }
     const matchCase = params.config.match_case || false;
-    if (Array.isArray(requiredHeadings)) {
-      const levels = {};
-      for (const level of [ 1, 2, 3, 4, 5, 6 ]) {
-        levels["h" + level] = "######".substr(-level);
-      }
-      let i = 0;
-      let matchAny = false;
-      let hasError = false;
-      let anyHeadings = false;
-      const getExpected = () => requiredHeadings[i++] || "[None]";
-      const handleCase = (str) => (matchCase ? str : str.toLowerCase());
-      forEachHeading(params, (heading, content) => {
-        if (!hasError) {
-          anyHeadings = true;
-          const actual = levels[heading.tag] + " " + content;
-          const expected = getExpected();
-          if (expected === "*") {
-            const nextExpected = getExpected();
-            if (handleCase(nextExpected) !== handleCase(actual)) {
-              matchAny = true;
-              i--;
-            }
-          } else if (expected === "+") {
+    const levels = {};
+    for (const level of [ 1, 2, 3, 4, 5, 6 ]) {
+      levels["h" + level] = "######".substr(-level);
+    }
+    let i = 0;
+    let matchAny = false;
+    let hasError = false;
+    let anyHeadings = false;
+    const getExpected = () => requiredHeadings[i++] || "[None]";
+    const handleCase = (str) => (matchCase ? str : str.toLowerCase());
+    forEachHeading(params, (heading, content) => {
+      if (!hasError) {
+        anyHeadings = true;
+        const actual = levels[heading.tag] + " " + content;
+        const expected = getExpected();
+        if (expected === "*") {
+          const nextExpected = getExpected();
+          if (handleCase(nextExpected) !== handleCase(actual)) {
             matchAny = true;
-          } else if (handleCase(expected) === handleCase(actual)) {
-            matchAny = false;
-          } else if (matchAny) {
             i--;
-          } else {
-            addErrorDetailIf(onError, heading.lineNumber,
-              expected, actual);
-            hasError = true;
           }
+        } else if (expected === "+") {
+          matchAny = true;
+        } else if (handleCase(expected) === handleCase(actual)) {
+          matchAny = false;
+        } else if (matchAny) {
+          i--;
+        } else {
+          addErrorDetailIf(onError, heading.lineNumber,
+            expected, actual);
+          hasError = true;
         }
-      });
-      const extraHeadings = requiredHeadings.length - i;
-      if (
-        !hasError &&
-        ((extraHeadings > 1) ||
-          ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
-        (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
-      ) {
-        addErrorContext(onError, params.lines.length,
-          requiredHeadings[i]);
       }
+    });
+    const extraHeadings = requiredHeadings.length - i;
+    if (
+      !hasError &&
+      ((extraHeadings > 1) ||
+        ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
+      (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
+    ) {
+      addErrorContext(onError, params.lines.length,
+        requiredHeadings[i]);
     }
   }
 };

package/lib/md044.js

@@ -2,7 +2,7 @@
 
 "use strict";
 
-const { addErrorDetailIf, escapeForRegExp, newLineRe, withinAnyRange } =
+const { addErrorDetailIf, escapeForRegExp, withinAnyRange } =
   require("../helpers");
 const { filterByPredicate, filterByTypes, parse } =
   require("../helpers/micromark.cjs");
@@ -19,46 +19,32 @@ module.exports = {
     let names = params.config.names;
     names = Array.isArray(names) ? names : [];
     names.sort((a, b) => (b.length - a.length) || a.localeCompare(b));
+    if (names.length === 0) {
+      // Nothing to check; avoid doing any work
+      return;
+    }
     const codeBlocks = params.config.code_blocks;
     const includeCodeBlocks =
       (codeBlocks === undefined) ? true : !!codeBlocks;
     const htmlElements = params.config.html_elements;
     const includeHtmlElements =
       (htmlElements === undefined) ? true : !!htmlElements;
-    const scannedTypes = new Set([ "data", "htmlFlowData" ]);
+    const scannedTypes = new Set([ "data" ]);
     if (includeCodeBlocks) {
       scannedTypes.add("codeFlowValue");
       scannedTypes.add("codeTextData");
     }
-    const tokenAdjustments = new Map();
+    if (includeHtmlElements) {
+      scannedTypes.add("htmlFlowData");
+      scannedTypes.add("htmlTextData");
+    }
     const contentTokens =
       filterByPredicate(
         params.parsers.micromark.tokens,
         (token) => scannedTypes.has(token.type),
-        (token) => {
-          let { children } = token;
-          const { startLine, text } = token;
-          if (!includeHtmlElements && (token.type === "htmlFlow")) {
-            if (text.startsWith("<!--")) {
-              // Remove comment content
-              children = [];
-            } else {
-              // Re-parse to get htmlText elements for detailed tokenization
-              const htmlTextLines =
-                `<md044>\n${text}\n</md044>`.split(newLineRe);
-              children = parse(htmlTextLines.join(""));
-              const reTokens = [ ...children ];
-              for (const reToken of reTokens) {
-                tokenAdjustments.set(reToken, {
-                  htmlTextLines,
-                  startLine
-                });
-                reTokens.push(...reToken.children);
-              }
-            }
-          }
-          return children.filter((t) => !ignoredChildTypes.has(t.type));
-        }
+        (token) => (
+          token.children.filter((t) => !ignoredChildTypes.has(t.type))
+        )
       );
     const exclusions = [];
     const autoLinked = new Set();
@@ -96,22 +82,10 @@ module.exports = {
               autoLinked.add(token);
             }
             if (!withinAnyRange(urlRanges, lineIndex, index, length)) {
-              let lineNumber = token.startLine;
-              let column = index;
-              if (tokenAdjustments.has(token)) {
-                const { htmlTextLines, startLine } =
-                  tokenAdjustments.get(token);
-                let lineDelta = 0;
-                while (htmlTextLines[lineDelta].length <= column) {
-                  column -= htmlTextLines[lineDelta].length;
-                  lineDelta++;
-                }
-                lineNumber = startLine + lineDelta - 1;
-              }
-              column++;
+              const column = index + 1;
               addErrorDetailIf(
                 onError,
-                lineNumber,
+                token.startLine,
                 name,
                 nameMatch,
                 null,

package/lib/md049-md050.js

@@ -3,15 +3,18 @@
 "use strict";
 
 const { addError, emphasisOrStrongStyleFor } = require("../helpers");
-const { filterByTypes, tokenIfType } = require("../helpers/micromark.cjs");
+const { filterByPredicate, tokenIfType } = require("../helpers/micromark.cjs");
 
 const intrawordRe = /\w/;
 
 const impl =
   (params, onError, type, asterisk, underline, style = "consistent") => {
     const { lines, parsers } = params;
-    const emphasisTokens =
-      filterByTypes(parsers.micromark.tokens, [ type ]);
+    const emphasisTokens = filterByPredicate(
+      parsers.micromark.tokens,
+      (token) => token.type === type,
+      (token) => ((token.type === "htmlFlow") ? [] : token.children)
+    );
     for (const token of emphasisTokens) {
       const { children } = token;
       const childType = `${type}Sequence`;