markdownlint 0.33.0 → 0.34.0

package/lib/md040.js

@@ -2,36 +2,41 @@
 
 "use strict";
 
-const { addError, addErrorContext, filterTokens } = require("../helpers");
+const { addError, addErrorContext } = require("../helpers");
+const { filterByTypes, getTokenTextByType, tokenIfType } =
+  require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD040", "fenced-code-language" ],
   "description": "Fenced code blocks should have a language specified",
   "tags": [ "code", "language" ],
+  "parser": "micromark",
   "function": function MD040(params, onError) {
     let allowed = params.config.allowed_languages;
     allowed = Array.isArray(allowed) ? allowed : [];
     const languageOnly = !!params.config.language_only;
-
-    filterTokens(params, "fence", function forToken(token) {
-      const lang = token.info.trim().split(/\s+/u).shift();
-      if (lang === "") {
-        addErrorContext(onError, token.lineNumber, token.line);
-      } else if ((allowed.length > 0) && !allowed.includes(lang)) {
-        addError(
-          onError,
-          token.lineNumber,
-          `"${lang}" is not allowed`
-        );
-      }
-
-      if (languageOnly && (token.info !== lang)) {
-        addError(
-          onError,
-          token.lineNumber,
-          `Info string contains more than language: "${token.info}"`
-        );
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const fencedCodes = filterByTypes(micromarkTokens, [ "codeFenced" ]);
+    for (const fencedCode of fencedCodes) {
+      const openingFence = tokenIfType(fencedCode.children[0], "codeFencedFence");
+      if (openingFence) {
+        const { children, startLine, text } = openingFence;
+        const info = getTokenTextByType(children, "codeFencedFenceInfo");
+        if (!info) {
+          addErrorContext(onError, startLine, text);
+        } else if ((allowed.length > 0) && !allowed.includes(info)) {
+          addError(onError, startLine, `"${info}" is not allowed`);
+        }
+        if (languageOnly && getTokenTextByType(children, "codeFencedFenceMeta")) {
+          addError(onError, startLine, `Info string contains more than language: "${text}"`);
+        }
       }
-    });
+    }
   }
 };

package/lib/md041.js

@@ -3,40 +3,35 @@
 "use strict";
 
 const { addErrorContext, frontMatterHasTitle } = require("../helpers");
+const { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } =
+  require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD041", "first-line-heading", "first-line-h1" ],
   "description": "First line in a file should be a top-level heading",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD041(params, onError) {
     const level = Number(params.config.level || 1);
-    const tag = "h" + level;
-    const foundFrontMatterTitle =
-      frontMatterHasTitle(
-        params.frontMatterLines,
-        params.config.front_matter_title
-      );
-    if (!foundFrontMatterTitle) {
-      const htmlHeadingRe = new RegExp(`^<h${level}[ />]`, "i");
-      params.parsers.markdownit.tokens.every((token) => {
-        let isError = false;
-        if (token.type === "html_block") {
-          if (token.content.startsWith("<!--")) {
-            // Ignore leading HTML comments
-            return true;
-          } else if (!htmlHeadingRe.test(token.content)) {
-            // Something other than an HTML heading
-            isError = true;
+    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" ]);
+            const tagInfo = (htmlTexts.length > 0) && getHtmlTagInfo(htmlTexts[0]);
+            isError = !tagInfo || (tagInfo.name.toLowerCase() !== `h${level}`);
           }
-        } else if ((token.type !== "heading_open") || (token.tag !== tag)) {
-          // Something other than a Markdown heading
-          isError = true;
-        }
-        if (isError) {
-          addErrorContext(onError, token.lineNumber, token.line);
-        }
-        return false;
-      });
+          if (isError) {
+            addErrorContext(onError, token.startLine, params.lines[token.startLine - 1]);
+          }
+          return false;
+        });
     }
   }
 };

package/lib/md042.js

@@ -5,10 +5,13 @@
 const { addErrorContext, escapeForRegExp, filterTokens } =
   require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD042", "no-empty-links" ],
   "description": "No empty links",
   "tags": [ "links" ],
