markdownlint 0.37.4 → 0.39.0

package/lib/md041.mjs

@@ -3,6 +3,26 @@
 import { addErrorContext, frontMatterHasTitle } from "../helpers/helpers.cjs";
 import { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } from "../helpers/micromark-helpers.cjs";
 
+const headingTagNameRe = /^h[1-6]$/;
+
+/**
+ * Gets the HTML tag name of an htmlFlow token.
+ *
+ * @param {import("markdownlint").MicromarkToken} token Micromark Token.
+ * @returns {string | null} Tag name.
+ */
+function getHtmlFlowTagName(token) {
+  const { children, type } = token;
+  if (type === "htmlFlow") {
+    const htmlTexts = filterByTypes(children, [ "htmlText" ], true);
+    const tagInfo = (htmlTexts.length > 0) && getHtmlTagInfo(htmlTexts[0]);
+    if (tagInfo) {
+      return tagInfo.name.toLowerCase();
+    }
+  }
+  return null;
+}
+
 /** @type {import("markdownlint").Rule} */
 export default {
   "names": [ "MD041", "first-line-heading", "first-line-h1" ],
@@ -10,24 +30,42 @@ export default {
   "tags": [ "headings" ],
   "parser": "micromark",
   "function": function MD041(params, onError) {
+    const allowPreamble = !!params.config.allow_preamble;
     const level = Number(params.config.level || 1);
-    if (!frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title)) {
-      params.parsers.micromark.tokens
-        .filter((token) => !nonContentTokens.has(token.type) && !isHtmlFlowComment(token))
-        .every((token) => {
-          let isError = true;
-          if ((token.type === "atxHeading") || (token.type === "setextHeading")) {
-            isError = (getHeadingLevel(token) !== level);
-          } else if (token.type === "htmlFlow") {
-            const htmlTexts = filterByTypes(token.children, [ "htmlText" ], true);
-            const tagInfo = (htmlTexts.length > 0) && getHtmlTagInfo(htmlTexts[0]);
-            isError = !tagInfo || (tagInfo.name.toLowerCase() !== `h${level}`);
-          }
-          if (isError) {
-            addErrorContext(onError, token.startLine, params.lines[token.startLine - 1]);
+    const { tokens } = params.parsers.micromark;
+    if (
+      !frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      )
+    ) {
+      let errorLineNumber = 0;
+      for (const token of tokens) {
+        const { startLine, type } = token;
+        if (!nonContentTokens.has(type) && !isHtmlFlowComment(token)) {
+          let tagName = null;
+          if ((type === "atxHeading") || (type === "setextHeading")) {
+            // First heading needs to have the expected level
+            if (getHeadingLevel(token) !== level) {
+              errorLineNumber = startLine;
+            }
+            break;
+          } else if ((tagName = getHtmlFlowTagName(token)) && headingTagNameRe.test(tagName)) {
+            // First HTML element needs to have an <h?> with the expected level
+            if (tagName !== `h${level}`) {
+              errorLineNumber = startLine;
+            }
+            break;
+          } else if (!allowPreamble) {
+            // First non-content needs to be a heading with the expected level
+            errorLineNumber = startLine;
+            break;
           }
-          return false;
-        });
+        }
+      }
+      if (errorLineNumber > 0) {
+        addErrorContext(onError, errorLineNumber, params.lines[errorLineNumber - 1]);
+      }
     }
   }
 };

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);
@@ -38,6 +38,8 @@ export default {
           }
         } else if (expected === "+") {
           matchAny = true;
+        } else if (expected === "?") {
+          // Allow current, match next
         } else if (handleCase(expected) === handleCase(actual)) {
           matchAny = false;
         } else if (matchAny) {

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/md045.mjs

@@ -5,6 +5,7 @@ import { getHtmlTagInfo, getDescendantsByType } from "../helpers/micromark-helpe
 import { filterByTypesCached } from "./cache.mjs";
 
 const altRe = getHtmlAttributeRe("alt");
+const ariaHiddenRe = getHtmlAttributeRe("aria-hidden");
 
 /** @type {import("markdownlint").Rule} */
 export default {
@@ -40,7 +41,8 @@ export default {
         htmlTagInfo &&
         !htmlTagInfo.close &&
         (htmlTagInfo.name.toLowerCase() === "img") &&
-        !altRe.test(text)
+        !altRe.test(text) &&
+        (ariaHiddenRe.exec(text)?.[1].toLowerCase() !== "true")
       ) {
         const range = [
           startColumn,

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/md051.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 
 import { addError, getHtmlAttributeRe } from "../helpers/helpers.cjs";
-import { filterByPredicate, filterByTypes, getHtmlTagInfo } from "../helpers/micromark-helpers.cjs";
+import { filterByPredicate, filterByTypes, getHtmlTagInfo, isDocfxTab } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
 // Regular expression for identifying HTML anchor names
@@ -66,7 +66,10 @@ export default {
   "parser": "micromark",
   "function": function MD051(params, onError) {
     const ignoreCase = params.config.ignore_case || false;
-    const fragments = new Map();
+    const ignoredPattern = params.config.ignored_pattern || "";
+    const ignoredPatternRe = new RegExp(ignoredPattern || "^$");
+    /** @type {Map<string, number>} */
+    const fragments = new Map([ [ "#top", 0 ] ]);
 
     // Process headings
     const headingTexts = filterByTypesCached([ "atxHeadingText", "setextHeadingText" ]);
@@ -107,18 +110,23 @@ export default {
       [ "definition", "definitionDestinationString" ]
     ];
     for (const [ parentType, definitionType ] of parentChilds) {
-      const links = filterByTypesCached([ parentType ]);
+      const links = filterByTypesCached([ parentType ])
+        .filter(
+          (link) => !((link.parent?.type === "atxHeadingText") && isDocfxTab(link.parent.parent))
+        );
       for (const link of links) {
         const definitions = filterByTypes(link.children, [ definitionType ]);
         for (const definition of definitions) {
           const { endColumn, startColumn } = definition;
           const text = unescapeStringTokenText(definition);
-          const encodedText = `#${encodeURIComponent(text.slice(1))}`;
+          const textSliceOne = text.slice(1);
+          const encodedText = `#${encodeURIComponent(textSliceOne)}`;
           if (
             (text.length > 1) &&
             text.startsWith("#") &&
             !fragments.has(encodedText) &&
-            !lineFragmentRe.test(encodedText)
+            !lineFragmentRe.test(encodedText) &&
+            !ignoredPatternRe.test(textSliceOne)
           ) {
             let context = undefined;
             let range = undefined;

package/lib/md052.mjs

@@ -13,6 +13,7 @@ export default {
   "function": function MD052(params, onError) {
     const { config, lines } = params;
     const shortcutSyntax = config.shortcut_syntax || false;
+    const ignoredLabels = new Set(config.ignored_labels || [ "x" ]);
     const { definitions, references, shortcuts } = getReferenceLinkImageData();
     const entries = shortcutSyntax ?
       [ ...references.entries(), ...shortcuts.entries() ] :
@@ -20,7 +21,7 @@ export default {
     // Look for links/images that use an undefined link reference
     for (const reference of entries) {
       const [ label, datas ] = reference;
-      if (!definitions.has(label)) {
+      if (!definitions.has(label) && !ignoredLabels.has(label)) {
         for (const data of datas) {
           const [ lineIndex, index, length ] = data;
           // Context will be incomplete if reporting for a multi-line link

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) {

package/lib/md055.mjs

@@ -3,15 +3,16 @@
 import { addErrorDetailIf } from "../helpers/helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {import("micromark-extension-gfm-table")} */
+
 const whitespaceTypes = new Set([ "linePrefix", "whitespace" ]);
-const ignoreWhitespace = (tokens) => tokens.filter(
+const ignoreWhitespace = (/** @type {MicromarkToken[]} */ tokens) => tokens.filter(
   (token) => !whitespaceTypes.has(token.type)
 );
-const firstOrNothing = (items) => items[0];
-const lastOrNothing = (items) => items[items.length - 1];
-const makeRange = (start, end) => [ start, end - start + 1 ];
-
-/** @typedef {import("micromark-extension-gfm-table")} */
+const firstOrNothing = (/** @type {MicromarkToken[]} */ items) => items[0];
+const lastOrNothing = (/** @type {MicromarkToken[]} */ items) => items[items.length - 1];
+const makeRange = (/** @type {number} */ start, /** @type {number} */ end) => [ start, end - start + 1 ];
 
 /** @type {import("markdownlint").Rule} */
 export default {

package/lib/md056.mjs

@@ -4,7 +4,7 @@ import { addErrorDetailIf } from "../helpers/helpers.cjs";
 import { getParentOfType } from "../helpers/micromark-helpers.cjs";
 import { filterByTypesCached } from "./cache.mjs";
 
-const makeRange = (start, end) => [ start, end - start + 1 ];
+const makeRange = (/** @type {number} */ start, /** @type {number} */ end) => [ start, end - start + 1 ];
 
 /** @typedef {import("micromark-extension-gfm-table")} */
 

package/lib/md059.mjs

@@ -0,0 +1,71 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+/** @type {Set<MicromarkTokenType>} */
+const allowedChildrenTypes = new Set([
+  "codeText",
+  "htmlText"
+]);
+const defaultProhibitedTexts = [
+  "click here",
+  "here",
+  "link",
+  "more"
+];
+
+/**
+ * Normalizes a string by removing extra whitespaces and punctuation.
+ *
+ * @param {string} str String to normalize.
+ * @returns {string} Normalized string.
+ */
+function normalize(str) {
+  return str
+    .replace(/[\W_]+/g, " ")
+    .replace(/\s+/g, " ")
+    .toLowerCase()
+    .trim();
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD059", "descriptive-link-text" ],
+  "description": "Link text should be descriptive",
+  "tags": [ "accessibility", "links" ],
+  "parser": "micromark",
+  "function": function MD059(params, onError) {
+    const prohibitedTexts = new Set(
+      (params.config.prohibited_texts || defaultProhibitedTexts).map(normalize)
+    );
+    if (prohibitedTexts.size > 0) {
+      const links = filterByTypesCached([ "link" ]);
+      for (const link of links) {
+        const labelTexts = getDescendantsByType(link, [ "label", "labelText" ]);
+        for (const labelText of labelTexts) {
+          const { children, endColumn, endLine, parent, startColumn, startLine, text } = labelText;
+          if (
+            !children.some((child) => allowedChildrenTypes.has(child.type)) &&
+            prohibitedTexts.has(normalize(text))
+          ) {
+            const range = (startLine === endLine) ?
+              [ startColumn, endColumn - startColumn ] :
+              undefined;
+            addErrorContext(
+              onError,
+              startLine,
+              // @ts-ignore
+              parent.text,
+              undefined,
+              undefined,
+              range
+            );
+          }
+        }
+      }
+    }
+  }
+};

package/lib/md060.mjs

@@ -0,0 +1,121 @@
+// @ts-check
+
+import { filterByTypes } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("micromark-extension-gfm-table")} */
+/** @typedef {import("markdownlint").RuleOnErrorInfo} RuleOnErrorInfo */
+
+/**
+ * Adds a RuleOnErrorInfo object to a list of RuleOnErrorInfo objects.
+ *
+ * @param {RuleOnErrorInfo[]} errors List of errors.
+ * @param {number} lineNumber Line number.
+ * @param {number} column Column number.
+ * @param {string} detail Detail message.
+ */
+function addError(errors, lineNumber, column, detail) {
+  errors.push({
+    lineNumber,
+    detail,
+    "range": [ column, 1 ]
+  });
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD060", "table-column-style" ],
+  "description": "Table column style",
+  "tags": [ "table" ],
+  "parser": "micromark",
+  "function": function MD060(params, onError) {
+    const style = String(params.config.style || "any");
+    const styleAlignedAllowed = (style === "any") || (style === "aligned");
+    const styleCompactAllowed = (style === "any") || (style === "compact");
+    const styleTightAllowed = (style === "any") || (style === "tight");
+
+    // Scan all tables/rows
+    const tables = filterByTypesCached([ "table" ]);
+    for (const table of tables) {
+      const rows = filterByTypes(table.children, [ "tableDelimiterRow", "tableRow" ]);
+      const headingRow = rows[0];
+
+      // Determine errors for style "aligned"
+      /** @type {RuleOnErrorInfo[]} */
+      const errorsIfAligned = [];
+      if (styleAlignedAllowed) {
+        const headingDividerColumns = filterByTypes(headingRow.children, [ "tableCellDivider" ]).map((divider) => divider.startColumn);
+        for (const row of rows.slice(1)) {
+          const remainingHeadingDividerColumns = new Set(headingDividerColumns);
+          const rowDividerColumns = filterByTypes(row.children, [ "tableCellDivider" ]).map((divider) => divider.startColumn);
+          for (const dividerColumn of rowDividerColumns) {
+            if ((remainingHeadingDividerColumns.size > 0) && !remainingHeadingDividerColumns.delete(dividerColumn)) {
+              addError(errorsIfAligned, row.startLine, dividerColumn, "Table pipe does not align with heading for style \"aligned\"");
+            }
+          }
+        }
+      }
+
+      // Determine errors for styles "compact" and "tight"
+      /** @type {RuleOnErrorInfo[]} */
+      const errorsIfCompact = [];
+      /** @type {RuleOnErrorInfo[]} */
+      const errorsIfTight = [];
+      if (
+        (styleCompactAllowed || styleTightAllowed) &&
+        !(styleAlignedAllowed && (errorsIfAligned.length === 0))
+      ) {
+        for (const row of rows) {
+          const tokensOfInterest = filterByTypes(row.children, [ "tableCellDivider", "tableContent", "whitespace" ]);
+          for (let i = 0; i < tokensOfInterest.length; i++) {
+            const { startColumn, startLine, type } = tokensOfInterest[i];
+            if (type === "tableCellDivider") {
+              const previous = tokensOfInterest[i - 1];
+              if (previous) {
+                if (previous.type === "whitespace") {
+                  if (previous.text.length !== 1) {
+                    addError(errorsIfCompact, startLine, startColumn, "Table pipe has extra space to the left for style \"compact\"");
+                  }
+                  addError(errorsIfTight, startLine, startColumn, "Table pipe has space to the left for style \"tight\"");
+                } else {
+                  addError(errorsIfCompact, startLine, startColumn, "Table pipe is missing space to the left for style \"compact\"");
+                }
+              }
+              const next = tokensOfInterest[i + 1];
+              if (next) {
+                if (next.type === "whitespace") {
+                  if (next.endColumn !== row.endColumn) {
+                    if (next.text.length !== 1) {
+                      addError(errorsIfCompact, startLine, startColumn, "Table pipe has extra space to the right for style \"compact\"");
+                    }
+                    addError(errorsIfTight, startLine, startColumn, "Table pipe has space to the right for style \"tight\"");
+                  }
+                } else {
+                  addError(errorsIfCompact, startLine, startColumn, "Table pipe is missing space to the right for style \"compact\"");
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // Report errors for whatever (allowed) style has the fewest
+      let errorInfos = errorsIfAligned;
+      if (
+        styleCompactAllowed &&
+        ((errorsIfCompact.length < errorInfos.length) || !styleAlignedAllowed)
+      ) {
+        errorInfos = errorsIfCompact;
+      }
+      if (
+        styleTightAllowed &&
+        ((errorsIfTight.length < errorInfos.length) || (!styleAlignedAllowed && !styleCompactAllowed))
+      ) {
+        errorInfos = errorsIfTight;
+      }
+      for (const errorInfo of errorInfos) {
+        onError(errorInfo);
+      }
+    }
+  }
+};

package/lib/micromark-parse.mjs

@@ -20,6 +20,17 @@ import { flatTokensSymbol, htmlFlowSymbol, newLineRe } from "../helpers/shared.c
 /** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
 /** @typedef {import("./micromark-types.d.mts")} */
 
+/**
+ * Gets the Markdown text for a Micromark token.
+ *
+ * @param {string} markdown Markdown content.
+ * @param {Token} token Micromark token.
+ * @returns {string} Token text.
+ */
+function getText(markdown, token) {
+  return markdown.slice(token.start.offset, token.end.offset);
+}
+
 /**
  * Parse options.
  *
@@ -126,7 +137,7 @@ export function getEvents(
         // Create artificial event list and replicate content
         const text = eventsToReplicate
           .filter((event) => event[0] === "enter")
-          .map((event) => tokenizeContext.sliceSerialize(event[1]))
+          .map((event) => getText(markdown, event[1]))
           .join("")
           .trim();
         if ((text.length > 0) && !text.includes("]")) {
@@ -201,7 +212,9 @@ function parseInternal(
   const events = getEvents(markdown, micromarkParseOptions);
 
   // Create Token objects
+  /** @type {MicromarkToken[]} */
   const document = [];
+  /** @type {MicromarkToken[]} */
   let flatTokens = [];
   /** @type {MicromarkToken} */
   const root = {
@@ -221,11 +234,11 @@ function parseInternal(
   let lines = null;
   let skipHtmlFlowChildren = false;
   for (const event of events) {
-    const [ kind, token, context ] = event;
+    const [ kind, token ] = event;
     const { type, start, end } = token;
     const { "column": startColumn, "line": startLine } = start;
     const { "column": endColumn, "line": endLine } = end;
-    const text = context.sliceSerialize(token);
+    const text = getText(markdown, token);
     if ((kind === "enter") && !skipHtmlFlowChildren) {
       const previous = current;
       history.push(previous);
@@ -271,6 +284,7 @@ function parseInternal(
         );
         current.children = tokens;
         // Avoid stack overflow of Array.push(...spread)
+        // @ts-ignore
         // eslint-disable-next-line unicorn/prefer-spread
         flatTokens = flatTokens.concat(tokens[flatTokensSymbol]);
       }

package/lib/node-imports-browser.mjs

@@ -6,8 +6,10 @@ const throwForSync = () => {
 };
 
 export const fs = {
+  // @ts-ignore
   "access": (path, callback) => callback(getError()),
   "accessSync": throwForSync,
+  // @ts-ignore
   "readFile": (path, options, callback) => callback(getError()),
   "readFileSync": throwForSync
 };

package/lib/parse-configuration.mjs

@@ -0,0 +1,47 @@
+// @ts-check
+
+/**
+ * Result of a call to parseConfiguration.
+ *
+ * @typedef {Object} ParseConfigurationResult
+ * @property {import("markdownlint").Configuration | null} config Configuration object if successful.
+ * @property {string | null} message Error message if an error occurred.
+ */
+
+/**
+ * Parse the content of a configuration file.
+ *
+ * @param {string} name Name of the configuration file.
+ * @param {string} content Configuration content.
+ * @param {import("markdownlint").ConfigurationParser[]} [parsers] Parsing function(s).
+ * @returns {ParseConfigurationResult} Parse configuration result.
+ */
+export default function parseConfiguration(name, content, parsers) {
+  let config = null;
+  let message = null;
+  const errors = [];
+  let index = 0;
+  // Try each parser
+  const failed = (parsers || [ JSON.parse ]).every((parser) => {
+    try {
+      const result = parser(content);
+      config = (result && (typeof result === "object") && !Array.isArray(result)) ? result : {};
+      // Succeeded
+      return false;
+      // eslint-disable-next-line jsdoc/reject-any-type
+    } catch(/** @type {any} */ error) {
+      errors.push(`Parser ${index++}: ${error?.message}`);
+    }
+    // Failed, try the next parser
+    return true;
+  });
+  // Message if unable to parse
+  if (failed) {
+    errors.unshift(`Unable to parse '${name}'`);
+    message = errors.join("; ");
+  }
+  return {
+    config,
+    message
+  };
+}

package/lib/rules.mjs

@@ -53,6 +53,8 @@ import md054 from "./md054.mjs";
 import md055 from "./md055.mjs";
 import md056 from "./md056.mjs";
 import md058 from "./md058.mjs";
+import md059 from "./md059.mjs";
+import md060 from "./md060.mjs";
 
 const rules = [
   md001,
@@ -108,7 +110,9 @@ const rules = [
   md055,
   md056,
   // md057: See https://github.com/markdownlint/markdownlint
-  md058
+  md058,
+  md059,
+  md060
 ];
 for (const rule of rules) {
   const name = rule.names[0].toLowerCase();