markdownlint 0.41.0 → 0.42.0

package/lib/md022.mjs

@@ -11,14 +11,15 @@ const defaultLines = 1;
 // eslint-disable-next-line jsdoc/reject-any-type
 const getLinesFunction = (/** @type {any} */ linesParam) => {
   if (Array.isArray(linesParam)) {
+    // eslint-disable-next-line unicorn/no-unreadable-new-expression
     const linesArray = new Array(6).fill(defaultLines);
-    for (const [ index, value ] of [ ...linesParam.entries() ].slice(0, 6)) {
+    for (const [ index, value ] of linesParam.slice(0, 6).entries()) {
       linesArray[index] = value;
     }
     return (/** @type {MicromarkToken} */ heading) => linesArray[getHeadingLevel(heading) - 1];
   }
   // Coerce linesParam to a number
-  const lines = (linesParam === undefined) ? defaultLines : Number(linesParam);
+  const lines = Number(linesParam ?? defaultLines);
   return () => lines;
 };
 
@@ -26,10 +27,9 @@ const getLine = (/** @type {readonly string[]} */ lines, /** @type {number} */ i
   if ((index >= 0) && (index < lines.length)) {
     return lines[index];
   }
-  if (includeFrontMatter && (frontMatterLines.length > 0) && (index < 0) && (index >= -frontMatterLines.length)) {
-    return frontMatterLines[frontMatterLines.length + index];
-  }
-  return "";
+  return (includeFrontMatter && (frontMatterLines.length > 0) && (index < 0) && (index >= -frontMatterLines.length)) ?
+    frontMatterLines[frontMatterLines.length + index] :
+    "";
 };
 
 /** @type {import("markdownlint").Rule} */

package/lib/md024.mjs

@@ -11,7 +11,7 @@ export default {
   "tags": [ "headings" ],
   "parser": "micromark",
   "function": function MD024(params, onError) {
-    const siblingsOnly = !!params.config.siblings_only || false;
+    const siblingsOnly = !!params.config.siblings_only;
     const knownContents = [ null, [] ];
     let lastLevel = 1;
     let knownContent = knownContents[lastLevel];

package/lib/md025.mjs

@@ -11,7 +11,7 @@ export default {
   "tags": [ "headings" ],
   "parser": "micromark",
   "function": function MD025(params, onError) {
-    const level = Number(params.config.level || 1);
+    const level = Number(params.config.level ?? 1);
     const { tokens } = params.parsers.micromark;
     const matchingHeadings = filterByTypesCached([ "atxHeading", "setextHeading" ])
       .filter((heading) => (level === getHeadingLevel(heading)) && !isDocfxTab(heading));

package/lib/md027.mjs

@@ -15,7 +15,7 @@ export default {
   "parser": "micromark",
   "function": function MD027(params, onError) {
     const listItems = params.config.list_items;
-    const includeListItems = (listItems === undefined) ? true : !!listItems;
+    const includeListItems = (listItems === undefined) || !!listItems;
     const { tokens } = params.parsers.micromark;
     for (const token of filterByTypesCached([ "linePrefix" ])) {
       const parent = token.parent;

package/lib/md028.mjs

@@ -16,8 +16,7 @@ export default {
       const errorLineNumbers = [];
       const siblings = token.parent?.children || params.parsers.micromark.tokens;
       for (let i = siblings.indexOf(token) + 1; i < siblings.length; i++) {
-        const sibling = siblings[i];
-        const { startLine, type } = sibling;
+        const { startLine, type } = siblings[i];
         if (type === "lineEndingBlank") {
           // Possible blank between blockquotes
           errorLineNumbers.push(startLine);

package/lib/md029.mjs

@@ -15,13 +15,15 @@ const listStyles = Object.keys(listStyleExamples);
  * Gets the column and text of an ordered list item prefix token.
  *
  * @param {import("markdownlint").MicromarkToken} listItemPrefix List item prefix token.
- * @returns {{column: number, value: number}} List item value column and text.
+ * @returns {{startColumn: number, endColumn: number, text: string, number: number}} List item value column and text.
  */
 function getOrderedListItemValue(listItemPrefix) {
-  const listItemValue = getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0];
+  const { startColumn, endColumn, text } = getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0];
   return {
-    "column": listItemValue.startColumn,
-    "value": Number(listItemValue.text)
+    startColumn,
+    endColumn,
+    text,
+    "number": Number(text)
   };
 }
 
@@ -35,40 +37,49 @@ export default {
     const style = String(params.config.style);
     for (const listOrdered of filterByTypesCached([ "listOrdered" ])) {
       const listItemPrefixes = getDescendantsByType(listOrdered, [ "listItemPrefix" ]);
-      let expected = 1;
+      let expectedNumber = 1;
       let incrementing = false;
-      // Check for incrementing number pattern 1/2/3 or 0/1/2
-      if (listItemPrefixes.length >= 2) {
-        const first = getOrderedListItemValue(listItemPrefixes[0]);
-        const second = getOrderedListItemValue(listItemPrefixes[1]);
-        if ((second.value !== 1) || (first.value === 0)) {
-          incrementing = true;
-          if (first.value === 0) {
-            expected = 0;
+      let rightAligned = false;
+      let zeroPrefixed = false;
+      if (listItemPrefixes.length > 0) {
+        // Check for right alignment
+        const firstPrefixEndColumn = listItemPrefixes[0].endColumn;
+        rightAligned = listItemPrefixes.every((prefix) => prefix.endColumn === firstPrefixEndColumn);
+        if (listItemPrefixes.length > 1) {
+          // Check for incrementing number pattern 1/2/3 or 0/1/2
+          const firstValue = getOrderedListItemValue(listItemPrefixes[0]);
+          const secondValue = getOrderedListItemValue(listItemPrefixes[1]);
+          if ((secondValue.number !== 1) || (firstValue.number === 0)) {
+            incrementing = true;
+            if (firstValue.number === 0) {
+              expectedNumber = 0;
+            }
           }
+          zeroPrefixed = firstValue.text.startsWith("0");
         }
       }
       // Determine effective style
       const listStyle = listStyles.includes(style) ? style : (incrementing ? "ordered" : "one");
       if (listStyle === "zero") {
-        expected = 0;
+        expectedNumber = 0;
       } else if (listStyle === "one") {
-        expected = 1;
+        expectedNumber = 1;
       }
       // Validate each list item marker
       for (const listItemPrefix of listItemPrefixes) {
-        const orderedListItemValue = getOrderedListItemValue(listItemPrefix);
-        const actual = orderedListItemValue.value;
+        const expectedText = expectedNumber.toString();
+        const { endColumn, startColumn, "number": actualNumber } = getOrderedListItemValue(listItemPrefix);
+        const length = endColumn - startColumn;
         const fixInfo = {
-          "editColumn": orderedListItemValue.column,
-          "deleteCount": orderedListItemValue.value.toString().length,
-          "insertText": expected.toString()
+          "editColumn": startColumn,
+          "deleteCount": length,
+          "insertText": rightAligned ? expectedText.padStart(length, (zeroPrefixed ? "0" : " ")) : expectedText
         };
         addErrorDetailIf(
           onError,
           listItemPrefix.startLine,
-          expected,
-          actual,
+          expectedNumber,
+          actualNumber,
           // @ts-ignore
           "Style: " + listStyleExamples[listStyle],
           undefined,
@@ -76,7 +87,7 @@ export default {
           fixInfo
         );
         if (listStyle === "ordered") {
-          expected++;
+          expectedNumber++;
         }
       }
     }

package/lib/md030.mjs

@@ -10,10 +10,10 @@ export default {
   "tags": [ "ol", "ul", "whitespace" ],
   "parser": "micromark",
   "function": function MD030(params, onError) {
-    const ulSingle = Number(params.config.ul_single || 1);
-    const olSingle = Number(params.config.ol_single || 1);
-    const ulMulti = Number(params.config.ul_multi || 1);
-    const olMulti = Number(params.config.ol_multi || 1);
+    const ulSingle = Number(params.config.ul_single ?? 1);
+    const olSingle = Number(params.config.ol_single ?? 1);
+    const ulMulti = Number(params.config.ul_multi ?? 1);
+    const olMulti = Number(params.config.ol_multi ?? 1);
     for (const list of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
       const ordered = (list.type === "listOrdered");
       const listItemPrefixes =

package/lib/md031.mjs

@@ -45,7 +45,7 @@ export default {
   "parser": "micromark",
   "function": function MD031(params, onError) {
     const listItems = params.config.list_items;
-    const includeListItems = (listItems === undefined) ? true : !!listItems;
+    const includeListItems = (listItems === undefined) || !!listItems;
     const { lines } = params;
     for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
       if (includeListItems || !(getParentOfType(codeBlock, [ "listOrdered", "listUnordered" ]))) {

package/lib/md032.mjs

@@ -52,10 +52,11 @@ export default {
         (token) => !nonContentTokens.has(token.type),
         (token) => nonContentTokens.has(token.type) ? [] : token.children
       );
-      let endLine = list.endLine;
-      if (flattenedChildren.length > 0) {
-        endLine = flattenedChildren[flattenedChildren.length - 1].endLine;
-      }
+      const endLine = (
+        (flattenedChildren.length > 0) ?
+          flattenedChildren[flattenedChildren.length - 1] :
+          list
+      ).endLine;
 
       // Look for a blank line below the list
       const lastLineNumber = endLine;

package/lib/md033.mjs

@@ -4,7 +4,7 @@ import { addError, nextLinesRe } from "../helpers/helpers.cjs";
 import { getHtmlTagInfo, getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-/** @typedef {import("micromark-extension-gfm-table")} */
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
 
 // eslint-disable-next-line jsdoc/reject-any-type
 const toLowerCaseStringArray = (/** @type {any} */ arr) => Array.isArray(arr) ? arr.map((elm) => String(elm).toLowerCase()) : [];

package/lib/md034.mjs

@@ -4,7 +4,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")} */
+/** @typedef {typeof import("micromark-extension-gfm-autolink-literal")} _ambient_ */
 
 /** @type {import("markdownlint").Rule} */
 export default {

package/lib/md037.mjs

@@ -38,8 +38,7 @@ export default {
       }
 
       // Process bare tokens for each emphasis marker type
-      for (const entry of emphasisTokensByMarker.entries()) {
-        const [ marker, emphasisTokens ] = entry;
+      for (const [ marker, emphasisTokens ] of emphasisTokensByMarker) {
         for (let i = 0; i + 1 < emphasisTokens.length; i += 2) {
 
           // Process start token of start/end pair

package/lib/md039.mjs

@@ -1,8 +1,12 @@
 // @ts-check
 
+import { re } from "re2js";
 import { addErrorContext } from "../helpers/helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+const startRe = re`^[^\S\r\n]+`;
+const endRe = re`[^\S\r\n]+$`;
+
 /**
  * Adds an error for a label space issue.
  *
@@ -12,7 +16,7 @@ import { filterByTypesCached } from "./cache.mjs";
  * @param {boolean} isStart True iff error is at the start of the link.
  */
 function addLabelSpaceError(onError, label, labelText, isStart) {
-  const match = labelText.text.match(isStart ? /^[^\S\r\n]+/ : /[^\S\r\n]+$/);
+  const match = (isStart ? startRe : endRe).exec(labelText.text);
   const range = match ?
     [
       (isStart ? (labelText.startColumn) : (labelText.endColumn - match[0].length)),

package/lib/md041.mjs

@@ -31,7 +31,7 @@ export default {
   "parser": "micromark",
   "function": function MD041(params, onError) {
     const allowPreamble = !!params.config.allow_preamble;
-    const level = Number(params.config.level || 1);
+    const level = Number(params.config.level ?? 1);
     const { tokens } = params.parsers.micromark;
     if (
       !frontMatterHasTitle(

package/lib/md043.mjs

@@ -1,9 +1,32 @@
 // @ts-check
 
-import { addErrorContext, addErrorDetailIf } from "../helpers/helpers.cjs";
+import { addError, addErrorDetailIf } from "../helpers/helpers.cjs";
 import { getHeadingLevel, getHeadingText } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+export const headingsItemsRe = /^(?:[*+?]|\^+|[#%]{1,6}\s+\S.*)$/u;
+const prefixedHeadingPartsRe = /^([#%]{1,6})\s+(\S.*)$/u;
+const loopHeadingRe = /^\^+$/u;
+const canMatchNothingHeadingsRe = /^(?:\*|\^+)$/u;
+const maximumLoopsAllowed = 1000;
+
+const headingIsExpected = (/** @type {string} */ actual, /** @type {string} */ expected, /** @type {boolean} */ matchCase) => {
+  if (expected.startsWith("%")) {
+    // Regular expression comparison
+    const [ , actualLevel, actualText ] = prefixedHeadingPartsRe.exec(actual) || [];
+    const [ , expectedLevel, expectedText ] = prefixedHeadingPartsRe.exec(expected) || [];
+    return (
+      (actualLevel.length === expectedLevel.length) &&
+      // eslint-disable-next-line unicorn/no-unreadable-new-expression
+      (new RegExp(expectedText, `${matchCase ? "" : "i"}u`)).test(actualText)
+    );
+  }
+  // Text comparison
+  const actualLower = matchCase ? actual : actual.toLowerCase();
+  const expectedLower = matchCase ? expected : expected.toLowerCase();
+  return actualLower === expectedLower;
+};
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD043", "required-headings" ],
@@ -11,62 +34,93 @@ export default {
   "tags": [ "headings" ],
   "parser": "micromark",
   "function": function MD043(params, onError) {
-    const requiredHeadings = params.config.headings;
-    if (!Array.isArray(requiredHeadings)) {
-      // Nothing to check; avoid doing any work
+    /** @type {string[] | null | undefined} */
+    const headings = params.config.headings;
+    if (!headings) {
       return;
     }
-    const matchCase = params.config.match_case || false;
+    const requiredHeadings = headings.map((heading) => headingsItemsRe.test(heading) ? heading : "[Invalid syntax]");
+    const matchCase = Boolean(params.config.match_case);
     let i = 0;
-    let matchAny = false;
+    let remainingLoopsAllowed = maximumLoopsAllowed;
+    let allowAnyMatchFallback = false;
     let hasError = false;
-    let anyHeadings = false;
-    const getExpected = () => String(requiredHeadings[i++] || "[None]");
-    const handleCase = (/** @type {string} */ str) => (matchCase ? str : str.toLowerCase());
+    const getExpected = (/** @type {boolean} */ skipLoopHeadings) => {
+      let expected = null;
+      do {
+        expected = requiredHeadings[i++] || "[No heading]";
+        // eslint-disable-next-line no-unmodified-loop-condition
+      } while (skipLoopHeadings && loopHeadingRe.test(expected));
+      return expected;
+    };
     for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
-      if (!hasError) {
-        const headingText = getHeadingText(heading);
-        const headingLevel = getHeadingLevel(heading);
-        anyHeadings = true;
-        const actual = `${"".padEnd(headingLevel, "#")} ${headingText}`;
-        const expected = getExpected();
-        if (expected === "*") {
-          const nextExpected = getExpected();
-          if (handleCase(nextExpected) !== handleCase(actual)) {
-            matchAny = true;
-            i--;
+      const headingText = getHeadingText(heading);
+      const headingLevel = getHeadingLevel(heading);
+      const actual = `${"".padEnd(headingLevel, "#")} ${headingText}`;
+      let expected = getExpected(false);
+      if (expected.startsWith("^")) {
+        // Handle loop
+        const current = i;
+        const nextExpected = getExpected(true);
+        if (headingIsExpected(actual, nextExpected, matchCase)) {
+          // No need to loop (again)
+          expected = nextExpected;
+        } else {
+          // Try to loop to previous matching marker
+          remainingLoopsAllowed--;
+          let j = current - 2;
+          for (; j >= 0; j--) {
+            if (requiredHeadings[j] === expected) {
+              // Perform loop
+              i = j + 1;
+              expected = getExpected(false);
+              break;
+            }
           }
-        } else if (expected === "+") {
-          matchAny = true;
-        } else if (expected === "?") {
-          // Allow current, match next
-        } else if (handleCase(expected) === handleCase(actual)) {
-          matchAny = false;
-        } else if (matchAny) {
+          if (j < 0) {
+            // No matching loop marker
+            expected = nextExpected;
+          }
+        }
+      }
+      if (remainingLoopsAllowed < 0) {
+        // Too many loops performed
+        addError(onError, heading.startLine, "Too many loops", `Limit: ${maximumLoopsAllowed}`);
+        hasError = true;
+        break;
+      } else if (expected === "*") {
+        // Handle "zero or more of anything"
+        const nextExpected = getExpected(true);
+        if (!headingIsExpected(actual, nextExpected, matchCase)) {
+          allowAnyMatchFallback = true;
           i--;
-        } else {
-          addErrorDetailIf(
-            onError,
-            heading.startLine,
-            expected,
-            actual
-          );
-          hasError = true;
         }
+      } else if (expected === "+") {
+        // Handle "one or more of anything"
+        allowAnyMatchFallback = true;
+      } else if (expected === "?") {
+        // Handle "exactly one of anything"
+        // Nothing to do
+      } else if (headingIsExpected(actual, expected, matchCase)) {
+        // Handle successful match
+        allowAnyMatchFallback = false;
+      } else if (allowAnyMatchFallback) {
+        // Handle "anything" match by restoring index
+        i--;
+      } else {
+        // Report heading mismatch
+        addErrorDetailIf(onError, heading.startLine, expected, actual);
+        hasError = true;
+        break;
       }
     }
-    const extraHeadings = requiredHeadings.length - i;
+    const remainingRequiredHeadings = requiredHeadings.slice(i).filter((heading) => !canMatchNothingHeadingsRe.test(heading));
     if (
       !hasError &&
-      ((extraHeadings > 1) ||
-        ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
-      (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
+      (remainingRequiredHeadings.length > 0)
     ) {
-      addErrorContext(
-        onError,
-        params.lines.length,
-        requiredHeadings[i]
-      );
+      // Report unmatched heading(s)
+      addErrorDetailIf(onError, params.lines.length, remainingRequiredHeadings[0], "[End of file]");
     }
   }
 };

package/lib/md044.mjs

@@ -24,10 +24,10 @@ export default {
     }
     const codeBlocks = params.config.code_blocks;
     const includeCodeBlocks =
-      (codeBlocks === undefined) ? true : !!codeBlocks;
+      (codeBlocks === undefined) || !!codeBlocks;
     const htmlElements = params.config.html_elements;
     const includeHtmlElements =
-      (htmlElements === undefined) ? true : !!htmlElements;
+      (htmlElements === undefined) || !!htmlElements;
     const scannedTypes = new Set([ "data" ]);
     if (includeCodeBlocks) {
       scannedTypes.add("codeFlowValue");

package/lib/md048.mjs

@@ -30,9 +30,7 @@ export default {
     let expectedStyle = style;
     const codeFenceds = filterByTypesCached([ "codeFenced" ]);
     for (const codeFenced of codeFenceds) {
-      const codeFencedFenceSequence =
-        getDescendantsByType(codeFenced, [ "codeFencedFence", "codeFencedFenceSequence" ])[0];
-      const { startLine, text } = codeFencedFenceSequence;
+      const { startLine, text } = getDescendantsByType(codeFenced, [ "codeFencedFence", "codeFencedFenceSequence" ])[0];
       if (expectedStyle === "consistent") {
         expectedStyle = fencedCodeBlockStyleFor(text);
       }

package/lib/md051.mjs

@@ -7,7 +7,7 @@ import { filterByTypesCached } from "./cache.mjs";
 // Regular expression for identifying HTML anchor names
 const idRe = getHtmlAttributeRe("id");
 const nameRe = getHtmlAttributeRe("name");
-const anchorRe = /\{(#[a-z\d]+(?:[-_][a-z\d]+)*)\}/gu;
+const anchorRe = /\{(#[a-z\d]+(?:[-_]+[a-z\d]+)*)\}/gu;
 const lineFragmentRe = /^#(?:L\d+(?:C\d+)?-L\d+(?:C\d+)?|L\d+)$/;
 
 // Sets for filtering heading tokens during conversion
@@ -17,8 +17,7 @@ const tokensInclude = new Set(
 );
 
 /**
- * Converts a Markdown heading into an HTML fragment according to the rules
- * used by GitHub.
+ * Converts a Markdown heading into an HTML fragment according to the rules used by GitHub.
  *
  * @param {import("markdownlint").MicromarkToken} headingText Heading text token.
  * @returns {string} Fragment string for heading.
@@ -141,6 +140,7 @@ export default {
               };
             }
             const textLower = text.toLowerCase();
+            // eslint-disable-next-line unicorn/prefer-iterator-helpers
             const mixedCaseKey = [ ...fragments.keys() ]
               .find((key) => textLower === key.toLowerCase());
             if (mixedCaseKey) {

package/lib/md055.mjs

@@ -1,10 +1,11 @@
 // @ts-check
 
 import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
 /** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
-/** @typedef {import("micromark-extension-gfm-table")} */
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
 
 const whitespaceTypes = new Set([ "linePrefix", "whitespace" ]);
 const ignoreWhitespace = (/** @type {MicromarkToken[]} */ tokens) => tokens.filter(
@@ -27,8 +28,17 @@ export default {
       ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "trailing_only"));
     let expectedTrailingPipe =
       ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "leading_only"));
+    let currentTable = null;
     const rows = filterByTypesCached([ "tableDelimiterRow", "tableRow" ]);
     for (const row of rows) {
+      if (style === "per_table") {
+        // Reset style for each new table
+        const rowTable = getParentOfType(row, [ "table" ]);
+        if (rowTable !== currentTable) {
+          expectedStyle = "consistent";
+          currentTable = rowTable;
+        }
+      }
       // The following uses of first/lastOrNothing lack fallback handling
       // because it seems not to be possible (i.e., 0% coverage)
       const firstCell = firstOrNothing(row.children);

package/lib/md056.mjs

@@ -6,7 +6,7 @@ import { filterByTypesCached } from "./cache.mjs";
 
 const makeRange = (/** @type {number} */ start, /** @type {number} */ end) => [ start, end - start + 1 ];
 
-/** @typedef {import("micromark-extension-gfm-table")} */
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
 
 /** @type {import("markdownlint").Rule} */
 export default {

package/lib/md058.mjs

@@ -4,7 +4,7 @@ import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
 import { getBlockQuotePrefixText } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-/** @typedef {import("micromark-extension-gfm-table")} */
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
 
 /** @type {import("markdownlint").Rule} */
 export default {