@alexlit/lint-kit 127.1.0 → 127.3.0

package/packages/config-markdownlint/node_modules/markdownlint/lib/markdownlint.js

@@ -0,0 +1,1572 @@
+// @ts-check
+
+"use strict";
+
+const path = require("node:path");
+const { promisify } = require("node:util");
+const micromark = require("../helpers/micromark.cjs");
+// const { deprecatedRuleNames } = require("./constants");
+const rules = require("./rules");
+const helpers = require("../helpers");
+const cache = require("./cache");
+
+// @ts-ignore
+// eslint-disable-next-line camelcase, no-inline-comments, no-undef
+const dynamicRequire = (typeof __non_webpack_require__ === "undefined") ? require : /* c8 ignore next */ __non_webpack_require__;
+// Capture native require implementation for dynamic loading of modules
+
+/**
+ * Validate the list of rules for structure and reuse.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @param {boolean} synchronous Whether to execute synchronously.
+ * @returns {Error | null} Error message if validation fails.
+ */
+function validateRuleList(ruleList, synchronous) {
+  let result = null;
+  if (ruleList.length === rules.length) {
+    // No need to validate if only using built-in rules
+    return result;
+  }
+  const allIds = {};
+  for (const [ index, rule ] of ruleList.entries()) {
+    const customIndex = index - rules.length;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function newError(property, value) {
+      return new Error(
+        `Property '${property}' of custom rule at index ${customIndex} is incorrect: '${value}'.`);
+    }
+    for (const property of [ "names", "tags" ]) {
+      const value = rule[property];
+      if (!result &&
+        (!value || !Array.isArray(value) || (value.length === 0) ||
+         !value.every(helpers.isString) || value.some(helpers.isEmptyString))) {
+        result = newError(property, value);
+      }
+    }
+    for (const propertyInfo of [
+      [ "description", "string" ],
+      [ "function", "function" ]
+    ]) {
+      const property = propertyInfo[0];
+      const value = rule[property];
+      if (!result && (!value || (typeof value !== propertyInfo[1]))) {
+        result = newError(property, value);
+      }
+    }
+    if (
+      !result &&
+      (rule.parser !== undefined) &&
+      (rule.parser !== "markdownit") &&
+      !((customIndex < 0) && (rule.parser === "micromark")) &&
+      (rule.parser !== "none")
+    ) {
+      result = newError("parser", rule.parser);
+    }
+    if (
+      !result &&
+      rule.information &&
+      !helpers.isUrl(rule.information)
+    ) {
+      result = newError("information", rule.information);
+    }
+    if (
+      !result &&
+      (rule.asynchronous !== undefined) &&
+      (typeof rule.asynchronous !== "boolean")
+    ) {
+      result = newError("asynchronous", rule.asynchronous);
+    }
+    if (!result && rule.asynchronous && synchronous) {
+      result = new Error(
+        "Custom rule " + rule.names.join("/") + " at index " + customIndex +
+        " is asynchronous and can not be used in a synchronous context."
+      );
+    }
+    if (!result) {
+      for (const name of rule.names) {
+        const nameUpper = name.toUpperCase();
+        if (!result && (allIds[nameUpper] !== undefined)) {
+          result = new Error("Name '" + name + "' of custom rule at index " +
+            customIndex + " is already used as a name or tag.");
+        }
+        allIds[nameUpper] = true;
+      }
+      for (const tag of rule.tags) {
+        const tagUpper = tag.toUpperCase();
+        if (!result && allIds[tagUpper]) {
+          result = new Error("Tag '" + tag + "' of custom rule at index " +
+            customIndex + " is already used as a name.");
+        }
+        allIds[tagUpper] = false;
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Creates a LintResults instance with toString for pretty display.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @returns {LintResults} New LintResults instance.
+ */
+function newResults(ruleList) {
+  const lintResults = {};
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function toString(useAlias) {
+    let ruleNameToRule = null;
+    const results = [];
+    const keys = Object.keys(lintResults);
+    keys.sort();
+    for (const file of keys) {
+      const fileResults = lintResults[file];
+      if (Array.isArray(fileResults)) {
+        for (const result of fileResults) {
+          const ruleMoniker = result.ruleNames ?
+            result.ruleNames.join("/") :
+            (result.ruleName + "/" + result.ruleAlias);
+          results.push(
+            file + ": " +
+            result.lineNumber + ": " +
+            ruleMoniker + " " +
+            result.ruleDescription +
+            (result.errorDetail ?
+              " [" + result.errorDetail + "]" :
+              "") +
+            (result.errorContext ?
+              " [Context: \"" + result.errorContext + "\"]" :
+              ""));
+        }
+      } else {
+        if (!ruleNameToRule) {
+          ruleNameToRule = {};
+          for (const rule of ruleList) {
+            const ruleName = rule.names[0].toUpperCase();
+            ruleNameToRule[ruleName] = rule;
+          }
+        }
+        for (const [ ruleName, ruleResults ] of Object.entries(fileResults)) {
+          const rule = ruleNameToRule[ruleName.toUpperCase()];
+          for (const lineNumber of ruleResults) {
+            // @ts-ignore
+            const nameIndex = Math.min(useAlias ? 1 : 0, rule.names.length - 1);
+            const result =
+              file + ": " +
+              lineNumber + ": " +
+              // @ts-ignore
+              rule.names[nameIndex] + " " +
+              // @ts-ignore
+              rule.description;
+            results.push(result);
+          }
+        }
+      }
+    }
+    return results.join("\n");
+  }
+  Object.defineProperty(lintResults, "toString", { "value": toString });
+  // @ts-ignore
+  return lintResults;
+}
+
+/**
+ * Remove front matter (if present at beginning of content).
+ *
+ * @param {string} content Markdown content.
+ * @param {RegExp | null} frontMatter Regular expression to match front matter.
+ * @returns {Object} Trimmed content and front matter lines.
+ */
+function removeFrontMatter(content, frontMatter) {
+  let frontMatterLines = [];
+  if (frontMatter) {
+    const frontMatterMatch = content.match(frontMatter);
+    if (frontMatterMatch && !frontMatterMatch.index) {
+      const contentMatched = frontMatterMatch[0];
+      content = content.slice(contentMatched.length);
+      frontMatterLines = contentMatched.split(helpers.newLineRe);
+      if ((frontMatterLines.length > 0) &&
+          (frontMatterLines[frontMatterLines.length - 1] === "")) {
+        frontMatterLines.length--;
+      }
+    }
+  }
+  return {
+    "content": content,
+    "frontMatterLines": frontMatterLines
+  };
+}
+
+/**
+ * Freeze all freeze-able members of a token and its children.
+ *
+ * @param {MarkdownItToken} token A markdown-it token.
+ * @returns {void}
+ */
+function freezeToken(token) {
+  if (token.attrs) {
+    for (const attr of token.attrs) {
+      Object.freeze(attr);
+    }
+    Object.freeze(token.attrs);
+  }
+  if (token.children) {
+    for (const child of token.children) {
+      freezeToken(child);
+    }
+    Object.freeze(token.children);
+  }
+  if (token.map) {
+    Object.freeze(token.map);
+  }
+  Object.freeze(token);
+}
+
+/**
+ * Annotate tokens with line/lineNumber and freeze them.
+ *
+ * @param {import("markdown-it").Token[]} tokens Array of markdown-it tokens.
+ * @param {string[]} lines Lines of Markdown content.
+ * @returns {void}
+ */
+function annotateAndFreezeTokens(tokens, lines) {
+  let trMap = null;
+  // eslint-disable-next-line jsdoc/valid-types
+  /** @type MarkdownItToken[] */
+  // @ts-ignore
+  const markdownItTokens = tokens;
+  for (const token of markdownItTokens) {
+    // Provide missing maps for table content
+    if (token.type === "tr_open") {
+      trMap = token.map;
+    } else if (token.type === "tr_close") {
+      trMap = null;
+    }
+    if (!token.map && trMap) {
+      token.map = [ ...trMap ];
+    }
+    // Update token metadata
+    if (token.map) {
+      token.line = lines[token.map[0]];
+      token.lineNumber = token.map[0] + 1;
+      // Trim bottom of token to exclude whitespace lines
+      while (token.map[1] && !((lines[token.map[1] - 1] || "").trim())) {
+        token.map[1]--;
+      }
+    }
+    // Annotate children with lineNumber
+    if (token.children) {
+      const codeSpanExtraLines = [];
+      if (token.children.some((child) => child.type === "code_inline")) {
+        helpers.forEachInlineCodeSpan(token.content, (code) => {
+          codeSpanExtraLines.push(code.split(helpers.newLineRe).length - 1);
+        });
+      }
+      let lineNumber = token.lineNumber;
+      for (const child of token.children) {
+        child.lineNumber = lineNumber;
+        child.line = lines[lineNumber - 1];
+        if ((child.type === "softbreak") || (child.type === "hardbreak")) {
+          lineNumber++;
+        } else if (child.type === "code_inline") {
+          lineNumber += codeSpanExtraLines.shift();
+        }
+      }
+    }
+    freezeToken(token);
+  }
+  Object.freeze(tokens);
+}
+
+/**
+ * Map rule names/tags to canonical rule name.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @returns {Object.<string, string[]>} Map of alias to rule name.
+ */
+function mapAliasToRuleNames(ruleList) {
+  const aliasToRuleNames = {};
+  // const tagToRuleNames = {};
+  for (const rule of ruleList) {
+    const ruleName = rule.names[0].toUpperCase();
+    // The following is useful for updating README.md:
+    // console.log(
+    //   "* **[" + ruleName + "](doc/Rules.md#" + ruleName.toLowerCase() +
+    //    ")** *" + rule.names.slice(1).join("/") + "* - " + rule.description);
+    for (const name of rule.names) {
+      const nameUpper = name.toUpperCase();
+      aliasToRuleNames[nameUpper] = [ ruleName ];
+    }
+    for (const tag of rule.tags) {
+      const tagUpper = tag.toUpperCase();
+      const ruleNames = aliasToRuleNames[tagUpper] || [];
+      ruleNames.push(ruleName);
+      aliasToRuleNames[tagUpper] = ruleNames;
+      // tagToRuleNames[tag] = ruleName;
+    }
+  }
+  // The following is useful for updating README.md:
+  // Object.keys(tagToRuleNames).sort().forEach(function forTag(tag) {
+  //   console.log("* **" + tag + "** - " +
+  //     aliasToRuleNames[tag.toUpperCase()].join(", "));
+  // });
+  // @ts-ignore
+  return aliasToRuleNames;
+}
+
+/**
+ * Apply (and normalize) configuration object.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @param {Configuration} config Configuration object.
+ * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
+ * names.
+ * @returns {Configuration} Effective configuration.
+ */
+function getEffectiveConfig(ruleList, config, aliasToRuleNames) {
+  const defaultKey = Object.keys(config).filter(
+    (key) => key.toUpperCase() === "DEFAULT"
+  );
+  const ruleDefault = (defaultKey.length === 0) || !!config[defaultKey[0]];
+  /** @type {Configuration} */
+  const effectiveConfig = {};
+  for (const rule of ruleList) {
+    const ruleName = rule.names[0].toUpperCase();
+    effectiveConfig[ruleName] = ruleDefault;
+  }
+  // for (const ruleName of deprecatedRuleNames) {
+  //   effectiveConfig[ruleName] = false;
+  // }
+  for (const key of Object.keys(config)) {
+    let value = config[key];
+    if (value) {
+      if (!(value instanceof Object)) {
+        value = {};
+      }
+    } else {
+      value = false;
+    }
+    const keyUpper = key.toUpperCase();
+    for (const ruleName of (aliasToRuleNames[keyUpper] || [])) {
+      effectiveConfig[ruleName] = value;
+    }
+  }
+  return effectiveConfig;
+}
+
+/**
+ * Parse the content of a configuration file.
+ *
+ * @param {string} name Name of the configuration file.
+ * @param {string} content Configuration content.
+ * @param {ConfigurationParser[] | null} [parsers] Parsing function(s).
+ * @returns {Object} Configuration object and error message.
+ */
+function parseConfiguration(name, content, parsers) {
+  let config = null;
+  let message = "";
+  const errors = [];
+  let index = 0;
+  // Try each parser
+  (parsers || [ JSON.parse ]).every((parser) => {
+    try {
+      config = parser(content);
+    } catch (error) {
+      errors.push(`Parser ${index++}: ${error.message}`);
+    }
+    return !config;
+  });
+  // Message if unable to parse
+  if (!config) {
+    errors.unshift(`Unable to parse '${name}'`);
+    message = errors.join("; ");
+  }
+  return {
+    config,
+    message
+  };
+}
+
+/**
+ * Create a mapping of enabled rules per line.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @param {string[]} lines List of content lines.
+ * @param {string[]} frontMatterLines List of front matter lines.
+ * @param {boolean} noInlineConfig Whether to allow inline configuration.
+ * @param {Configuration} config Configuration object.
+ * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
+ * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
+ * names.
+ * @returns {Object} Effective configuration and enabled rules per line number.
+ */
+function getEnabledRulesPerLineNumber(
+  ruleList,
+  lines,
+  frontMatterLines,
+  noInlineConfig,
+  config,
+  configParsers,
+  aliasToRuleNames) {
+  // Shared variables
+  let enabledRules = {};
+  let capturedRules = {};
+  const allRuleNames = [];
+  const enabledRulesPerLineNumber = new Array(1 + frontMatterLines.length);
+  // Helper functions
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function handleInlineConfig(input, forEachMatch, forEachLine) {
+    for (const [ lineIndex, line ] of input.entries()) {
+      if (!noInlineConfig) {
+        let match = null;
+        while ((match = helpers.inlineCommentStartRe.exec(line))) {
+          const action = match[2].toUpperCase();
+          const startIndex = match.index + match[1].length;
+          const endIndex = line.indexOf("-->", startIndex);
+          if (endIndex === -1) {
+            break;
+          }
+          const parameter = line.slice(startIndex, endIndex);
+          forEachMatch(action, parameter, lineIndex + 1);
+        }
+      }
+      if (forEachLine) {
+        forEachLine();
+      }
+    }
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function configureFile(action, parameter) {
+    if (action === "CONFIGURE-FILE") {
+      const { "config": parsed } = parseConfiguration(
+        "CONFIGURE-FILE", parameter, configParsers
+      );
+      if (parsed) {
+        config = {
+          ...config,
+          ...parsed
+        };
+      }
+    }
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function applyEnableDisable(action, parameter, state) {
+    state = { ...state };
+    const enabled = (action.startsWith("ENABLE"));
+    const trimmed = parameter && parameter.trim();
+    const items = trimmed ? trimmed.toUpperCase().split(/\s+/) : allRuleNames;
+    for (const nameUpper of items) {
+      for (const ruleName of (aliasToRuleNames[nameUpper] || [])) {
+        state[ruleName] = enabled;
+      }
+    }
+    return state;
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function enableDisableFile(action, parameter) {
+    if ((action === "ENABLE-FILE") || (action === "DISABLE-FILE")) {
+      enabledRules = applyEnableDisable(action, parameter, enabledRules);
+    }
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function captureRestoreEnableDisable(action, parameter) {
+    if (action === "CAPTURE") {
+      capturedRules = enabledRules;
+    } else if (action === "RESTORE") {
+      enabledRules = capturedRules;
+    } else if ((action === "ENABLE") || (action === "DISABLE")) {
+      enabledRules = applyEnableDisable(action, parameter, enabledRules);
+    }
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function updateLineState() {
+    enabledRulesPerLineNumber.push(enabledRules);
+  }
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function disableLineNextLine(action, parameter, lineNumber) {
+    const disableLine = (action === "DISABLE-LINE");
+    const disableNextLine = (action === "DISABLE-NEXT-LINE");
+    if (disableLine || disableNextLine) {
+      const nextLineNumber =
+        frontMatterLines.length + lineNumber + (disableNextLine ? 1 : 0);
+      enabledRulesPerLineNumber[nextLineNumber] =
+        applyEnableDisable(
+          action,
+          parameter,
+          enabledRulesPerLineNumber[nextLineNumber]
+        );
+    }
+  }
+  // Handle inline comments
+  handleInlineConfig([ lines.join("\n") ], configureFile);
+  const effectiveConfig = getEffectiveConfig(
+    ruleList, config, aliasToRuleNames);
+  for (const rule of ruleList) {
+    const ruleName = rule.names[0].toUpperCase();
+    allRuleNames.push(ruleName);
+    enabledRules[ruleName] = !!effectiveConfig[ruleName];
+  }
+  capturedRules = enabledRules;
+  handleInlineConfig(lines, enableDisableFile);
+  handleInlineConfig(lines, captureRestoreEnableDisable, updateLineState);
+  handleInlineConfig(lines, disableLineNextLine);
+  // Create the list of rules that are used at least once
+  const enabledRuleList = [];
+  for (const [ index, ruleName ] of allRuleNames.entries()) {
+    if (enabledRulesPerLineNumber.some((enabledRulesForLine) => enabledRulesForLine[ruleName])) {
+      enabledRuleList.push(ruleList[index]);
+    }
+  }
+  // Return results
+  return {
+    effectiveConfig,
+    enabledRulesPerLineNumber,
+    enabledRuleList
+  };
+}
+
+/**
+ * Lints a string containing Markdown content.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
+ * names.
+ * @param {string} name Identifier for the content.
+ * @param {string} content Markdown content.
+ * @param {GetMarkdownIt} getMarkdownIt Getter for instance of markdown-it.
+ * @param {Configuration} config Configuration object.
+ * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
+ * @param {RegExp | null} frontMatter Regular expression for front matter.
+ * @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 {LintContentCallback} callback Callback (err, result) function.
+ * @returns {void}
+ */
+function lintContent(
+  ruleList,
+  aliasToRuleNames,
+  name,
+  content,
+  getMarkdownIt,
+  config,
+  configParsers,
+  frontMatter,
+  handleRuleFailures,
+  noInlineConfig,
+  resultVersion,
+  callback) {
+  // Remove UTF-8 byte order marker (if present)
+  content = content.replace(/^\uFEFF/, "");
+  // Remove front matter
+  const removeFrontMatterResult = removeFrontMatter(content, frontMatter);
+  const { frontMatterLines } = removeFrontMatterResult;
+  content = removeFrontMatterResult.content;
+  // Get enabled rules per line (with HTML comments present)
+  const { effectiveConfig, enabledRulesPerLineNumber, enabledRuleList } =
+    getEnabledRulesPerLineNumber(
+      ruleList,
+      content.split(helpers.newLineRe),
+      frontMatterLines,
+      noInlineConfig,
+      config,
+      configParsers,
+      aliasToRuleNames
+    );
+  const needMarkdownItTokens = enabledRuleList.some(
+    (rule) => (rule.parser === "markdownit") || (rule.parser === undefined)
+  );
+  // Parse content into parser tokens
+  const markdownitTokens = needMarkdownItTokens ? getMarkdownIt().parse(content, {}) : [];
+  const micromarkTokens = micromark.parse(content);
+  // Hide the content of HTML comments from rules
+  content = helpers.clearHtmlCommentText(content);
+  // Parse content into lines and update markdown-it tokens
+  const lines = content.split(helpers.newLineRe);
+  annotateAndFreezeTokens(markdownitTokens, lines);
+  // Create (frozen) parameters for rules
+  /** @type {MarkdownParsers} */
+  // @ts-ignore
+  const parsersMarkdownIt = Object.freeze({
+    "markdownit": Object.freeze({
+      "tokens": markdownitTokens
+    })
+  });
+  /** @type {MarkdownParsers} */
+  // @ts-ignore
+  const parsersMicromark = Object.freeze({
+    "micromark": Object.freeze({
+      "tokens": micromarkTokens
+    })
+  });
+  /** @type {MarkdownParsers} */
+  // @ts-ignore
+  const parsersNone = Object.freeze({});
+  const paramsBase = {
+    name,
+    "lines": Object.freeze(lines),
+    "frontMatterLines": Object.freeze(frontMatterLines)
+  };
+  cache.initialize({
+    ...paramsBase,
+    "parsers": parsersMicromark,
+    "config": null
+  });
+  // Function to run for each rule
+  let results = [];
+  /**
+   * @param {Rule} rule Rule.
+   * @returns {Promise<void> | null} Promise.
+   */
+  const forRule = (rule) => {
+    // Configure rule
+    const ruleName = rule.names[0].toUpperCase();
+    const tokens = {};
+    let parsers = parsersNone;
+    if (rule.parser === undefined) {
+      tokens.tokens = markdownitTokens;
+      parsers = parsersMarkdownIt;
+    } else if (rule.parser === "markdownit") {
+      parsers = parsersMarkdownIt;
+    } else if (rule.parser === "micromark") {
+      parsers = parsersMicromark;
+    }
+    const params = {
+      ...paramsBase,
+      ...tokens,
+      parsers,
+      "config": effectiveConfig[ruleName]
+    };
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function throwError(property) {
+      throw new Error(
+        `Value of '${property}' passed to onError by '${ruleName}' is incorrect for '${name}'.`);
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function onError(errorInfo) {
+      if (!errorInfo ||
+        !helpers.isNumber(errorInfo.lineNumber) ||
+        (errorInfo.lineNumber < 1) ||
+        (errorInfo.lineNumber > lines.length)) {
+        throwError("lineNumber");
+      }
+      const lineNumber = errorInfo.lineNumber + frontMatterLines.length;
+      if (!enabledRulesPerLineNumber[lineNumber][ruleName]) {
+        return;
+      }
+      if (errorInfo.detail &&
+        !helpers.isString(errorInfo.detail)) {
+        throwError("detail");
+      }
+      if (errorInfo.context &&
+        !helpers.isString(errorInfo.context)) {
+        throwError("context");
+      }
+      if (errorInfo.information &&
+        !helpers.isUrl(errorInfo.information)) {
+        throwError("information");
+      }
+      if (errorInfo.range &&
+        (!Array.isArray(errorInfo.range) ||
+          (errorInfo.range.length !== 2) ||
+          !helpers.isNumber(errorInfo.range[0]) ||
+          (errorInfo.range[0] < 1) ||
+          !helpers.isNumber(errorInfo.range[1]) ||
+          (errorInfo.range[1] < 1) ||
+          ((errorInfo.range[0] + errorInfo.range[1] - 1) >
+          lines[errorInfo.lineNumber - 1].length))) {
+        throwError("range");
+      }
+      const fixInfo = errorInfo.fixInfo;
+      const cleanFixInfo = {};
+      if (fixInfo) {
+        if (!helpers.isObject(fixInfo)) {
+          throwError("fixInfo");
+        }
+        if (fixInfo.lineNumber !== undefined) {
+          if ((!helpers.isNumber(fixInfo.lineNumber) ||
+            (fixInfo.lineNumber < 1) ||
+            (fixInfo.lineNumber > lines.length))) {
+            throwError("fixInfo.lineNumber");
+          }
+          cleanFixInfo.lineNumber =
+            fixInfo.lineNumber + frontMatterLines.length;
+        }
+        const effectiveLineNumber = fixInfo.lineNumber || errorInfo.lineNumber;
+        if (fixInfo.editColumn !== undefined) {
+          if ((!helpers.isNumber(fixInfo.editColumn) ||
+            (fixInfo.editColumn < 1) ||
+            (fixInfo.editColumn >
+              lines[effectiveLineNumber - 1].length + 1))) {
+            throwError("fixInfo.editColumn");
+          }
+          cleanFixInfo.editColumn = fixInfo.editColumn;
+        }
+        if (fixInfo.deleteCount !== undefined) {
+          if ((!helpers.isNumber(fixInfo.deleteCount) ||
+            (fixInfo.deleteCount < -1) ||
+            (fixInfo.deleteCount >
+              lines[effectiveLineNumber - 1].length))) {
+            throwError("fixInfo.deleteCount");
+          }
+          cleanFixInfo.deleteCount = fixInfo.deleteCount;
+        }
+        if (fixInfo.insertText !== undefined) {
+          if (!helpers.isString(fixInfo.insertText)) {
+            throwError("fixInfo.insertText");
+          }
+          cleanFixInfo.insertText = fixInfo.insertText;
+        }
+      }
+      const information = errorInfo.information || rule.information;
+      results.push({
+        lineNumber,
+        "ruleName": rule.names[0],
+        "ruleNames": rule.names,
+        "ruleDescription": rule.description,
+        "ruleInformation": information ? information.href : null,
+        "errorDetail": errorInfo.detail || null,
+        "errorContext": errorInfo.context || null,
+        "errorRange": errorInfo.range ? [ ...errorInfo.range ] : null,
+        "fixInfo": fixInfo ? cleanFixInfo : null
+      });
+    }
+    // Call (possibly external) rule function to report errors
+    const catchCallsOnError = (error) => onError({
+      "lineNumber": 1,
+      "detail": `This rule threw an exception: ${error.message || error}`
+    });
+    const invokeRuleFunction = () => rule.function(params, onError);
+    if (rule.asynchronous) {
+      // Asynchronous rule, ensure it returns a Promise
+      const ruleFunctionPromise =
+        Promise.resolve().then(invokeRuleFunction);
+      return handleRuleFailures ?
+        ruleFunctionPromise.catch(catchCallsOnError) :
+        ruleFunctionPromise;
+    }
+    // Synchronous rule
+    try {
+      invokeRuleFunction();
+    } catch (error) {
+      if (handleRuleFailures) {
+        catchCallsOnError(error);
+      } else {
+        throw error;
+      }
+    }
+    return null;
+  };
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function formatResults() {
+    // Sort results by rule name by line number
+    results.sort((a, b) => (
+      a.ruleName.localeCompare(b.ruleName) ||
+      a.lineNumber - b.lineNumber
+    ));
+    if (resultVersion < 3) {
+      // Remove fixInfo and multiple errors for the same rule and line number
+      const noPrevious = {
+        "ruleName": null,
+        "lineNumber": -1
+      };
+      results = results.filter((error, index, array) => {
+        delete error.fixInfo;
+        const previous = array[index - 1] || noPrevious;
+        return (
+          (error.ruleName !== previous.ruleName) ||
+          (error.lineNumber !== previous.lineNumber)
+        );
+      });
+    }
+    if (resultVersion === 0) {
+      // Return a dictionary of rule->[line numbers]
+      const dictionary = {};
+      for (const error of results) {
+        const ruleLines = dictionary[error.ruleName] || [];
+        ruleLines.push(error.lineNumber);
+        dictionary[error.ruleName] = ruleLines;
+      }
+      // @ts-ignore
+      results = dictionary;
+    } else if (resultVersion === 1) {
+      // Use ruleAlias instead of ruleNames
+      for (const error of results) {
+        error.ruleAlias = error.ruleNames[1] || error.ruleName;
+        delete error.ruleNames;
+      }
+    } else {
+      // resultVersion 2 or 3: Remove unwanted ruleName
+      for (const error of results) {
+        delete error.ruleName;
+      }
+    }
+    return results;
+  }
+  // Run all rules
+  const ruleListAsync = enabledRuleList.filter((rule) => rule.asynchronous);
+  const ruleListSync = enabledRuleList.filter((rule) => !rule.asynchronous);
+  const ruleListAsyncFirst = [
+    ...ruleListAsync,
+    ...ruleListSync
+  ];
+  const callbackSuccess = () => callback(null, formatResults());
+  const callbackError =
+    (error) => callback(error instanceof Error ? error : new Error(error));
+  try {
+    const ruleResults = ruleListAsyncFirst.map(forRule);
+    if (ruleListAsync.length > 0) {
+      Promise.all(ruleResults.slice(0, ruleListAsync.length))
+        .then(callbackSuccess)
+        .catch(callbackError);
+    } else {
+      callbackSuccess();
+    }
+  } catch (error) {
+    callbackError(error);
+  } finally {
+    cache.initialize();
+  }
+}
+
+/**
+ * Lints a file containing Markdown content.
+ *
+ * @param {Rule[]} ruleList List of rules.
+ * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
+ * names.
+ * @param {string} file Path of file to lint.
+ * @param {GetMarkdownIt} getMarkdownIt Getter for instance of markdown-it.
+ * @param {Configuration} config Configuration object.
+ * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
+ * @param {RegExp | null} frontMatter Regular expression for front matter.
+ * @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 {Object} fs File system implementation.
+ * @param {boolean} synchronous Whether to execute synchronously.
+ * @param {LintContentCallback} callback Callback (err, result) function.
+ * @returns {void}
+ */
+function lintFile(
+  ruleList,
+  aliasToRuleNames,
+  file,
+  getMarkdownIt,
+  config,
+  configParsers,
+  frontMatter,
+  handleRuleFailures,
+  noInlineConfig,
+  resultVersion,
+  fs,
+  synchronous,
+  callback) {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function lintContentWrapper(err, content) {
+    if (err) {
+      return callback(err);
+    }
+    return lintContent(
+      ruleList,
+      aliasToRuleNames,
+      file,
+      content,
+      getMarkdownIt,
+      config,
+      configParsers,
+      frontMatter,
+      handleRuleFailures,
+      noInlineConfig,
+      resultVersion,
+      callback
+    );
+  }
+  // Make a/synchronous call to read file
+  if (synchronous) {
+    lintContentWrapper(null, fs.readFileSync(file, "utf8"));
+  } else {
+    fs.readFile(file, "utf8", lintContentWrapper);
+  }
+}
+
+/**
+ * Lint files and strings specified in the Options object.
+ *
+ * @param {Options | null} options Options object.
+ * @param {boolean} synchronous Whether to execute synchronously.
+ * @param {LintCallback} callback Callback (err, result) function.
+ * @returns {void}
+ */
+function lintInput(options, synchronous, callback) {
+  // Normalize inputs
+  options = options || {};
+  callback = callback || function noop() {};
+  const customRuleList =
+    [ options.customRules || [] ]
+      .flat()
+      .map((rule) => ({
+        "names": helpers.cloneIfArray(rule.names),
+        "description": rule.description,
+        "information": helpers.cloneIfUrl(rule.information),
+        "tags": helpers.cloneIfArray(rule.tags),
+        "parser": rule.parser,
+        "asynchronous": rule.asynchronous,
+        "function": rule.function
+      }));
+  // eslint-disable-next-line unicorn/prefer-spread
+  const ruleList = rules.concat(customRuleList);
+  const ruleErr = validateRuleList(ruleList, synchronous);
+  if (ruleErr) {
+    callback(ruleErr);
+    return;
+  }
+  let files = [];
+  if (Array.isArray(options.files)) {
+    files = [ ...options.files ];
+  } else if (options.files) {
+    files = [ String(options.files) ];
+  }
+  const strings = options.strings || {};
+  const stringsKeys = Object.keys(strings);
+  const config = options.config || { "default": true };
+  const configParsers = options.configParsers || null;
+  const frontMatter = (options.frontMatter === undefined) ?
+    helpers.frontMatterRe : options.frontMatter;
+  const handleRuleFailures = !!options.handleRuleFailures;
+  const noInlineConfig = !!options.noInlineConfig;
+  const resultVersion = (options.resultVersion === undefined) ?
+    3 : options.resultVersion;
+  const getMarkdownIt = () => {
+    const markdownit = require("markdown-it");
+    const md = markdownit({ "html": true });
+    const markdownItPlugins = options.markdownItPlugins || [];
+    for (const plugin of markdownItPlugins) {
+      // @ts-ignore
+      md.use(...plugin);
+    }
+    return md;
+  };
+  const fs = options.fs || require("node:fs");
+  const aliasToRuleNames = mapAliasToRuleNames(ruleList);
+  const results = newResults(ruleList);
+  let done = false;
+  let concurrency = 0;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  function lintWorker() {
+    let currentItem = null;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function lintWorkerCallback(err, result) {
+      concurrency--;
+      if (err) {
+        done = true;
+        return callback(err);
+      }
+      results[currentItem] = result;
+      if (!synchronous) {
+        lintWorker();
+      }
+      return null;
+    }
+    if (done) {
+      // Abort for error or nothing left to do
+    } else if (files.length > 0) {
+      // Lint next file
+      concurrency++;
+      currentItem = files.shift();
+      lintFile(
+        ruleList,
+        aliasToRuleNames,
+        currentItem,
+        getMarkdownIt,
+        config,
+        configParsers,
+        frontMatter,
+        handleRuleFailures,
+        noInlineConfig,
+        resultVersion,
+        fs,
+        synchronous,
+        lintWorkerCallback
+      );
+    } else if ((currentItem = stringsKeys.shift())) {
+      // Lint next string
+      concurrency++;
+      lintContent(
+        ruleList,
+        aliasToRuleNames,
+        currentItem,
+        strings[currentItem] || "",
+        getMarkdownIt,
+        config,
+        configParsers,
+        frontMatter,
+        handleRuleFailures,
+        noInlineConfig,
+        resultVersion,
+        lintWorkerCallback
+      );
+    } else if (concurrency === 0) {
+      // Finish
+      done = true;
+      return callback(null, results);
+    }
+    return null;
+  }
+  if (synchronous) {
+    while (!done) {
+      lintWorker();
+    }
+  } else {
+    // Testing on a Raspberry Pi 4 Model B with an artificial 5ms file access
+    // delay suggests that a concurrency factor of 8 can eliminate the impact
+    // of that delay (i.e., total time is the same as with no delay).
+    lintWorker();
+    lintWorker();
+    lintWorker();
+    lintWorker();
+    lintWorker();
+    lintWorker();
+    lintWorker();
+    lintWorker();
+  }
+}
+
+/**
+ * Lint specified Markdown files.
+ *
+ * @param {Options | null} options Configuration options.
+ * @param {LintCallback} callback Callback (err, result) function.
+ * @returns {void}
+ */
+function markdownlint(options, callback) {
+  return lintInput(options, false, callback);
+}
+
+const markdownlintPromisify = promisify && promisify(markdownlint);
+
+/**
+ * Lint specified Markdown files.
+ *
+ * @param {Options} options Configuration options.
+ * @returns {Promise<LintResults>} Results object.
+ */
+function markdownlintPromise(options) {
+  // @ts-ignore
+  return markdownlintPromisify(options);
+}
+
+/**
+ * Lint specified Markdown files synchronously.
+ *
+ * @param {Options | null} options Configuration options.
+ * @returns {LintResults} Results object.
+ */
+function markdownlintSync(options) {
+  let results = null;
+  lintInput(options, true, function callback(error, res) {
+    if (error) {
+      throw error;
+    }
+    results = res;
+  });
+  // @ts-ignore
+  return results;
+}
+
+/**
+ * Resolve referenced "extends" path in a configuration file
+ * using path.resolve() with require.resolve() as a fallback.
+ *
+ * @param {string} configFile Configuration file name.
+ * @param {string} referenceId Referenced identifier to resolve.
+ * @param {Object} fs File system implementation.
+ * @param {ResolveConfigExtendsCallback} callback Callback (err, result)
+ * function.
+ * @returns {void}
+ */
+function resolveConfigExtends(configFile, referenceId, fs, callback) {
+  const configFileDirname = path.dirname(configFile);
+  const resolvedExtendsFile = path.resolve(configFileDirname, referenceId);
+  fs.access(resolvedExtendsFile, (err) => {
+    if (err) {
+      // Not a file, try require.resolve
+      try {
+        return callback(null, dynamicRequire.resolve(
+          referenceId,
+          { "paths": [ configFileDirname ] }
+        ));
+      } catch {
+        // Unable to resolve, use resolvedExtendsFile
+      }
+    }
+    return callback(null, resolvedExtendsFile);
+  });
+}
+
+/**
+ * Resolve referenced "extends" path in a configuration file
+ * using path.resolve() with require.resolve() as a fallback.
+ *
+ * @param {string} configFile Configuration file name.
+ * @param {string} referenceId Referenced identifier to resolve.
+ * @param {Object} fs File system implementation.
+ * @returns {string} Resolved path to file.
+ */
+function resolveConfigExtendsSync(configFile, referenceId, fs) {
+  const configFileDirname = path.dirname(configFile);
+  const resolvedExtendsFile = path.resolve(configFileDirname, referenceId);
+  try {
+    fs.accessSync(resolvedExtendsFile);
+    return resolvedExtendsFile;
+  } catch {
+    // Not a file, try require.resolve
+  }
+  try {
+    return dynamicRequire.resolve(
+      referenceId,
+      { "paths": [ configFileDirname ] }
+    );
+  } catch {
+    // Unable to resolve, return resolvedExtendsFile
+  }
+  return resolvedExtendsFile;
+}
+
+/**
+ * Extend specified configuration object.
+ *
+ * @param {Configuration} config Configuration object.
+ * @param {string} file Configuration file name.
+ * @param {ConfigurationParser[]} parsers Parsing
+ * function(s).
+ * @param {Object} fs File system implementation.
+ * @param {ReadConfigCallback} callback Callback (err, result) function.
+ * @returns {void}
+ */
+function extendConfig(config, file, parsers, fs, callback) {
+  const configExtends = config.extends;
+  if (configExtends) {
+    return resolveConfigExtends(
+      file,
+      helpers.expandTildePath(configExtends, require("node:os")),
+      fs,
+      // eslint-disable-next-line no-use-before-define
+      (_, resolvedExtends) => readConfig(
+        // @ts-ignore
+        resolvedExtends,
+        parsers,
+        fs,
+        (err, extendsConfig) => {
+          if (err) {
+            return callback(err);
+          }
+          const result = {
+            ...extendsConfig,
+            ...config
+          };
+          delete result.extends;
+          return callback(null, result);
+        }
+      )
+    );
+  }
+  return callback(null, config);
+}
+
+const extendConfigPromisify = promisify && promisify(extendConfig);
+
+/**
+ * Extend specified configuration object.
+ *
+ * @param {Configuration} config Configuration object.
+ * @param {string} file Configuration file name.
+ * @param {ConfigurationParser[]} [parsers] Parsing function(s).
+ * @param {Object} [fs] File system implementation.
+ * @returns {Promise<Configuration>} Configuration object.
+ */
+function extendConfigPromise(config, file, parsers, fs) {
+  // @ts-ignore
+  return extendConfigPromisify(config, file, parsers, fs);
+}
+
+/**
+ * Read specified configuration file.
+ *
+ * @param {string} file Configuration file name.
+ * @param {ConfigurationParser[] | ReadConfigCallback} parsers Parsing
+ * function(s).
+ * @param {Object} [fs] File system implementation.
+ * @param {ReadConfigCallback} [callback] Callback (err, result) function.
+ * @returns {void}
+ */
+function readConfig(file, parsers, fs, callback) {
+  if (!callback) {
+    if (fs) {
+      callback = fs;
+      fs = null;
+    } else {
+      // @ts-ignore
+      callback = parsers;
+      // @ts-ignore
+      parsers = null;
+    }
+  }
+  if (!fs) {
+    fs = require("node:fs");
+  }
+  // Read file
+  file = helpers.expandTildePath(file, require("node:os"));
+  fs.readFile(file, "utf8", (err, content) => {
+    if (err) {
+      // @ts-ignore
+      return callback(err);
+    }
+    // Try to parse file
+    // @ts-ignore
+    const { config, message } = parseConfiguration(file, content, parsers);
+    if (!config) {
+      // @ts-ignore
+      return callback(new Error(message));
+    }
+    // Extend configuration
+    // @ts-ignore
+    return extendConfig(config, file, parsers, fs, callback);
+  });
+}
+
+const readConfigPromisify = promisify && promisify(readConfig);
+
+/**
+ * Read specified configuration file.
+ *
+ * @param {string} file Configuration file name.
+ * @param {ConfigurationParser[]} [parsers] Parsing function(s).
+ * @param {Object} [fs] File system implementation.
+ * @returns {Promise<Configuration>} Configuration object.
+ */
+function readConfigPromise(file, parsers, fs) {
+  // @ts-ignore
+  return readConfigPromisify(file, parsers, fs);
+}
+
+/**
+ * Read specified configuration file synchronously.
+ *
+ * @param {string} file Configuration file name.
+ * @param {ConfigurationParser[]} [parsers] Parsing function(s).
+ * @param {Object} [fs] File system implementation.
+ * @returns {Configuration} Configuration object.
+ * @throws An Error if processing fails.
+ */
+function readConfigSync(file, parsers, fs) {
+  if (!fs) {
+    fs = require("node:fs");
+  }
+  // Read file
+  const os = require("node:os");
+  file = helpers.expandTildePath(file, os);
+  const content = fs.readFileSync(file, "utf8");
+  // Try to parse file
+  const { config, message } = parseConfiguration(file, content, parsers);
+  if (!config) {
+    throw new Error(message);
+  }
+  // Extend configuration
+  const configExtends = config.extends;
+  if (configExtends) {
+    delete config.extends;
+    const resolvedExtends = resolveConfigExtendsSync(
+      file,
+      helpers.expandTildePath(configExtends, os),
+      fs
+    );
+    return {
+      ...readConfigSync(resolvedExtends, parsers, fs),
+      ...config
+    };
+  }
+  return config;
+}
+
+/**
+ * Gets the (semantic) version of the library.
+ *
+ * @returns {string} SemVer string.
+ */
+function getVersion() {
+  return require("./constants").version;
+}
+
+// Export a/synchronous/Promise APIs
+markdownlint.sync = markdownlintSync;
+markdownlint.readConfig = readConfig;
+markdownlint.readConfigSync = readConfigSync;
+markdownlint.getVersion = getVersion;
+markdownlint.promises = {
+  "markdownlint": markdownlintPromise,
+  "extendConfig": extendConfigPromise,
+  "readConfig": readConfigPromise
+};
+module.exports = markdownlint;
+
+// Type declarations
+
+/**
+ * Function to get an instance of the markdown-it parser.
+ *
+ * @callback GetMarkdownIt
+ * @returns {import("markdown-it")}
+ */
+
+/**
+ * Function to implement rule logic.
+ *
+ * @callback RuleFunction
+ * @param {RuleParams} params Rule parameters.
+ * @param {RuleOnError} onError Error-reporting callback.
+ * @returns {void}
+ */
+
+/* eslint-disable jsdoc/valid-types */
+
+/**
+ * Rule parameters.
+ *
+ * @typedef {Object} RuleParams
+ * @property {string} name File/string name.
+ * @property {MarkdownParsers} parsers Markdown parser data.
+ * @property {readonly string[]} lines File/string lines.
+ * @property {readonly string[]} frontMatterLines Front matter lines.
+ * @property {RuleConfiguration} config Rule configuration.
+ */
+
+/* eslint-enable jsdoc/valid-types */
+
+/**
+ * Markdown parser data.
+ *
+ * @typedef {Object} MarkdownParsers
+ * @property {ParserMarkdownIt} markdownit Markdown parser data from markdown-it (only present when Rule.parser is "markdownit").
+ * @property {ParserMicromark} micromark Markdown parser data from micromark (only present when Rule.parser is "micromark").
+ */
+
+/**
+ * Markdown parser data from markdown-it.
+ *
+ * @typedef {Object} ParserMarkdownIt
+ * @property {MarkdownItToken[]} tokens Token objects from markdown-it.
+ */
+
+/**
+ * Markdown parser data from micromark.
+ *
+ * @typedef {Object} ParserMicromark
+ * @property {MicromarkToken[]} tokens Token objects from micromark.
+ */
+
+/**
+ * markdown-it token.
+ *
+ * @typedef {Object} MarkdownItToken
+ * @property {string[][]} attrs HTML attributes.
+ * @property {boolean} block Block-level token.
+ * @property {MarkdownItToken[]} children Child nodes.
+ * @property {string} content Tag contents.
+ * @property {boolean} hidden Ignore element.
+ * @property {string} info Fence info.
+ * @property {number} level Nesting level.
+ * @property {number[]} map Beginning/ending line numbers.
+ * @property {string} markup Markup text.
+ * @property {Object} meta Arbitrary data.
+ * @property {number} nesting Level change.
+ * @property {string} tag HTML tag name.
+ * @property {string} type Token type.
+ * @property {number} lineNumber Line number (1-based).
+ * @property {string} line Line content.
+ */
+
+/** @typedef {import("markdownlint-micromark").TokenType} MicromarkTokenType */
+
+/**
+ * micromark token.
+ *
+ * @typedef {Object} MicromarkToken
+ * @property {MicromarkTokenType} type Token type.
+ * @property {number} startLine Start line (1-based).
+ * @property {number} startColumn Start column (1-based).
+ * @property {number} endLine End line (1-based).
+ * @property {number} endColumn End column (1-based).
+ * @property {string} text Token text.
+ * @property {MicromarkToken[]} children Child tokens.
+ * @property {MicromarkToken | null} parent Parent token.
+ */
+
+/**
+ * Error-reporting callback.
+ *
+ * @callback RuleOnError
+ * @param {RuleOnErrorInfo} onErrorInfo Error information.
+ * @returns {void}
+ */
+
+/**
+ * Fix information for RuleOnError callback.
+ *
+ * @typedef {Object} RuleOnErrorInfo
+ * @property {number} lineNumber Line number (1-based).
+ * @property {string} [detail] Detail about the error.
+ * @property {string} [context] Context for the error.
+ * @property {URL} [information] Link to more information.
+ * @property {number[]} [range] Column number (1-based) and length.
+ * @property {RuleOnErrorFixInfo} [fixInfo] Fix information.
+ */
+
+/**
+ * Fix information for RuleOnErrorInfo.
+ *
+ * @typedef {Object} RuleOnErrorFixInfo
+ * @property {number} [lineNumber] Line number (1-based).
+ * @property {number} [editColumn] Column of the fix (1-based).
+ * @property {number} [deleteCount] Count of characters to delete.
+ * @property {string} [insertText] Text to insert (after deleting).
+ */
+
+/**
+ * Rule definition.
+ *
+ * @typedef {Object} Rule
+ * @property {string[]} names Rule name(s).
+ * @property {string} description Rule description.
+ * @property {URL} [information] Link to more information.
+ * @property {string[]} tags Rule tag(s).
+ * @property {"markdownit" | "micromark" | "none"} parser Parser used.
+ * @property {boolean} [asynchronous] True if asynchronous.
+ * @property {RuleFunction} function Rule implementation.
+ */
+
+/**
+ * Configuration options.
+ *
+ * @typedef {Object} Options
+ * @property {Configuration} [config] Configuration object.
+ * @property {ConfigurationParser[]} [configParsers] Configuration parsers.
+ * @property {Rule[] | Rule} [customRules] Custom rules.
+ * @property {string[] | string} [files] Files to lint.
+ * @property {RegExp | null} [frontMatter] Front matter pattern.
+ * @property {Object} [fs] File system implementation.
+ * @property {boolean} [handleRuleFailures] True to catch exceptions.
+ * @property {Plugin[]} [markdownItPlugins] Additional plugins.
+ * @property {boolean} [noInlineConfig] True to ignore HTML directives.
+ * @property {number} [resultVersion] Results object version.
+ * @property {Object.<string, string>} [strings] Strings to lint.
+ */
+
+/**
+ * A markdown-it plugin.
+ *
+ * @typedef {Array} Plugin
+ */
+
+/**
+ * Function to pretty-print lint results.
+ *
+ * @callback ToStringCallback
+ * @param {boolean} [ruleAliases] True to use rule aliases.
+ * @returns {string}
+ */
+
+/**
+ * Lint results (for resultVersion 3).
+ *
+ * @typedef {Object.<string, LintError[]>} LintResults
+ * @property {ToStringCallback} toString String representation.
+ */
+
+/**
+ * Lint error.
+ *
+ * @typedef {Object} LintError
+ * @property {number} lineNumber Line number (1-based).
+ * @property {string[]} ruleNames Rule name(s).
+ * @property {string} ruleDescription Rule description.
+ * @property {string} ruleInformation Link to more information.
+ * @property {string} errorDetail Detail about the error.
+ * @property {string} errorContext Context for the error.
+ * @property {number[]} errorRange Column number (1-based) and length.
+ * @property {FixInfo} [fixInfo] Fix information.
+ */
+
+/**
+ * Fix information.
+ *
+ * @typedef {Object} FixInfo
+ * @property {number} [lineNumber] Line number (1-based).
+ * @property {number} [editColumn] Column of the fix (1-based).
+ * @property {number} [deleteCount] Count of characters to delete.
+ * @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} error Error object iff failed.
+ * @param {LintResults} [results] Lint results iff succeeded.
+ * @returns {void}
+ */
+
+/**
+ * Configuration object for linting rules. For the JSON schema, see
+ * {@link ../schema/markdownlint-config-schema.json}.
+ *
+ * @typedef {import("./configuration").Configuration} Configuration
+ */
+
+/**
+ * Configuration object for linting rules strictly. For the JSON schema, see
+ * {@link ../schema/markdownlint-config-schema-strict.json}.
+ *
+ * @typedef {import("./configuration-strict").ConfigurationStrict} ConfigurationStrict
+ */
+
+/**
+ * Rule configuration object.
+ *
+ * @typedef {boolean | Object} RuleConfiguration Rule configuration.
+ */
+
+/**
+ * Parses a configuration string and returns a configuration object.
+ *
+ * @callback ConfigurationParser
+ * @param {string} text Configuration string.
+ * @returns {Configuration}
+ */
+
+/**
+ * Called with the result of the readConfig function.
+ *
+ * @callback ReadConfigCallback
+ * @param {Error | null} err Error object or null.
+ * @param {Configuration} [config] Configuration object.
+ * @returns {void}
+ */
+
+/**
+ * Called with the result of the resolveConfigExtends function.
+ *
+ * @callback ResolveConfigExtendsCallback
+ * @param {Error | null} err Error object or null.
+ * @param {string} [path] Resolved path to file.
+ * @returns {void}
+ */