markdownlint 0.33.0 → 0.34.0

package/lib/md022.js

@@ -31,16 +31,24 @@ const getBlockQuote = (str, count) => (
     .repeat(count)
 );
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD022", "blanks-around-headings" ],
   "description": "Headings should be surrounded by blank lines",
   "tags": [ "headings", "blank_lines" ],
+  "parser": "micromark",
   "function": function MD022(params, onError) {
     const getLinesAbove = getLinesFunction(params.config.lines_above);
     const getLinesBelow = getLinesFunction(params.config.lines_below);
-    const { lines, parsers } = params;
+    // 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 headings = filterByTypes(
-      parsers.micromark.tokens,
+      micromarkTokens,
       [ "atxHeading", "setextHeading" ]
     ).filter((heading) => !inHtmlFlow(heading));
     for (const heading of headings) {

package/lib/md023.js

@@ -6,10 +6,13 @@ const { addErrorContext, filterTokens } = require("../helpers");
 
 const spaceBeforeHeadingRe = /^(\s+|[>\s]+\s\s)[^>\s]/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD023", "heading-start-left" ],
   "description": "Headings must start at the beginning of the line",
   "tags": [ "headings", "spaces" ],
+  "parser": "markdownit",
   "function": function MD023(params, onError) {
     filterTokens(params, "heading_open", function forToken(token) {
       const { lineNumber, line } = token;

package/lib/md024.js

@@ -4,10 +4,13 @@
 
 const { addErrorContext, forEachHeading } = require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD024", "no-duplicate-heading" ],
   "description": "Multiple headings with the same content",
   "tags": [ "headings" ],
+  "parser": "markdownit",
   "function": function MD024(params, onError) {
     const siblingsOnly = !!params.config.siblings_only || false;
     const knownContents = [ null, [] ];

package/lib/md025.js

@@ -5,10 +5,13 @@
 const { addErrorContext, filterTokens, frontMatterHasTitle } =
   require("../helpers");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD025", "single-title", "single-h1" ],
   "description": "Multiple top-level headings in the same document",
   "tags": [ "headings" ],
+  "parser": "markdownit",
   "function": function MD025(params, onError) {
     const level = Number(params.config.level || 1);
     const tag = "h" + level;

package/lib/md026.js

@@ -6,11 +6,13 @@ const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
   endOfLineHtmlEntityRe, escapeForRegExp } = require("../helpers");
 const { filterByTypes } = require("../helpers/micromark.cjs");
 
-
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD026", "no-trailing-punctuation" ],
   "description": "Trailing punctuation in heading",
   "tags": [ "headings" ],
+  "parser": "micromark",
   "function": function MD026(params, onError) {
     let punctuation = params.config.punctuation;
     punctuation = String(
@@ -18,10 +20,12 @@ module.exports = {
     );
     const trailingPunctuationRe =
       new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
-    const headings = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "atxHeadingText", "setextHeadingText" ]
-    );
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const headings = filterByTypes(micromarkTokens, [ "atxHeadingText", "setextHeadingText" ]);
     for (const heading of headings) {
       const { endColumn, endLine, text } = heading;
       const match = trailingPunctuationRe.exec(text);

package/lib/md027.js

@@ -2,54 +2,40 @@
 
 "use strict";
 
-const { addErrorContext, newLineRe } = require("../helpers");
-
-const spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
+const { addErrorContext } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
-  "names": [ "MD027", "no-multiple-space-blockquote" ],
+  "names": ["MD027", "no-multiple-space-blockquote"],
   "description": "Multiple spaces after blockquote symbol",
-  "tags": [ "blockquote", "whitespace", "indentation" ],
+  "tags": ["blockquote", "whitespace", "indentation"],
+  "parser": "micromark",
   "function": function MD027(params, onError) {
-    let blockquoteNesting = 0;
-    let listItemNesting = 0;
-    for (const token of params.parsers.markdownit.tokens) {
-      const { content, lineNumber, type } = token;
-      if (type === "blockquote_open") {
-        blockquoteNesting++;
-      } else if (type === "blockquote_close") {
-        blockquoteNesting--;
-      } else if (type === "list_item_open") {
-        listItemNesting++;
-      } else if (type === "list_item_close") {
-        listItemNesting--;
-      } else if ((type === "inline") && blockquoteNesting) {
-        const lineCount = content.split(newLineRe).length;
-        for (let i = 0; i < lineCount; i++) {
-          const line = params.lines[lineNumber + i - 1];
-          const match = line.match(spaceAfterBlockQuoteRe);
-          if (match) {
-            const [
-              fullMatch,
-              { "length": blockquoteLength },
-              { "length": spaceLength }
-            ] = match;
-            if (!listItemNesting || (fullMatch[fullMatch.length - 1] === ">")) {
-              addErrorContext(
-                onError,
-                lineNumber + i,
-                line,
-                null,
-                null,
-                [ 1, fullMatch.length ],
-                {
-                  "editColumn": blockquoteLength + 1,
-                  "deleteCount": spaceLength - 1
-                }
-              );
-            }
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    for (const token of filterByTypes(micromarkTokens, [ "linePrefix" ])) {
+      const siblings = token.parent?.children || micromarkTokens;
+      if (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix") {
+        const { startColumn, startLine, text } = token;
+        const { length } = text;
+        const line = params.lines[startLine - 1];
+        addErrorContext(
+          onError,
+          startLine,
+          line,
+          null,
+          null,
+          [ startColumn, length ],
+          {
+            "editColumn": startColumn,
+            "deleteCount": length
           }
-        }
+        );
       }
     }
   }

package/lib/md028.js

@@ -3,28 +3,45 @@
 "use strict";
 
 const { addError } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
 
+const ignoreTypes = new Set([ "lineEnding", "listItemIndent", "linePrefix" ]);
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD028", "no-blanks-blockquote" ],
   "description": "Blank line inside blockquote",
   "tags": [ "blockquote", "whitespace" ],
+  "parser": "micromark",
   "function": function MD028(params, onError) {
-    let prevToken = {};
-    let prevLineNumber = null;
-    for (const token of params.parsers.markdownit.tokens) {
-      if ((token.type === "blockquote_open") &&
-          (prevToken.type === "blockquote_close")) {
-        for (
-          let lineNumber = prevLineNumber;
-          lineNumber < token.lineNumber;
-          lineNumber++) {
-          addError(onError, lineNumber);
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    for (const token of filterByTypes(micromarkTokens, [ "blockQuote" ])) {
+      const errorLineNumbers = [];
+      const siblings = token.parent?.children || micromarkTokens;
+      for (let i = siblings.indexOf(token) + 1; i < siblings.length; i++) {
+        const sibling = siblings[i];
+        const { startLine, type } = sibling;
+        if (type === "lineEndingBlank") {
+          // Possible blank between blockquotes
+          errorLineNumbers.push(startLine);
+        } else if (ignoreTypes.has(type)) {
+          // Ignore invisible formatting
+        } else if (type === "blockQuote") {
+          // Blockquote followed by blockquote
+          for (const lineNumber of errorLineNumbers) {
+            addError(onError, lineNumber);
+          }
+          break;
+        } else {
+          // Blockquote not followed by blockquote
+          break;
         }
       }
-      prevToken = token;
-      if (token.type === "blockquote_open") {
-        prevLineNumber = token.map[1] + 1;
-      }
     }
   }
 };

package/lib/md029.js

@@ -12,10 +12,13 @@ const listStyleExamples = {
   "zero": "0/0/0"
 };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD029", "ol-prefix" ],
   "description": "Ordered list item prefix",
   "tags": [ "ol" ],
+  "parser": "none",
   "function": function MD029(params, onError) {
     const style = String(params.config.style || "one_or_ordered");
     const filteredLists = flattenedLists().filter((list) => !list.unordered);

package/lib/md030.js

@@ -5,19 +5,24 @@
 const { addErrorDetailIf } = require("../helpers");
 const { filterByTypes } = require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD030", "list-marker-space" ],
   "description": "Spaces after list markers",
   "tags": [ "ol", "ul", "whitespace" ],
+  "parser": "micromark",
   "function": function MD030(params, onError) {
     const ulSingle = Number(params.config.ul_single || 1);
     const olSingle = Number(params.config.ol_single || 1);
     const ulMulti = Number(params.config.ul_multi || 1);
     const olMulti = Number(params.config.ol_multi || 1);
-    const lists = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "listOrdered", "listUnordered" ]
-    );
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const lists = filterByTypes(micromarkTokens, [ "listOrdered", "listUnordered" ]);
     for (const list of lists) {
       const ordered = (list.type === "listOrdered");
       const listItemPrefixes =

package/lib/md031.js

@@ -7,10 +7,13 @@ const { lineMetadata } = require("./cache");
 
 const codeFencePrefixRe = /^(.*?)[`~]/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD031", "blanks-around-fences" ],
   "description": "Fenced code blocks should be surrounded by blank lines",
   "tags": [ "code", "blank_lines" ],
+  "parser": "none",
   "function": function MD031(params, onError) {
     const listItems = params.config.list_items;
     const includeListItems = (listItems === undefined) ? true : !!listItems;

package/lib/md032.js

@@ -2,19 +2,9 @@
 
 "use strict";
 
-const { addErrorContext, blockquotePrefixRe, isBlankLine } =
-  require("../helpers");
-const { filterByPredicate } = require("../helpers/micromark.cjs");
+const { addErrorContext, blockquotePrefixRe, isBlankLine } = require("../helpers");
+const { filterByPredicate, nonContentTokens } = require("../helpers/micromark.cjs");
 
-const nonContentTokens = new Set([
-  "blockQuoteMarker",
-  "blockQuotePrefix",
-  "blockQuotePrefixWhitespace",
-  "lineEnding",
-  "lineEndingBlank",
-  "linePrefix",
-  "listItemIndent"
-]);
 const isList = (token) => (
   (token.type === "listOrdered") || (token.type === "listUnordered")
 );
@@ -35,16 +25,24 @@ const addBlankLineError = (onError, lines, lineIndex, lineNumber) => {
   );
 };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD032", "blanks-around-lists" ],
   "description": "Lists should be surrounded by blank lines",
   "tags": [ "bullet", "ul", "ol", "blank_lines" ],
+  "parser": "micromark",
   "function": function MD032(params, onError) {
-    const { lines, parsers } = params;
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const { lines } = params;
 
     // For every top-level list...
     const topLevelLists = filterByPredicate(
-      parsers.micromark.tokens,
+      micromarkTokens,
       isList,
       (token) => (
         (isList(token) || (token.type === "htmlFlow")) ? [] : token.children

package/lib/md033.js

@@ -6,16 +6,23 @@ const { addError, nextLinesRe } = require("../helpers");
 const { filterByTypes, getHtmlTagInfo } =
   require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD033", "no-inline-html" ],
   "description": "Inline HTML",
   "tags": [ "html" ],
+  "parser": "micromark",
   "function": function MD033(params, onError) {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    const { tokens } = params.parsers.micromark;
-    for (const token of filterByTypes(tokens, [ "htmlText" ])) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    for (const token of filterByTypes(micromarkTokens, [ "htmlText" ])) {
       const htmlTagInfo = getHtmlTagInfo(token);
       if (
         htmlTagInfo &&

package/lib/md034.js

@@ -6,15 +6,44 @@ const { addErrorContext } = require("../helpers");
 const { filterByPredicate, filterByTypes, getHtmlTagInfo, inHtmlFlow, parse } =
   require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD034", "no-bare-urls" ],
   "description": "Bare URL used",
   "tags": [ "links", "url" ],
+  "parser": "micromark",
   "function": function MD034(params, onError) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
     const literalAutolinks = (tokens) => (
       filterByPredicate(
         tokens,
-        (token) => (token.type === "literalAutolink") && !inHtmlFlow(token),
+        (token) => {
+          if ((token.type === "literalAutolink") && !inHtmlFlow(token)) {
+            // Detect and ignore https://github.com/micromark/micromark/issues/164
+            const siblings = token.parent?.children;
+              // Commented-out due to not being able to exercise in test/code coverage
+              // || micromarkTokens;
+            const index = siblings?.indexOf(token);
+            // @ts-ignore
+            const prev = siblings?.at(index - 1);
+            // @ts-ignore
+            const next = siblings?.at(index + 1);
+            return !(
+              prev &&
+              next &&
+              (prev.type === "data") &&
+              (next.type === "data") &&
+              prev.text.endsWith("<") &&
+              next.text.startsWith(">")
+            );
+          }
+          return false;
+        },
         (token) => {
           const { children } = token;
           const result = [];
@@ -46,10 +75,7 @@ module.exports = {
         }
       )
     );
-    const autoLinks = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "literalAutolink" ]
-    );
+    const autoLinks = filterByTypes(micromarkTokens, [ "literalAutolink" ]);
     if (autoLinks.length > 0) {
       // Re-parse with correct link/image reference definition handling
       const document = params.lines.join("\n");

package/lib/md035.js

@@ -5,14 +5,21 @@
 const { addErrorDetailIf } = require("../helpers");
 const { filterByTypes } = require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD035", "hr-style" ],
   "description": "Horizontal rule style",
   "tags": [ "hr" ],
+  "parser": "micromark",
   "function": function MD035(params, onError) {
     let style = String(params.config.style || "consistent").trim();
-    const thematicBreaks =
-      filterByTypes(params.parsers.micromark.tokens, [ "thematicBreak" ]);
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const thematicBreaks = filterByTypes(micromarkTokens, [ "thematicBreak" ]);
     for (const token of thematicBreaks) {
       const { startLine, text } = token;
       if (style === "consistent") {

package/lib/md036.js

@@ -3,54 +3,48 @@
 "use strict";
 
 const { addErrorContext, allPunctuation } = require("../helpers");
+const { filterByTypes, matchAndGetTokensByType } = require("../helpers/micromark.cjs");
 
+/** @typedef {import("../helpers/micromark.cjs").TokenType} TokenType */
+/** @type {Map<TokenType, TokenType[]>} */
+const emphasisAndChildrenTypes = new Map([
+  [ "emphasis", [ "emphasisSequence", "emphasisText", "emphasisSequence" ] ],
+  [ "strong", [ "strongSequence", "strongText", "strongSequence" ] ]
+]);
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD036", "no-emphasis-as-heading" ],
   "description": "Emphasis used instead of a heading",
   "tags": [ "headings", "emphasis" ],
+  "parser": "micromark",
   "function": function MD036(params, onError) {
     let punctuation = params.config.punctuation;
-    punctuation =
-      String((punctuation === undefined) ? allPunctuation : punctuation);
-    const re = new RegExp("[" + punctuation + "]$");
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    function base(token) {
-      if (token.type === "paragraph_open") {
-        return function inParagraph(t) {
-          // Always paragraph_open/inline/paragraph_close,
-          const children = t.children.filter(function notEmptyText(child) {
-            return (child.type !== "text") || (child.content !== "");
-          });
-          if ((children.length === 3) &&
-              ((children[0].type === "strong_open") ||
-                (children[0].type === "em_open")) &&
-              (children[1].type === "text") &&
-              !re.test(children[1].content)) {
-            addErrorContext(onError, t.lineNumber,
-              children[1].content);
-          }
-          return base;
-        };
-      } else if (token.type === "blockquote_open") {
-        return function inBlockquote(t) {
-          if (t.type !== "blockquote_close") {
-            return inBlockquote;
+    punctuation = String((punctuation === undefined) ? allPunctuation : punctuation);
+    const punctuationRe = new RegExp("[" + punctuation + "]$");
+    const paragraphTokens =
+      filterByTypes(params.parsers.micromark.tokens, [ "paragraph" ]).
+        filter((token) =>
+          (token.parent?.type === "content") && !token.parent?.parent && (token.children.length === 1)
+        );
+    for (const paragraphToken of paragraphTokens) {
+      const childToken = paragraphToken.children[0];
+      for (const [ emphasisType, emphasisChildrenTypes ] of emphasisAndChildrenTypes) {
+        if (childToken.type === emphasisType) {
+          const matchingTokens = matchAndGetTokensByType(childToken.children, emphasisChildrenTypes);
+          if (matchingTokens) {
+            const textToken = matchingTokens[1];
+            if (
+              (textToken.children.length === 1) &&
+              (textToken.children[0].type === "data") &&
+              !punctuationRe.test(textToken.text)
+            ) {
+              addErrorContext(onError, textToken.startLine, textToken.text);
+            }
           }
-          return base;
-        };
-      } else if (token.type === "list_item_open") {
-        return function inListItem(t) {
-          if (t.type !== "list_item_close") {
-            return inListItem;
-          }
-          return base;
-        };
+        }
       }
-      return base;
-    }
-    let state = base;
-    for (const token of params.parsers.markdownit.tokens) {
-      state = state(token);
     }
   }
 };

package/lib/md037.js

@@ -5,20 +5,28 @@
 const { addError } = require("../helpers");
 const { filterByPredicate, inHtmlFlow } = require("../helpers/micromark.cjs");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD037", "no-space-in-emphasis" ],
   "description": "Spaces inside emphasis markers",
   "tags": [ "whitespace", "emphasis" ],
+  "parser": "micromark",
   "function": function MD037(params, onError) {
 
     // Initialize variables
-    const { lines, parsers } = params;
+    // 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 emphasisTokensByMarker = new Map();
     for (const marker of [ "_", "__", "___", "*", "**", "***" ]) {
       emphasisTokensByMarker.set(marker, []);
     }
     const tokens = filterByPredicate(
-      parsers.micromark.tokens,
+      micromarkTokens,
       (token) => token.children.some((child) => child.type === "data")
     );
     for (const token of tokens) {

package/lib/md038.js

@@ -19,14 +19,21 @@ const trimCodeText = (text, start, end) => {
   return text;
 };
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD038", "no-space-in-code" ],
   "description": "Spaces inside code span elements",
   "tags": [ "whitespace", "code" ],
+  "parser": "micromark",
   "function": function MD038(params, onError) {
-    const codeTexts =
-      filterByTypes(params.parsers.micromark.tokens, [ "codeText" ])
-        .filter((codeText) => !inHtmlFlow(codeText));
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const codeTexts = filterByTypes(micromarkTokens, [ "codeText" ])
+      .filter((codeText) => !inHtmlFlow(codeText));
     for (const codeText of codeTexts) {
       const { children } = codeText;
       const first = 0;

package/lib/md039.js

@@ -7,10 +7,13 @@ const { addErrorContext, filterTokens } = require("../helpers");
 const spaceInLinkRe =
   /\[(?:\s[^\]]*|[^\]]*?\s)\](?=(\([^)]*\)|\[[^\]]*\]))/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD039", "no-space-in-links" ],
   "description": "Spaces inside link text",
   "tags": [ "whitespace", "links" ],
+  "parser": "markdownit",
   "function": function MD039(params, onError) {
     filterTokens(params, "inline", (token) => {
       const { children } = token;
@@ -33,6 +36,7 @@ module.exports = {
             let fixInfo = null;
             const match = line.slice(lineIndex).match(spaceInLinkRe);
             if (match) {
+              // @ts-ignore
               const column = match.index + lineIndex + 1;
               const length = match[0].length;
               range = [ column, length ];