markdownlint 0.33.0 → 0.34.0

package/lib/constants.js

@@ -11,4 +11,4 @@ module.exports.fixableRuleNames = [
   "MD047", "MD049", "MD050", "MD051", "MD053", "MD054"
 ];
 module.exports.homepage = "https://github.com/DavidAnson/markdownlint";
-module.exports.version = "0.33.0";
+module.exports.version = "0.34.0";

package/lib/markdownlint.d.ts

@@ -8,7 +8,7 @@ export = markdownlint;
  */
 declare function markdownlint(options: Options | null, callback: LintCallback): void;
 declare namespace markdownlint {
-    export { markdownlintSync as sync, readConfig, readConfigSync, getVersion, promises, RuleFunction, RuleParams, MarkdownItToken, RuleOnError, RuleOnErrorInfo, RuleOnErrorFixInfo, Rule, Options, Plugin, ToStringCallback, LintResults, LintError, FixInfo, LintContentCallback, LintCallback, Configuration, RuleConfiguration, ConfigurationParser, ReadConfigCallback, ResolveConfigExtendsCallback };
+    export { markdownlintSync as sync, readConfig, readConfigSync, getVersion, promises, RuleFunction, RuleParams, MarkdownParsers, ParserMarkdownIt, ParserMicromark, MarkdownItToken, MicromarkTokenType, MicromarkToken, RuleOnError, RuleOnErrorInfo, RuleOnErrorFixInfo, Rule, Options, Plugin, ToStringCallback, LintResults, LintError, FixInfo, LintContentCallback, LintCallback, Configuration, RuleConfiguration, ConfigurationParser, ReadConfigCallback, ResolveConfigExtendsCallback };
 }
 /**
  * Configuration options.
@@ -117,24 +117,55 @@ type RuleParams = {
      */
     name: string;
     /**
-     * Token objects from markdown-it.
+     * Markdown parser data.
      */
-    tokens: MarkdownItToken[];
+    parsers: MarkdownParsers;
     /**
      * File/string lines.
      */
-    lines: string[];
+    lines: readonly string[];
     /**
      * Front matter lines.
      */
-    frontMatterLines: string[];
+    frontMatterLines: readonly string[];
     /**
      * Rule configuration.
      */
     config: RuleConfiguration;
 };
 /**
- * Markdown-It token.
+ * Markdown parser data.
+ */
+type MarkdownParsers = {
+    /**
+     * Markdown parser data from markdown-it (only present when Rule.parser is "markdownit").
+     */
+    markdownit: ParserMarkdownIt;
+    /**
+     * Markdown parser data from micromark (only present when Rule.parser is "micromark").
+     */
+    micromark: ParserMicromark;
+};
+/**
+ * Markdown parser data from markdown-it.
+ */
+type ParserMarkdownIt = {
+    /**
+     * Token objects from markdown-it.
+     */
+    tokens: MarkdownItToken[];
+};
+/**
+ * Markdown parser data from micromark.
+ */
+type ParserMicromark = {
+    /**
+     * Token objects from micromark.
+     */
+    tokens: MicromarkToken[];
+};
+/**
+ * markdown-it token.
  */
 type MarkdownItToken = {
     /**
@@ -198,6 +229,44 @@ type MarkdownItToken = {
      */
     line: string;
 };
+type MicromarkTokenType = import("markdownlint-micromark").TokenType;
+/**
+ * micromark token.
+ */
+type MicromarkToken = {
+    /**
+     * Token type.
+     */
+    type: MicromarkTokenType;
+    /**
+     * Start line (1-based).
+     */
+    startLine: number;
+    /**
+     * Start column (1-based).
+     */
+    startColumn: number;
+    /**
+     * End line (1-based).
+     */
+    endLine: number;
+    /**
+     * End column (1-based).
+     */
+    endColumn: number;
+    /**
+     * Token text.
+     */
+    text: string;
+    /**
+     * Child tokens.
+     */
+    children: MicromarkToken[];
+    /**
+     * Parent token.
+     */
+    parent: MicromarkToken | null;
+};
 /**
  * Error-reporting callback.
  */