+  "parser": "markdownit",
   "function": function MD042(params, onError) {
     filterTokens(params, "inline", function forToken(token) {
       let inLink = false;
@@ -33,6 +36,7 @@ module.exports = {
             );
             if (match) {
               context = match[0];
+              // @ts-ignore
               range = [ match.index + 1, match[0].length ];
             }
             addErrorContext(

package/lib/md043.js

@@ -5,10 +5,13 @@
 const { addErrorContext, addErrorDetailIf, forEachHeading } =
   require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD043", "required-headings" ],
   "description": "Required heading structure",
   "tags": [ "headings" ],
+  "parser": "markdownit",
   "function": function MD043(params, onError) {
     const requiredHeadings = params.config.headings;
     if (!Array.isArray(requiredHeadings)) {

package/lib/md044.js

@@ -11,10 +11,13 @@ const ignoredChildTypes = new Set(
   [ "codeFencedFence", "definition", "reference", "resource" ]
 );
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD044", "proper-names" ],
   "description": "Proper names should have the correct capitalization",
   "tags": [ "spelling" ],
+  "parser": "micromark",
   "function": function MD044(params, onError) {
     let names = params.config.names;
     names = Array.isArray(names) ? names : [];
@@ -29,6 +32,11 @@ module.exports = {
     const htmlElements = params.config.html_elements;
     const includeHtmlElements =
       (htmlElements === undefined) ? true : !!htmlElements;
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     const scannedTypes = new Set([ "data" ]);
     if (includeCodeBlocks) {
       scannedTypes.add("codeFlowValue");
@@ -40,7 +48,7 @@ module.exports = {
     }
     const contentTokens =
       filterByPredicate(
-        params.parsers.micromark.tokens,
+        micromarkTokens,
         (token) => scannedTypes.has(token.type),
         (token) => (
           token.children.filter((t) => !ignoredChildTypes.has(t.type))

package/lib/md045.js

@@ -7,15 +7,22 @@ const { filterByTypes, getHtmlTagInfo } = require("../helpers/micromark.cjs");
 
 const altRe = getHtmlAttributeRe("alt");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD045", "no-alt-text" ],
   "description": "Images should have alternate text (alt text)",
   "tags": [ "accessibility", "images" ],
+  "parser": "micromark",
   "function": function MD045(params, onError) {
-    const { tokens } = params.parsers.micromark;
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
 
     // Process Markdown images
-    const images = filterByTypes(tokens, [ "image" ]);
+    const images = filterByTypes(micromarkTokens, [ "image" ]);
     for (const image of images) {
       const labelTexts = filterByTypes(image.children, [ "labelText" ]);
       if (labelTexts.some((labelText) => labelText.text.length === 0)) {
@@ -33,7 +40,7 @@ module.exports = {
     }
 
     // Process HTML images
-    const htmlTexts = filterByTypes(tokens, [ "htmlText" ]);
+    const htmlTexts = filterByTypes(micromarkTokens, [ "htmlText" ]);
     for (const htmlText of htmlTexts) {
       const { startColumn, startLine, text } = htmlText;
       const htmlTagInfo = getHtmlTagInfo(htmlText);

package/lib/md046.js

@@ -3,29 +3,36 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
 
 const tokenTypeToStyle = {
-  "fence": "fenced",
-  "code_block": "indented"
+  "codeFenced": "fenced",
+  "codeIndented": "indented"
 };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD046", "code-block-style" ],
   "description": "Code block style",
   "tags": [ "code" ],
+  "parser": "micromark",
   "function": function MD046(params, onError) {
     let expectedStyle = String(params.config.style || "consistent");
-    const codeBlocksAndFences = params.parsers.markdownit.tokens.filter(
-      (token) => (token.type === "code_block") || (token.type === "fence")
-    );
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const codeBlocksAndFences = filterByTypes(micromarkTokens, [ "codeFenced", "codeIndented" ]);
     for (const token of codeBlocksAndFences) {
-      const { lineNumber, type } = token;
+      const { startLine, type } = token;
       if (expectedStyle === "consistent") {
         expectedStyle = tokenTypeToStyle[type];
       }
       addErrorDetailIf(
         onError,
-        lineNumber,
+        startLine,
         expectedStyle,
         tokenTypeToStyle[type]);
     }

package/lib/md047.js

@@ -4,10 +4,13 @@
 
 const { addError, isBlankLine } = require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD047", "single-trailing-newline" ],
   "description": "Files should end with a single newline character",
   "tags": [ "blank_lines" ],
+  "parser": "none",
   "function": function MD047(params, onError) {
     const lastLineNumber = params.lines.length;
     const lastLine = params.lines[lastLineNumber - 1];
@@ -15,8 +18,8 @@ module.exports = {
       addError(
         onError,
         lastLineNumber,
-        null,
-        null,
+        undefined,
+        undefined,
         [ lastLine.length, 1 ],
         {
           "insertText": "\n",

package/lib/md048.js

@@ -3,28 +3,41 @@
 "use strict";
 
 const { addErrorDetailIf, fencedCodeBlockStyleFor } = require("../helpers");
+const { filterByTypes, tokenIfType } = require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD048", "code-fence-style" ],
   "description": "Code fence style",
   "tags": [ "code" ],
+  "parser": "micromark",
   "function": function MD048(params, onError) {
     const style = String(params.config.style || "consistent");
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     let expectedStyle = style;
-    const fenceTokens = params.parsers.markdownit.tokens.filter(
-      (token) => token.type === "fence"
-    );
-    for (const fenceToken of fenceTokens) {
-      const { lineNumber, markup } = fenceToken;
-      if (expectedStyle === "consistent") {
-        expectedStyle = fencedCodeBlockStyleFor(markup);
+    const codeFenceds = filterByTypes(micromarkTokens, [ "codeFenced" ]);
+    for (const codeFenced of codeFenceds) {
+      const codeFencedFence = tokenIfType(codeFenced.children[0], "codeFencedFence");
+      if (codeFencedFence) {
+        const codeFencedFenceSequence = tokenIfType(codeFencedFence.children[0], "codeFencedFenceSequence");
+        if (codeFencedFenceSequence) {
+          const { startLine, text } = codeFencedFenceSequence;
+          if (expectedStyle === "consistent") {
+            expectedStyle = fencedCodeBlockStyleFor(text);
+          }
+          addErrorDetailIf(
+            onError,
+            startLine,
+            expectedStyle,
+            fencedCodeBlockStyleFor(text)
+          );
+        }
       }
-      addErrorDetailIf(
-        onError,
-        lineNumber,
-        expectedStyle,
-        fencedCodeBlockStyleFor(markup)
-      );
     }
   }
 };

package/lib/md049-md050.js

@@ -5,21 +5,34 @@
 const { addError, emphasisOrStrongStyleFor } = require("../helpers");
 const { filterByPredicate, tokenIfType } = require("../helpers/micromark.cjs");
 
-const intrawordRe = /\w/;
+const intrawordRe = /^\w$/;
 
+/**
+ * @param {import("./markdownlint").RuleParams} params Rule parameters.
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("markdownlint-micromark").TokenType} type Token type.
+ * @param {import("markdownlint-micromark").TokenType} typeSequence Token sequence type.
+ * @param {"*" | "**"} asterisk Asterisk kind.
+ * @param {"_" | "__"} underline Underline kind.
+ * @param {"asterisk" | "consistent" | "underscore"} style Style string.
+ */
 const impl =
-  (params, onError, type, asterisk, underline, style = "consistent") => {
-    const { lines, parsers } = params;
+  (params, onError, type, typeSequence, asterisk, underline, style = "consistent") => {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const { lines } = params;
     const emphasisTokens = filterByPredicate(
-      parsers.micromark.tokens,
+      micromarkTokens,
       (token) => token.type === type,
       (token) => ((token.type === "htmlFlow") ? [] : token.children)
     );
     for (const token of emphasisTokens) {
       const { children } = token;
-      const childType = `${type}Sequence`;
-      const startSequence = tokenIfType(children[0], childType);
-      const endSequence = tokenIfType(children[children.length - 1], childType);
+      const startSequence = tokenIfType(children[0], typeSequence);
+      const endSequence = tokenIfType(children[children.length - 1], typeSequence);
       if (startSequence && endSequence) {
         const markupStyle = emphasisOrStrongStyleFor(startSequence.text);
         if (style === "consistent") {
@@ -55,16 +68,20 @@ const impl =
     }
   };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule[] */
 module.exports = [
   {
     "names": [ "MD049", "emphasis-style" ],
     "description": "Emphasis style",
     "tags": [ "emphasis" ],
+    "parser": "micromark",
     "function": function MD049(params, onError) {
       return impl(
         params,
         onError,
         "emphasis",
+        "emphasisSequence",
         "*",
         "_",
         params.config.style || undefined
@@ -75,11 +92,13 @@ module.exports = [
     "names": [ "MD050", "strong-style" ],
     "description": "Strong style",
     "tags": [ "emphasis" ],
+    "parser": "micromark",
     "function": function MD050(params, onError) {
       return impl(
         params,
         onError,
         "strong",
+        "strongSequence",
         "**",
         "__",
         params.config.style || undefined

package/lib/md051.js

@@ -11,22 +11,19 @@ const { filterByPredicate, filterByTypes, getHtmlTagInfo } =
 const idRe = getHtmlAttributeRe("id");
 const nameRe = getHtmlAttributeRe("name");
 const anchorRe = /\{(#[a-z\d]+(?:[-_][a-z\d]+)*)\}/gu;
+const lineFragmentRe = /^#(?:L\d+(?:C\d+)?-L\d+(?:C\d+)?|L\d+)$/;
 
 // Sets for filtering heading tokens during conversion
 const childrenExclude = new Set([ "image", "reference", "resource" ]);
 const tokensInclude = new Set(
-  [ "characterEscapeValue", "codeTextData", "data" ]
+  [ "characterEscapeValue", "codeTextData", "data", "mathTextData" ]
 );
 
-/**
- * @typedef {import("../helpers/micromark.cjs").Token} Token
- */
-
 /**
  * Converts a Markdown heading into an HTML fragment according to the rules
  * used by GitHub.
  *
- * @param {Token} headingText Heading text token.
+ * @param {import("../helpers/micromark.cjs").Token} headingText Heading text token.
  * @returns {string} Fragment string for heading.
  */
 function convertHeadingToHTMLFragment(headingText) {
@@ -55,7 +52,7 @@ function convertHeadingToHTMLFragment(headingText) {
 /**
  * Unescapes the text of a String-type micromark Token.
  *
- * @param {Token} token String-type micromark Token.
+ * @param {import("../helpers/micromark.cjs").Token} token String-type micromark Token.
  * @returns {string} Unescaped token text.
  */
 function unescapeStringTokenText(token) {
@@ -64,19 +61,23 @@ function unescapeStringTokenText(token) {
     .join("");
 }
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD051", "link-fragments" ],
   "description": "Link fragments should be valid",
   "tags": [ "links" ],
+  "parser": "micromark",
   "function": function MD051(params, onError) {
-    const { tokens } = params.parsers.micromark;
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     const fragments = new Map();
 
     // Process headings
-    const headingTexts = filterByTypes(
-      tokens,
-      [ "atxHeadingText", "setextHeadingText" ]
-    );
+    const headingTexts = filterByTypes(micromarkTokens, [ "atxHeadingText", "setextHeadingText" ]);
     for (const headingText of headingTexts) {
       const fragment = convertHeadingToHTMLFragment(headingText);
       if (fragment !== "#") {
@@ -96,7 +97,7 @@ module.exports = {
     }
 
     // Process HTML anchors
-    for (const token of filterByTypes(tokens, [ "htmlText" ])) {
+    for (const token of filterByTypes(micromarkTokens, [ "htmlText" ])) {
       const htmlTagInfo = getHtmlTagInfo(token);
       if (htmlTagInfo && !htmlTagInfo.close) {
         const anchorMatch = idRe.exec(token.text) ||
@@ -108,22 +109,25 @@ module.exports = {
     }
 
     // Process link and definition fragments
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").TokenType[][] */
     const parentChilds = [
       [ "link", "resourceDestinationString" ],
       [ "definition", "definitionDestinationString" ]
     ];
     for (const [ parentType, definitionType ] of parentChilds) {
-      const links = filterByTypes(tokens, [ parentType ]);
+      const links = filterByTypes(micromarkTokens, [ parentType ]);
       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))}`;
           if (
             (text.length > 1) &&
             text.startsWith("#") &&
-            !fragments.has(text) &&
-            !fragments.has(`#${encodeURIComponent(text.slice(1))}`)
+            !fragments.has(encodedText) &&
+            !lineFragmentRe.test(encodedText)
           ) {
             // eslint-disable-next-line no-undef-init
             let context = undefined;

package/lib/md052.js

@@ -5,11 +5,14 @@
 const { addError } = require("../helpers");
 const { referenceLinkImageData } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD052", "reference-links-images" ],
   "description":
     "Reference links and images should use a label that is defined",
   "tags": [ "images", "links" ],
+  "parser": "none",
   "function": function MD052(params, onError) {
     const { config, lines } = params;
     const shortcutSyntax = config.shortcut_syntax || false;

package/lib/md053.js

@@ -6,10 +6,13 @@ const { addError, ellipsify, linkReferenceDefinitionRe } =
   require("../helpers");
 const { referenceLinkImageData } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD053", "link-image-reference-definitions" ],
   "description": "Link and image reference definitions should be needed",
   "tags": [ "images", "links" ],
+  "parser": "none",
   "function": function MD053(params, onError) {
     const ignored = new Set(params.config.ignored_definitions || [ "//" ]);
     const lines = params.lines;

package/lib/md054.js

@@ -21,12 +21,15 @@ const autolinkAble = (destination) => {
   return !autolinkDisallowedRe.test(destination);
 };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD054", "link-image-style" ],
   "description": "Link and image style",
   "tags": [ "images", "links" ],
+  "parser": "micromark",
   "function": (params, onError) => {
-    const { parsers, config } = params;
+    const config = params.config;
     const autolink = (config.autolink === undefined) || !!config.autolink;
     const inline = (config.inline === undefined) || !!config.inline;
     const full = (config.full === undefined) || !!config.full;
@@ -37,11 +40,13 @@ module.exports = {
       // Everything allowed, nothing to check
       return;
     }
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     const { definitions } = referenceLinkImageData();
-    const links = filterByTypes(
-      parsers.micromark.tokens,
-      [ "autolink", "image", "link" ]
-    );
+    const links = filterByTypes(micromarkTokens, [ "autolink", "image", "link" ]);
     for (const link of links) {
       let label = null;
       let destination = null;

package/lib/md055.js

@@ -13,10 +13,13 @@ const firstOrNothing = (items) => items[0];
 const lastOrNothing = (items) => items[items.length - 1];
 const makeRange = (start, end) => [ start, end - start + 1 ];
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD055", "table-pipe-style" ],
   "description": "Table pipe style",
   "tags": [ "table" ],
+  "parser": "micromark",
   "function": function MD055(params, onError) {
     const style = String(params.config.style || "consistent");
     let expectedStyle = style;
@@ -24,7 +27,12 @@ module.exports = {
       ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "trailing_only"));
     let expectedTrailingPipe =
       ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "leading_only"));
-    const tables = filterByTypes(params.parsers.micromark.tokens, [ "table" ]);
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const tables = filterByTypes(micromarkTokens, [ "table" ]);
     for (const table of tables) {
       const rows = filterByTypes(table.children, [ "tableDelimiterRow", "tableRow" ]);
       for (const row of rows) {

package/lib/md056.js

@@ -7,12 +7,20 @@ const { filterByTypes } = require("../helpers/micromark.cjs");
 
 const makeRange = (start, end) => [ start, end - start + 1 ];
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD056", "table-column-count" ],
   "description": "Table column count",
   "tags": [ "table" ],
+  "parser": "micromark",
   "function": function MD056(params, onError) {
-    const tables = filterByTypes(params.parsers.micromark.tokens, [ "table" ]);
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const tables = filterByTypes(micromarkTokens, [ "table" ]);
     for (const table of tables) {
       const rows = filterByTypes(table.children, [ "tableDelimiterRow", "tableRow" ]);
       let expectedCount = 0;