markdownlint 0.38.0 → 0.40.0

package/lib/md001.mjs

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { addErrorDetailIf, frontMatterHasTitle } from "../helpers/helpers.cjs";
 import { getHeadingLevel } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
@@ -11,7 +11,11 @@ export default {
   "tags": [ "headings" ],
   "parser": "micromark",
   "function": function MD001(params, onError) {
-    let prevLevel = Number.MAX_SAFE_INTEGER;
+    const hasTitle = frontMatterHasTitle(
+      params.frontMatterLines,
+      params.config.front_matter_title
+    );
+    let prevLevel = hasTitle ? 1 : Number.MAX_SAFE_INTEGER;
     for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
       const level = getHeadingLevel(heading);
       if (level > prevLevel) {

package/lib/md004.mjs

@@ -4,21 +4,9 @@ import { addErrorDetailIf } from "../helpers/helpers.cjs";
 import { getDescendantsByType, getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const markerToStyle = {
-  "-": "dash",
-  "+": "plus",
-  "*": "asterisk"
-};
-const styleToMarker = {
-  "dash": "-",
-  "plus": "+",
-  "asterisk": "*"
-};
-const differentItemStyle = {
-  "dash": "plus",
-  "plus": "asterisk",
-  "asterisk": "dash"
-};
+const markerToStyle = (/** @type {string} */ marker) => (marker === "-") ? "dash" : ((marker === "+") ? "plus" : "asterisk");
+const styleToMarker = (/** @type {string} */ style) => (style === "dash") ? "-" : ((style === "plus") ? "+" : "*");
+const differentItemStyle = (/** @type {string} */ style) => (style === "dash") ? "plus" : ((style === "plus") ? "asterisk" : "dash");
 const validStyles = new Set([
   "asterisk",
   "consistent",
@@ -36,6 +24,7 @@ export default {
   "function": function MD004(params, onError) {
     const style = String(params.config.style || "consistent");
     let expectedStyle = validStyles.has(style) ? style : "dash";
+    /** @type {("asterisk"|"dash"|"plus")[]} */
     const nestingStyles = [];
     for (const listUnordered of filterByTypesCached([ "listUnordered" ])) {
       let nesting = 0;
@@ -49,12 +38,12 @@ export default {
       }
       const listItemMarkers = getDescendantsByType(listUnordered, [ "listItemPrefix", "listItemMarker" ]);
       for (const listItemMarker of listItemMarkers) {
-        const itemStyle = markerToStyle[listItemMarker.text];
+        const itemStyle = markerToStyle(listItemMarker.text);
         if (style === "sublist") {
           if (!nestingStyles[nesting]) {
             nestingStyles[nesting] =
               (itemStyle === nestingStyles[nesting - 1]) ?
-                differentItemStyle[itemStyle] :
+                differentItemStyle(itemStyle) :
                 itemStyle;
           }
           expectedStyle = nestingStyles[nesting];
@@ -74,7 +63,7 @@ export default {
           {
             "editColumn": column,
             "deleteCount": length,
-            "insertText": styleToMarker[expectedStyle]
+            "insertText": styleToMarker(expectedStyle)
           }
         );
       }

package/lib/md007.mjs

@@ -53,8 +53,9 @@ export default {
         const nesting = unorderedListNesting.get(parent);
         if (nesting !== undefined) {
           // listItemPrefix for listUnordered
+          const baseIndent = (getParentOfType(token, [ "gfmFootnoteDefinition" ])) ? 4 : 0;
           const expectedIndent =
-            (startIndented ? startIndent : 0) + (nesting * indent);
+            baseIndent + (startIndented ? startIndent : 0) + (nesting * indent);
           const blockQuoteAdjustment =
             (lastBlockQuotePrefix?.endLine === startLine) ?
               (lastBlockQuotePrefix.endColumn - 1) :

package/lib/md009.mjs

@@ -13,14 +13,18 @@ export default {
   "function": function MD009(params, onError) {
     let brSpaces = params.config.br_spaces;
     brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);
+    const codeBlocks = params.config.code_blocks;
+    const includeCode = (codeBlocks === undefined) ? false : !!codeBlocks;
     const listItemEmptyLines = !!params.config.list_item_empty_lines;
     const strict = !!params.config.strict;
     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);
+    if (!includeCode) {
+      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) {

package/lib/md010.mjs

@@ -17,7 +17,7 @@ export default {
     const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
     const ignoreCodeLanguages = new Set(
       (params.config.ignore_code_languages || [])
-        .map((language) => language.toLowerCase())
+        .map((/** @type {void} */ language) => String(language).toLowerCase())
     );
     const spacesPerTab = params.config.spaces_per_tab;
     const spaceMultiplier = (spacesPerTab === undefined) ?

package/lib/md011.mjs

@@ -4,6 +4,8 @@ import { addError, hasOverlap } from "../helpers/helpers.cjs";
 import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("micromark-extension-math")} */
+
 const reversedLinkRe = /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g;
 
 /** @type {import("markdownlint").Rule} */
@@ -13,14 +15,14 @@ export default {
   "tags": [ "links" ],
   "parser": "micromark",
   "function": function MD011(params, onError) {
-    const codeBlockLineNumbers = new Set();
-    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
-      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    const ignoreBlockLineNumbers = new Set();
+    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "mathFlow" ])) {
+      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
     }
-    const codeTexts = filterByTypesCached([ "codeText" ]);
+    const ignoreTexts = filterByTypesCached([ "codeText", "mathText" ]);
     for (const [ lineIndex, line ] of params.lines.entries()) {
       const lineNumber = lineIndex + 1;
-      if (!codeBlockLineNumbers.has(lineNumber)) {
+      if (!ignoreBlockLineNumbers.has(lineNumber)) {
         let match = null;
         while ((match = reversedLinkRe.exec(line)) !== null) {
           const [ reversedLink, preChar, linkText, linkDestination ] = match;
@@ -32,7 +34,7 @@ export default {
             const length = match[0].length - preChar.length;
             /** @type {import("../helpers/helpers.cjs").FileRange} */
             const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
-            if (!codeTexts.some((codeText) => hasOverlap(codeText, range))) {
+            if (!ignoreTexts.some((ignoreText) => hasOverlap(ignoreText, range))) {
               addError(
                 onError,
                 lineNumber,

package/lib/md013.mjs

@@ -4,10 +4,8 @@ import { addErrorDetailIf } from "../helpers/helpers.cjs";
 import { filterByTypesCached, getReferenceLinkImageData } from "./cache.mjs";
 import { addRangeToSet, getDescendantsByType } from "../helpers/micromark-helpers.cjs";
 
-const longLineRePrefix = "^.{";
-const longLineRePostfixRelaxed = "}.*\\s.*$";
-const longLineRePostfixStrict = "}.+$";
-const sternModeRe = /^(?:[#>\s]*\s)?\S*$/;
+// Regular expression for a line that is not wrappable
+const notWrappableRe = /^(?:[#>\s]*\s)?\S*$/;
 
 /** @typedef {import("micromark-extension-gfm-autolink-literal")} */
 /** @typedef {import("micromark-extension-gfm-table")} */
@@ -20,20 +18,10 @@ export default {
   "parser": "micromark",
   "function": function MD013(params, onError) {
     const lineLength = Number(params.config.line_length || 80);
-    const headingLineLength =
-      Number(params.config.heading_line_length || lineLength);
-    const codeLineLength =
-      Number(params.config.code_block_line_length || lineLength);
+    const headingLineLength = Number(params.config.heading_line_length || lineLength);
+    const codeLineLength = Number(params.config.code_block_line_length || lineLength);
     const strict = !!params.config.strict;
     const stern = !!params.config.stern;
-    const longLineRePostfix =
-      (strict || stern) ? longLineRePostfixStrict : longLineRePostfixRelaxed;
-    const longLineRe =
-      new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
-    const longHeadingLineRe =
-      new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
-    const longCodeLineRe =
-      new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
     const codeBlocks = params.config.code_blocks;
     const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
     const tables = params.config.tables;
@@ -75,28 +63,27 @@ export default {
       const isHeading = headingLineNumbers.has(lineNumber);
       const inCode = codeBlockLineNumbers.has(lineNumber);
       const inTable = tableLineNumbers.has(lineNumber);
-      const length = inCode ?
-        codeLineLength :
-        (isHeading ? headingLineLength : lineLength);
-      const lengthRe = inCode ?
-        longCodeLineRe :
-        (isHeading ? longHeadingLineRe : longLineRe);
-      if ((includeCodeBlocks || !inCode) &&
+      const maxLength = inCode ? codeLineLength : (isHeading ? headingLineLength : lineLength);
+      // If not strict/stern, the last run of non-whitespace is allowed to go
+      // beyond the limit as long as it begins within the limit
+      const text = (strict || stern) ? line : line.replace(/\S*$/u, "#");
+      if ((maxLength > 0) &&
+          (includeCodeBlocks || !inCode) &&
           (includeTables || !inTable) &&
           (includeHeadings || !isHeading) &&
           !definitionLineIndices.has(lineIndex) &&
           (strict ||
-           (!(stern && sternModeRe.test(line)) &&
+           (!(stern && notWrappableRe.test(line)) &&
             !linkOnlyLineNumbers.has(lineNumber))) &&
-          lengthRe.test(line)) {
+          (text.length > maxLength)) {
         addErrorDetailIf(
           onError,
           lineNumber,
-          length,
+          maxLength,
           line.length,
           undefined,
           undefined,
-          [ length + 1, line.length - length ]
+          [ maxLength + 1, line.length - maxLength ]
         );
       }
     }

package/lib/md022.mjs

@@ -4,15 +4,18 @@ import { addErrorDetailIf, isBlankLine } from "../helpers/helpers.cjs";
 import { getBlockQuotePrefixText, getHeadingLevel } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
 const defaultLines = 1;
 
-const getLinesFunction = (linesParam) => {
+// eslint-disable-next-line jsdoc/reject-any-type
+const getLinesFunction = (/** @type {any} */ linesParam) => {
   if (Array.isArray(linesParam)) {
     const linesArray = new Array(6).fill(defaultLines);
     for (const [ index, value ] of [ ...linesParam.entries() ].slice(0, 6)) {
       linesArray[index] = value;
     }
-    return (heading) => linesArray[getHeadingLevel(heading) - 1];
+    return (/** @type {MicromarkToken} */ heading) => linesArray[getHeadingLevel(heading) - 1];
   }
   // Coerce linesParam to a number
   const lines = (linesParam === undefined) ? defaultLines : Number(linesParam);

package/lib/md029.mjs

@@ -11,13 +11,17 @@ const listStyleExamples = {
 };
 
 /**
- * Gets the value of an ordered list item prefix token.
+ * Gets the column and text of an ordered list item prefix token.
  *
  * @param {import("markdownlint").MicromarkToken} listItemPrefix List item prefix token.
- * @returns {number} List item value.
+ * @returns {{column: number, value: number}} List item value column and text.
  */
 function getOrderedListItemValue(listItemPrefix) {
-  return Number(getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0].text);
+  const listItemValue = getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0];
+  return {
+    "column": listItemValue.startColumn,
+    "value": Number(listItemValue.text)
+  };
 }
 
 /** @type {import("markdownlint").Rule} */
@@ -27,34 +31,40 @@ export default {
   "tags": [ "ol" ],
   "parser": "micromark",
   "function": function MD029(params, onError) {
-    const style = String(params.config.style || "one_or_ordered");
+    const style = String(params.config.style);
     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 (listItemPrefixes.length >= 2) {
-        const firstValue = getOrderedListItemValue(listItemPrefixes[0]);
-        const secondValue = getOrderedListItemValue(listItemPrefixes[1]);
-        if ((secondValue !== 1) || (firstValue === 0)) {
+        const first = getOrderedListItemValue(listItemPrefixes[0]);
+        const second = getOrderedListItemValue(listItemPrefixes[1]);
+        if ((second.value !== 1) || (first.value === 0)) {
           incrementing = true;
-          if (firstValue === 0) {
+          if (first.value === 0) {
             expected = 0;
           }
         }
       }
       // Determine effective style
-      let listStyle = style;
-      if (listStyle === "one_or_ordered") {
-        listStyle = incrementing ? "ordered" : "one";
-      } else if (listStyle === "zero") {
+      const listStyle = ((style === "one") || (style === "ordered") || (style === "zero")) ?
+        style :
+        (incrementing ? "ordered" : "one");
+      if (listStyle === "zero") {
         expected = 0;
       } else if (listStyle === "one") {
         expected = 1;
       }
       // Validate each list item marker
       for (const listItemPrefix of listItemPrefixes) {
-        const actual = getOrderedListItemValue(listItemPrefix);
+        const orderedListItemValue = getOrderedListItemValue(listItemPrefix);
+        const actual = orderedListItemValue.value;
+        const fixInfo = {
+          "editColumn": orderedListItemValue.column,
+          "deleteCount": orderedListItemValue.value.toString().length,
+          "insertText": expected.toString()
+        };
         addErrorDetailIf(
           onError,
           listItemPrefix.startLine,
@@ -62,7 +72,8 @@ export default {
           actual,
           "Style: " + listStyleExamples[listStyle],
           undefined,
-          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ]
+          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ],
+          fixInfo
         );
         if (listStyle === "ordered") {
           expected++;

package/lib/md031.mjs

@@ -6,7 +6,6 @@ import { filterByTypesCached } from "./cache.mjs";
 
 const codeFencePrefixRe = /^(.*?)[`~]/;
 
-// eslint-disable-next-line jsdoc/valid-types
 /** @typedef {readonly string[]} ReadonlyStringArray */
 
 /**

package/lib/md032.mjs

@@ -4,7 +4,9 @@ import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
 import { filterByPredicate, getBlockQuotePrefixText, nonContentTokens } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const isList = (token) => (
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
+const isList = (/** @type {MicromarkToken} */ token) => (
   (token.type === "listOrdered") || (token.type === "listUnordered")
 );
 

package/lib/md033.mjs

@@ -1,9 +1,14 @@
 // @ts-check
 
 import { addError, nextLinesRe } from "../helpers/helpers.cjs";
-import { getHtmlTagInfo } from "../helpers/micromark-helpers.cjs";
+import { getHtmlTagInfo, getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("micromark-extension-gfm-table")} */
+
+// eslint-disable-next-line jsdoc/reject-any-type
+const toLowerCaseStringArray = (/** @type {any} */ arr) => Array.isArray(arr) ? arr.map((elm) => String(elm).toLowerCase()) : [];
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD033", "no-inline-html" ],
@@ -11,27 +16,30 @@ export default {
   "tags": [ "html" ],
   "parser": "micromark",
   "function": function MD033(params, onError) {
-    let allowedElements = params.config.allowed_elements;
-    allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
-    allowedElements = allowedElements.map((element) => element.toLowerCase());
+    const allowedElements = toLowerCaseStringArray(params.config.allowed_elements);
+    // If not defined, use allowedElements for backward compatibility
+    const tableAllowedElements = toLowerCaseStringArray(params.config.table_allowed_elements || params.config.allowed_elements);
     for (const token of filterByTypesCached([ "htmlText" ], true)) {
       const htmlTagInfo = getHtmlTagInfo(token);
-      if (
-        htmlTagInfo &&
-        !htmlTagInfo.close &&
-        !allowedElements.includes(htmlTagInfo.name.toLowerCase())
-      ) {
-        const range = [
-          token.startColumn,
-          token.text.replace(nextLinesRe, "").length
-        ];
-        addError(
-          onError,
-          token.startLine,
-          "Element: " + htmlTagInfo.name,
-          undefined,
-          range
-        );
+      if (htmlTagInfo && !htmlTagInfo.close) {
+        const elementName = htmlTagInfo?.name.toLowerCase();
+        const inTable = !!getParentOfType(token, [ "table" ]);
+        if (
+          (inTable || !allowedElements.includes(elementName)) &&
+          (!inTable || !tableAllowedElements.includes(elementName))
+        ) {
+          const range = [
+            token.startColumn,
+            token.text.replace(nextLinesRe, "").length
+          ];
+          addError(
+            onError,
+            token.startLine,
+            "Element: " + htmlTagInfo.name,
+            undefined,
+            range
+          );
+        }
       }
     }
   }

package/lib/md034.mjs

@@ -3,6 +3,7 @@
 import { addErrorContext } from "../helpers/helpers.cjs";
 import { filterByPredicate, getHtmlTagInfo, inHtmlFlow } from "../helpers/micromark-helpers.cjs";
 
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
 /** @typedef {import("micromark-extension-gfm-autolink-literal")} */
 
 /** @type {import("markdownlint").Rule} */
@@ -12,7 +13,7 @@ export default {
   "tags": [ "links", "url" ],
   "parser": "micromark",
   "function": function MD034(params, onError) {
-    const literalAutolinks = (tokens) => (
+    const literalAutolinks = (/** @type {MicromarkToken[]} */ tokens) => (
       filterByPredicate(
         tokens,
         (token) => {

package/lib/md036.mjs

@@ -4,14 +4,16 @@ import { addErrorContext, allPunctuation } from "../helpers/helpers.cjs";
 import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-/** @typedef {import("markdownlint").MicromarkTokenType} TokenType */
-/** @type {TokenType[][]} */
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+
+/** @type {MicromarkTokenType[][]} */
 const emphasisTypes = [
   [ "emphasis", "emphasisText" ],
   [ "strong", "strongText" ]
 ];
 
-const isParagraphChildMeaningful = (token) => !(
+const isParagraphChildMeaningful = (/** @type {MicromarkToken} */ token) => !(
   (token.type === "htmlText") ||
   ((token.type === "data") && (token.text.trim().length === 0))
 );

package/lib/md037.mjs

@@ -50,15 +50,17 @@ export default {
           if (startMatch) {
             const [ startSpaceCharacter ] = startMatch;
             const startContext = `${marker}${startSpaceCharacter}`;
+            const column = startToken.endColumn;
+            const count = startSpaceCharacter.length - 1;
             addError(
               onError,
               startToken.startLine,
               undefined,
               startContext,
-              [ startToken.startColumn, startContext.length ],
+              [ column, count ],
               {
-                "editColumn": startToken.endColumn,
-                "deleteCount": startSpaceCharacter.length - 1
+                "editColumn": column,
+                "deleteCount": count
               }
             );
           }
@@ -71,16 +73,17 @@ export default {
           if (endMatch) {
             const [ endSpaceCharacter ] = endMatch;
             const endContext = `${endSpaceCharacter}${marker}`;
+            const column = endToken.startColumn - (endSpaceCharacter.length - 1);
+            const count = endSpaceCharacter.length - 1;
             addError(
               onError,
               endToken.startLine,
               undefined,
               endContext,
-              [ endToken.endColumn - endContext.length, endContext.length ],
+              [ column, count ],
               {
-                "editColumn":
-                  endToken.startColumn - (endSpaceCharacter.length - 1),
-                "deleteCount": endSpaceCharacter.length - 1
+                "editColumn": column,
+                "deleteCount": count
               }
             );
           }

package/lib/md042.mjs

@@ -4,6 +4,8 @@ import { addErrorContext } from "../helpers/helpers.cjs";
 import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
 import { getReferenceLinkImageData, filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD042", "no-empty-links" ],
@@ -12,9 +14,9 @@ export default {
   "parser": "micromark",
   "function": function MD042(params, onError) {
     const { definitions } = getReferenceLinkImageData();
-    const isReferenceDefinitionHash = (token) => {
+    const isReferenceDefinitionHash = (/** @type {MicromarkToken} */ token) => {
       const definition = definitions.get(token.text.trim());
-      return (definition && (definition[1] === "#"));
+      return Boolean(definition && (definition[1] === "#"));
     };
     const links = filterByTypesCached([ "link" ]);
     for (const link of links) {

package/lib/md043.mjs

@@ -21,8 +21,8 @@ export default {
     let matchAny = false;
     let hasError = false;
     let anyHeadings = false;
-    const getExpected = () => requiredHeadings[i++] || "[None]";
-    const handleCase = (str) => (matchCase ? str : str.toLowerCase());
+    const getExpected = () => String(requiredHeadings[i++] || "[None]");
+    const handleCase = (/** @type {string} */ str) => (matchCase ? str : str.toLowerCase());
     for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
       if (!hasError) {
         const headingText = getHeadingText(heading);

package/lib/md044.mjs

@@ -17,7 +17,7 @@ export default {
   "function": function MD044(params, onError) {
     let names = params.config.names;
     names = Array.isArray(names) ? names : [];
-    names.sort((a, b) => (b.length - a.length) || a.localeCompare(b));
+    names.sort((/** @type {string} */ a, /** @type {string} */ b) => (b.length - a.length) || a.localeCompare(b));
     if (names.length === 0) {
       // Nothing to check; avoid doing any work
       return;

package/lib/md046.mjs

@@ -3,10 +3,9 @@
 import { addErrorDetailIf } from "../helpers/helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const tokenTypeToStyle = {
-  "codeFenced": "fenced",
-  "codeIndented": "indented"
-};
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+
+const tokenTypeToStyle = (/** @type {MicromarkTokenType} */ tokenType) => (tokenType === "codeFenced") ? "fenced" : "indented";
 
 /** @type {import("markdownlint").Rule} */
 export default {
@@ -19,13 +18,14 @@ export default {
     for (const token of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
       const { startLine, type } = token;
       if (expectedStyle === "consistent") {
-        expectedStyle = tokenTypeToStyle[type];
+        expectedStyle = tokenTypeToStyle(type);
       }
       addErrorDetailIf(
         onError,
         startLine,
         expectedStyle,
-        tokenTypeToStyle[type]);
+        tokenTypeToStyle(type)
+      );
     }
   }
 };

package/lib/md053.mjs

@@ -16,7 +16,7 @@ export default {
     const lines = params.lines;
     const { references, shortcuts, definitions, duplicateDefinitions } =
       getReferenceLinkImageData();
-    const singleLineDefinition = (line) => (
+    const singleLineDefinition = (/** @type {string} */ line) => (
       line.replace(linkReferenceDefinitionRe, "").trim().length > 0
     );
     const deleteFixInfo = {

package/lib/md054.mjs

@@ -5,9 +5,9 @@ import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
 import { getReferenceLinkImageData, filterByTypesCached } from "./cache.mjs";
 
 const backslashEscapeRe = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
-const removeBackslashEscapes = (text) => text.replace(backslashEscapeRe, "$1");
+const removeBackslashEscapes = (/** @type {string} **/ text) => text.replace(backslashEscapeRe, "$1");
 const autolinkDisallowedRe = /[ <>]/;
-const autolinkAble = (destination) => {
+const autolinkAble = (/** @type {string} */ destination) => {
   try {
     // eslint-disable-next-line no-new
     new URL(destination);
@@ -73,9 +73,11 @@ export default {
           const referenceString = getDescendantsByType(link, [ "reference", "referenceString" ])[0]?.text;
           const isCollapsed = (referenceString === undefined);
           const definition = definitions.get(referenceString || label);
-          destination = definition && definition[1];
-          isError = destination &&
-            (isShortcut ? !shortcut : (isCollapsed ? !collapsed : !full));
+          destination = (definition && definition[1]) || "";
+          isError = Boolean(
+            destination &&
+            (isShortcut ? !shortcut : (isCollapsed ? !collapsed : !full))
+          );
         }
       }
       if (isError) {