@@ -272,6 +341,10 @@ type Rule = {
      * Rule tag(s).
      */
     tags: string[];
+    /**
+     * Parser used.
+     */
+    parser: "markdownit" | "micromark" | "none";
     /**
      * True if asynchronous.
      */

package/lib/markdownlint.js

@@ -33,17 +33,16 @@ function validateRuleList(ruleList, synchronous) {
   for (const [ index, rule ] of ruleList.entries()) {
     const customIndex = index - rules.length;
     // eslint-disable-next-line no-inner-declarations, jsdoc/require-jsdoc
-    function newError(property) {
+    function newError(property, value) {
       return new Error(
-        "Property '" + property + "' of custom rule at index " +
-        customIndex + " is incorrect.");
+        `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);
+        result = newError(property, value);
       }
     }
     for (const propertyInfo of [
@@ -53,22 +52,31 @@ function validateRuleList(ruleList, synchronous) {
       const property = propertyInfo[0];
       const value = rule[property];
       if (!result && (!value || (typeof value !== propertyInfo[1]))) {
-        result = newError(property);
+        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");
+      result = newError("information", rule.information);
     }
     if (
       !result &&
       (rule.asynchronous !== undefined) &&
       (typeof rule.asynchronous !== "boolean")
     ) {
-      result = newError("asynchronous");
+      result = newError("asynchronous", rule.asynchronous);
     }
     if (!result && rule.asynchronous && synchronous) {
       result = new Error(
@@ -563,18 +571,26 @@ function lintContent(
   const lines = content.split(helpers.newLineRe);
   annotateAndFreezeTokens(markdownitTokens, lines);
   // Create (frozen) parameters for rules
-  const parsers = Object.freeze({
+  /** @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,
-    parsers,
-    "tokens": markdownitTokens,
+    "parsers": parsersMarkdownIt,
     "lines": Object.freeze(lines),
     "frontMatterLines": Object.freeze(frontMatterLines)
   };
@@ -583,9 +599,9 @@ function lintContent(
   const codeBlockAndSpanRanges =
     helpers.codeBlockAndSpanRanges(paramsBase, lineMetadata);
   const flattenedLists =
-    helpers.flattenLists(paramsBase.parsers.markdownit.tokens);
+    helpers.flattenLists(markdownitTokens);
   const referenceLinkImageData =
-    helpers.getReferenceLinkImageData(paramsBase);
+    helpers.getReferenceLinkImageData(micromarkTokens);
   cache.set({
     codeBlockAndSpanRanges,
     flattenedLists,
@@ -594,12 +610,27 @@ function lintContent(
   });
   // Function to run for each rule
   let results = [];
-  // eslint-disable-next-line jsdoc/require-jsdoc
-  function forRule(rule) {
+  /**
+   * @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
@@ -721,7 +752,7 @@ function lintContent(
       }
     }
     return null;
-  }
+  };
   // eslint-disable-next-line jsdoc/require-jsdoc
   function formatResults() {
     // Sort results by rule name by line number
@@ -875,6 +906,7 @@ function lintInput(options, synchronous, callback) {
         "description": rule.description,
         "information": helpers.cloneIfUrl(rule.information),
         "tags": helpers.cloneIfArray(rule.tags),
+        "parser": rule.parser,
         "asynchronous": rule.asynchronous,
         "function": rule.function
       }));
@@ -1281,19 +1313,45 @@ module.exports = markdownlint;
  * @returns {void}
  */
 
+/* eslint-disable jsdoc/valid-types */
+
 /**
  * Rule parameters.
  *
  * @typedef {Object} RuleParams
  * @property {string} name File/string name.
- * @property {MarkdownItToken[]} tokens Token objects from markdown-it.
- * @property {string[]} lines File/string lines.
- * @property {string[]} frontMatterLines Front matter lines.
+ * @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-It token.
+ * 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.
@@ -1313,6 +1371,22 @@ module.exports = markdownlint;
  * @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.
  *
@@ -1351,6 +1425,7 @@ module.exports = markdownlint;
  * @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.
  */

package/lib/md001.js

@@ -4,10 +4,13 @@
 
 const { addErrorDetailIf, filterTokens } = require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD001", "heading-increment" ],
   "description": "Heading levels should only increment by one level at a time",
   "tags": [ "headings" ],
+  "parser": "markdownit",
   "function": function MD001(params, onError) {
     let prevLevel = 0;
     filterTokens(params, "heading_open", function forToken(token) {

package/lib/md003.js

@@ -5,10 +5,13 @@
 const { addErrorDetailIf, filterTokens, headingStyleFor } =
   require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD003", "heading-style" ],
   "description": "Heading style",
   "tags": [ "headings" ],
+  "parser": "markdownit",
   "function": function MD003(params, onError) {
     let style = String(params.config.style || "consistent");
     filterTokens(params, "heading_open", function forToken(token) {

package/lib/md004.js

@@ -18,10 +18,13 @@ const differentItemStyle = {
 };
 const validStyles = Object.keys(expectedStyleToMarker);
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD004", "ul-style" ],
   "description": "Unordered list style",
   "tags": [ "bullet", "ul" ],
+  "parser": "none",
   "function": function MD004(params, onError) {
     const style = String(params.config.style || "consistent");
     let expectedStyle = style;

package/lib/md005.js

@@ -5,13 +5,21 @@
 const { addError, addErrorDetailIf } = require("../helpers");
 const { filterByTypes, inHtmlFlow } = require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD005", "list-indent" ],
   "description": "Inconsistent indentation for list items at the same level",
   "tags": [ "bullet", "ul", "indentation" ],
+  "parser": "micromark",
   "function": function MD005(params, onError) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     const lists = filterByTypes(
-      params.parsers.micromark.tokens,
+      micromarkTokens,
       [ "listOrdered", "listUnordered" ]
     ).filter((list) => !inHtmlFlow(list));
     for (const list of lists) {

package/lib/md007.js

@@ -6,36 +6,41 @@ const { addErrorDetailIf } = require("../helpers");
 const { filterByTypes, getTokenParentOfType, inHtmlFlow } =
   require("../helpers/micromark.cjs");
 
-/**
- * @typedef {import("../helpers/micromark.cjs").Token} Token
- */
-
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("markdownlint-micromark").TokenType[] */
 const unorderedListTypes =
   [ "blockQuotePrefix", "listItemPrefix", "listUnordered" ];
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("markdownlint-micromark").TokenType[] */
 const unorderedParentTypes =
   [ "blockQuote", "listOrdered", "listUnordered" ];
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD007", "ul-indent" ],
   "description": "Unordered list indentation",
   "tags": [ "bullet", "ul", "indentation" ],
+  "parser": "micromark",
   "function": function MD007(params, onError) {
     const indent = Number(params.config.indent || 2);
     const startIndented = !!params.config.start_indented;
     const startIndent = Number(params.config.start_indent || indent);
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     const unorderedListNesting = new Map();
     let lastBlockQuotePrefix = null;
-    const tokens = filterByTypes(
-      params.parsers.micromark.tokens,
-      unorderedListTypes
-    );
+    const tokens = filterByTypes(micromarkTokens, unorderedListTypes);
     for (const token of tokens) {
       const { endColumn, parent, startColumn, startLine, type } = token;
       if (type === "blockQuotePrefix") {
         lastBlockQuotePrefix = token;
       } else if (type === "listUnordered") {
         let nesting = 0;
-        /** @type {Token | null} */
+        /** @type {import("../helpers/micromark.cjs").Token | null} */
         let current = token;
         while (
           (current = getTokenParentOfType(current, unorderedParentTypes))

package/lib/md009.js

@@ -6,10 +6,13 @@ const { addError, filterTokens, forEachLine, includesSorted,
   numericSortAscending } = require("../helpers");
 const { lineMetadata } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD009", "no-trailing-spaces" ],
   "description": "Trailing spaces",
   "tags": [ "whitespace" ],
+  "parser": "markdownit",
   "function": function MD009(params, onError) {
     let brSpaces = params.config.br_spaces;
     brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);

package/lib/md010.js

@@ -8,10 +8,13 @@ const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 
 const tabRe = /\t+/g;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD010", "no-hard-tabs" ],
   "description": "Hard tabs",
   "tags": [ "whitespace", "hard_tab" ],
+  "parser": "markdownit",
   "function": function MD010(params, onError) {
     const codeBlocks = params.config.code_blocks;
     const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
@@ -44,7 +47,7 @@ module.exports = {
               onError,
               lineIndex + 1,
               "Column: " + column,
-              null,
+              undefined,
               [ column, length ],
               {
                 "editColumn": column,

package/lib/md011.js

@@ -8,10 +8,13 @@ const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 const reversedLinkRe =
   /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD011", "no-reversed-links" ],
   "description": "Reversed link syntax",
   "tags": [ "links" ],
+  "parser": "none",
   "function": function MD011(params, onError) {
     const exclusions = codeBlockAndSpanRanges();
     forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {

package/lib/md012.js

@@ -5,10 +5,13 @@
 const { addErrorDetailIf, forEachLine } = require("../helpers");
 const { lineMetadata } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD012", "no-multiple-blanks" ],
   "description": "Multiple consecutive blank lines",
   "tags": [ "whitespace", "blank_lines" ],
+  "parser": "none",
   "function": function MD012(params, onError) {
     const maximum = Number(params.config.maximum || 1);
     let count = 0;

package/lib/md013.js

@@ -22,10 +22,13 @@ const tokenTypeMap = {
   "text": "T"
 };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD013", "line-length" ],
   "description": "Line length",
   "tags": [ "line_length" ],
+  "parser": "markdownit",
   "function": function MD013(params, onError) {
     const lineLength = Number(params.config.line_length || 80);
     const headingLineLength =

package/lib/md014.js

@@ -6,10 +6,13 @@ const { addErrorContext, filterTokens } = require("../helpers");
 
 const dollarCommandRe = /^(\s*)(\$\s+)/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD014", "commands-show-output" ],
   "description": "Dollar signs used before commands without showing output",
   "tags": [ "code" ],
+  "parser": "markdownit",
   "function": function MD014(params, onError) {
     for (const type of [ "code_block", "fence" ]) {
       filterTokens(params, type, (token) => {
@@ -35,6 +38,7 @@ module.exports = {
             const [ i, lineTrim, column, length ] = instance;
             addErrorContext(
               onError,
+              // @ts-ignore
               i + 1,
               lineTrim,
               null,

package/lib/md018.js

@@ -5,16 +5,20 @@
 const { addErrorContext, forEachLine } = require("../helpers");
 const { lineMetadata } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD018", "no-missing-space-atx" ],
   "description": "No space after hash on atx style heading",
   "tags": [ "headings", "atx", "spaces" ],
+  "parser": "none",
   "function": function MD018(params, onError) {
     forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
       if (!inCode &&
         /^#+[^# \t]/.test(line) &&
         !/#\s*$/.test(line) &&
         !line.startsWith("#️⃣")) {
+        // @ts-ignore
         const hashCount = /^#+/.exec(line)[0].length;
         addErrorContext(
           onError,

package/lib/md019.js

@@ -5,10 +5,13 @@
 const { addErrorContext, filterTokens, headingStyleFor } =
   require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD019", "no-multiple-space-atx" ],
   "description": "Multiple spaces after hash on atx style heading",
   "tags": [ "headings", "atx", "spaces" ],
+  "parser": "markdownit",
   "function": function MD019(params, onError) {
     filterTokens(params, "heading_open", (token) => {
       if (headingStyleFor(token) === "atx") {

package/lib/md020.js

@@ -5,10 +5,13 @@
 const { addErrorContext, forEachLine } = require("../helpers");
 const { lineMetadata } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD020", "no-missing-space-closed-atx" ],
   "description": "No space inside hashes on closed atx style heading",
   "tags": [ "headings", "atx_closed", "spaces" ],
+  "parser": "none",
   "function": function MD020(params, onError) {
     forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
       if (!inCode) {

package/lib/md021.js

@@ -7,10 +7,13 @@ const { addErrorContext, filterTokens, headingStyleFor } =
 
 const closedAtxRe = /^(#+)([ \t]+)([^ \t]|[^ \t].*[^ \t])([ \t]+)(#+)(\s*)$/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD021", "no-multiple-space-closed-atx" ],
   "description": "Multiple spaces inside hashes on closed atx style heading",
   "tags": [ "headings", "atx_closed", "spaces" ],
+  "parser": "markdownit",
   "function": function MD021(params, onError) {
     filterTokens(params, "heading_open", (token) => {
       if (headingStyleFor(token) === "atx_closed") {