markdownlint 0.27.0 → 0.28.1

package/lib/md033.js

@@ -2,17 +2,11 @@
 
 "use strict";
 
-const {
-  addError, forEachLine, htmlElementRe, withinAnyRange, unescapeMarkdown
-} = require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata, referenceLinkImageData } =
-  require("./cache");
+const { addError } = require("../helpers");
+const { filterByTypes, getHtmlTagInfo, parse } =
+  require("../helpers/micromark.cjs");
 
-const linkDestinationRe = /\]\(\s*$/;
-// See https://spec.commonmark.org/0.29/#autolinks
-const emailAddressRe =
-  // eslint-disable-next-line max-len
-  /^[\w.!#$%&'*+/=?^`{|}~-]+@[a-zA-Z\d](?:[a-zA-Z\d-]{0,61}[a-zA-Z\d])?(?:\.[a-zA-Z\d](?:[a-zA-Z\d-]{0,61}[a-zA-Z\d])?)*$/;
+const nextLinesRe = /[\r\n][\s\S]*$/;
 
 module.exports = {
   "names": [ "MD033", "no-inline-html" ],
@@ -22,38 +16,51 @@ module.exports = {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    const exclusions = codeBlockAndSpanRanges();
-    const { references, definitionLineIndices } = referenceLinkImageData();
-    for (const datas of references.values()) {
-      for (const data of datas) {
-        const [ lineIndex, index, , textLength, labelLength ] = data;
-        if (labelLength > 0) {
-          exclusions.push([ lineIndex, index + 3 + textLength, labelLength ]);
-        }
-      }
-    }
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      let match = null;
-      // eslint-disable-next-line no-unmodified-loop-condition
-      while (!inCode && ((match = htmlElementRe.exec(line)) !== null)) {
-        const [ tag, content, element ] = match;
-        if (
-          !allowedElements.includes(element.toLowerCase()) &&
-          !tag.endsWith("\\>") &&
-          !emailAddressRe.test(content) &&
-          !withinAnyRange(exclusions, lineIndex, match.index, tag.length) &&
-          !definitionLineIndices.includes(lineIndex)
-        ) {
-          const prefix = line.substring(0, match.index);
-          if (!linkDestinationRe.test(prefix)) {
-            const unescaped = unescapeMarkdown(prefix + "<", "_");
-            if (!unescaped.endsWith("_")) {
-              addError(onError, lineIndex + 1, "Element: " + element,
-                undefined, [ match.index + 1, tag.length ]);
-            }
+    const pending = [ [ 0, params.parsers.micromark.tokens ] ];
+    let current = null;
+    while ((current = pending.shift())) {
+      const [ offset, tokens ] = current;
+      for (const token of filterByTypes(tokens, [ "htmlFlow", "htmlText" ])) {
+        if (token.type === "htmlText") {
+          const htmlTagInfo = getHtmlTagInfo(token);
+          if (
+            htmlTagInfo &&
+            !htmlTagInfo.close &&
+            !allowedElements.includes(htmlTagInfo.name.toLowerCase())
+          ) {
+            const range = [
+              token.startColumn,
+              token.text.replace(nextLinesRe, "").length
+            ];
+            addError(
+              onError,
+              token.startLine + offset,
+              "Element: " + htmlTagInfo.name,
+              undefined,
+              range
+            );
           }
+        } else {
+          // token.type === "htmlFlow"
+          // Re-parse without "htmlFlow" to get only "htmlText" tokens
+          const options = {
+            "extensions": [
+              {
+                "disable": {
+                  "null": [ "codeIndented", "htmlFlow" ]
+                }
+              }
+            ]
+          };
+          // Use lines instead of token.text for accurate columns
+          const lines =
+            params.lines.slice(token.startLine - 1, token.endLine).join("\n");
+          const flowTokens = parse(lines, options);
+          pending.push(
+            [ token.startLine - 1, flowTokens ]
+          );
         }
       }
-    });
+    }
   }
 };

package/lib/md034.js

@@ -2,85 +2,67 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens, funcExpExec, urlFe, withinAnyRange } =
-  require("../helpers");
-const { codeBlockAndSpanRanges, htmlElementRanges, referenceLinkImageData } =
-  require("./cache");
-
-const htmlLinkRe = /<a(?:\s[^>]*)?>[^<>]*<\/a\s*>/gi;
+const { addErrorContext } = require("../helpers");
+const { filterByPredicate, getHtmlTagInfo } =
+  require("../helpers/micromark.cjs");
 
 module.exports = {
   "names": [ "MD034", "no-bare-urls" ],
   "description": "Bare URL used",
   "tags": [ "links", "url" ],
   "function": function MD034(params, onError) {
-    const { lines } = params;
-    const codeExclusions = [
-      ...codeBlockAndSpanRanges(),
-      ...htmlElementRanges()
-    ];
-    filterTokens(params, "html_block", (token) => {
-      for (let i = token.map[0]; i < token.map[1]; i++) {
-        codeExclusions.push([ i, 0, lines[i].length ]);
-      }
-    });
-    const { definitionLineIndices } = referenceLinkImageData();
-    for (const [ lineIndex, line ] of lines.entries()) {
-      if (definitionLineIndices[0] === lineIndex) {
-        definitionLineIndices.shift();
-      } else {
-        let match = null;
-        const lineExclusions = [];
-        while ((match = htmlLinkRe.exec(line)) !== null) {
-          lineExclusions.push([ lineIndex, match.index, match[0].length ]);
-        }
-        while ((match = funcExpExec(urlFe, line)) !== null) {
-          const [ bareUrl ] = match;
-          // @ts-ignore
-          const matchIndex = match.index;
-          const bareUrlLength = bareUrl.length;
-          const prefix = line.slice(0, matchIndex);
-          const postfix = line.slice(matchIndex + bareUrlLength);
-          if (
-            // Allow <...> to avoid reporting non-bare links
-            !(prefix.endsWith("<") && postfix.startsWith(">")) &&
-            // Allow >...</ to avoid reporting <code>...</code>
-            !(prefix.endsWith(">") && postfix.startsWith("</")) &&
-            // Allow "..." and '...' to allow quoting a bare link
-            !(prefix.endsWith("\"") && postfix.startsWith("\"")) &&
-            !(prefix.endsWith("'") && postfix.startsWith("'")) &&
-            // Allow ](... to avoid reporting Markdown-style links
-            !(/\]\(\s*$/.test(prefix)) &&
-            // Allow [...] to avoid MD011/no-reversed-links and nested links
-            !(/\[[^\]]*$/.test(prefix) && /^[^[]*\]/.test(postfix)) &&
-            !withinAnyRange(
-              lineExclusions, lineIndex, matchIndex, bareUrlLength
-            ) &&
-            !withinAnyRange(
-              codeExclusions, lineIndex, matchIndex, bareUrlLength
-            )
-          ) {
-            const range = [
-              matchIndex + 1,
-              bareUrlLength
-            ];
-            const fixInfo = {
-              "editColumn": range[0],
-              "deleteCount": range[1],
-              "insertText": `<${bareUrl}>`
-            };
-            addErrorContext(
-              onError,
-              lineIndex + 1,
-              bareUrl,
-              null,
-              null,
-              range,
-              fixInfo
-            );
+    const literalAutolinks =
+      filterByPredicate(
+        params.parsers.micromark.tokens,
+        (token) => token.type === "literalAutolink",
+        (token) => {
+          const { children } = token;
+          const result = [];
+          for (let i = 0; i < children.length; i++) {
+            const openToken = children[i];
+            const openTagInfo = getHtmlTagInfo(openToken);
+            if (openTagInfo && !openTagInfo.close) {
+              let count = 1;
+              for (let j = i + 1; j < children.length; j++) {
+                const closeToken = children[j];
+                const closeTagInfo = getHtmlTagInfo(closeToken);
+                if (closeTagInfo && (openTagInfo.name === closeTagInfo.name)) {
+                  if (closeTagInfo.close) {
+                    count--;
+                    if (count === 0) {
+                      i = j;
+                      break;
+                    }
+                  } else {
+                    count++;
+                  }
+                }
+              }
+            } else {
+              result.push(openToken);
+            }
           }
-        }
-      }
+          return result;
+        });
+    for (const token of literalAutolinks) {
+      const range = [
+        token.startColumn,
+        token.endColumn - token.startColumn
+      ];
+      const fixInfo = {
+        "editColumn": range[0],
+        "deleteCount": range[1],
+        "insertText": `<${token.text}>`
+      };
+      addErrorContext(
+        onError,
+        token.startLine,
+        token.text,
+        null,
+        null,
+        range,
+        fixInfo
+      );
     }
   }
 };

package/lib/md035.js

@@ -2,7 +2,8 @@
 
 "use strict";
 
-const { addErrorDetailIf, filterTokens } = require("../helpers");
+const { addErrorDetailIf } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
 
 module.exports = {
   "names": [ "MD035", "hr-style" ],
@@ -10,17 +11,14 @@ module.exports = {
   "tags": [ "hr" ],
   "function": function MD035(params, onError) {
     let style = String(params.config.style || "consistent").trim();
-    filterTokens(params, "hr", (token) => {
-      const { line, lineNumber } = token;
-      let { markup } = token;
-      const match = line.match(/[_*\-\s]+$/);
-      if (match) {
-        markup = match[0].trim();
-      }
+    const thematicBreaks =
+      filterByTypes(params.parsers.micromark.tokens, [ "thematicBreak" ]);
+    for (const token of thematicBreaks) {
+      const { startLine, text } = token;
       if (style === "consistent") {
-        style = markup;
+        style = text;
       }
-      addErrorDetailIf(onError, lineNumber, style, markup);
-    });
+      addErrorDetailIf(onError, startLine, style, text);
+    }
   }
 };

package/lib/md036.js

@@ -49,7 +49,7 @@ module.exports = {
       return base;
     }
     let state = base;
-    for (const token of params.tokens) {
+    for (const token of params.parsers.markdownit.tokens) {
       state = state(token);
     }
   }

package/lib/md038.js

@@ -2,70 +2,95 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens, forEachInlineCodeSpan, newLineRe } =
-  require("../helpers");
+const { addErrorContext } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
 
 const leftSpaceRe = /^\s(?:[^`]|$)/;
 const rightSpaceRe = /[^`]\s$/;
-
-const spaceInsideCodeInline = (token) => (
-  (token.type === "code_inline") &&
-  (leftSpaceRe.test(token.content) || rightSpaceRe.test(token.content))
-);
+const trimCodeText = (text, start, end) => {
+  text = text.replace(/^\s+$/, "");
+  if (start) {
+    text = text.replace(/^\s+?(\s`|\S)/, "$1");
+  }
+  if (end) {
+    text = text.replace(/(`\s|\S)\s+$/, "$1");
+  }
+  return text;
+};
+const tokenIfType = (token, type) => token && (token.type === type) && token;
 
 module.exports = {
   "names": [ "MD038", "no-space-in-code" ],
   "description": "Spaces inside code span elements",
   "tags": [ "whitespace", "code" ],
   "function": function MD038(params, onError) {
-    filterTokens(params, "inline", (token) => {
-      if (token.children.some(spaceInsideCodeInline)) {
-        const tokenLines = params.lines.slice(token.map[0], token.map[1]);
-        forEachInlineCodeSpan(
-          tokenLines.join("\n"),
-          (code, lineIndex, columnIndex, tickCount) => {
-            let rangeIndex = columnIndex - tickCount;
-            let rangeLength = code.length + (2 * tickCount);
-            let rangeLineOffset = 0;
-            let fixIndex = columnIndex;
-            let fixLength = code.length;
-            const codeLines = code.split(newLineRe);
-            const left = leftSpaceRe.test(code);
-            const right = !left && rightSpaceRe.test(code);
-            if (right && (codeLines.length > 1)) {
-              rangeIndex = 0;
-              rangeLineOffset = codeLines.length - 1;
-              fixIndex = 0;
-            }
-            if (left || right) {
-              const codeLinesRange = codeLines[rangeLineOffset];
-              if (codeLines.length > 1) {
-                rangeLength = codeLinesRange.length + tickCount;
-                fixLength = codeLinesRange.length;
-              }
-              const context = tokenLines[lineIndex + rangeLineOffset]
-                .substring(rangeIndex, rangeIndex + rangeLength);
-              const codeLinesRangeTrim = codeLinesRange.trim();
-              const fixText =
-                (codeLinesRangeTrim.startsWith("`") ? " " : "") +
-                codeLinesRangeTrim +
-                (codeLinesRangeTrim.endsWith("`") ? " " : "");
-              addErrorContext(
-                onError,
-                token.lineNumber + lineIndex + rangeLineOffset,
-                context,
-                left,
-                right,
-                [ rangeIndex + 1, rangeLength ],
-                {
-                  "editColumn": fixIndex + 1,
-                  "deleteCount": fixLength,
-                  "insertText": fixText
-                }
-              );
-            }
-          });
+    const codeTextTokens =
+      filterByTypes(params.parsers.micromark.tokens, [ "codeText" ]);
+    for (const token of codeTextTokens) {
+      const { children } = token;
+      const first = 0;
+      const last = children.length - 1;
+      const startSequence = tokenIfType(children[first], "codeTextSequence");
+      const endSequence = tokenIfType(children[last], "codeTextSequence");
+      const startData =
+        tokenIfType(children[first + 1], "codeTextData") ||
+        tokenIfType(children[first + 2], "codeTextData");
+      const endData =
+        tokenIfType(children[last - 1], "codeTextData") ||
+        tokenIfType(children[last - 2], "codeTextData");
+      if (startSequence && endSequence && startData && endData) {
+        const spaceLeft = leftSpaceRe.test(startData.text);
+        const spaceRight = !spaceLeft && rightSpaceRe.test(endData.text);
+        if (spaceLeft || spaceRight) {
+          let lineNumber = startSequence.startLine;
+          let range = null;
+          let fixInfo = null;
+          if (startSequence.startLine === endSequence.endLine) {
+            range = [
+              startSequence.startColumn,
+              endSequence.endColumn - startSequence.startColumn
+            ];
+            fixInfo = {
+              "editColumn": startSequence.endColumn,
+              "deleteCount": endSequence.startColumn - startSequence.endColumn,
+              "insertText": trimCodeText(startData.text, true, true)
+            };
+          } else if (spaceLeft) {
+            range = [
+              startSequence.startColumn,
+              startData.endColumn - startSequence.startColumn
+            ];
+            fixInfo = {
+              "editColumn": startSequence.endColumn,
+              "deleteCount": startData.endColumn - startData.startColumn,
+              "insertText": trimCodeText(startData.text, true, false)
+            };
+          } else {
+            lineNumber = endSequence.endLine;
+            range = [
+              endData.startColumn,
+              endSequence.endColumn - endData.startColumn
+            ];
+            fixInfo = {
+              "editColumn": endData.startColumn,
+              "deleteCount": endData.endColumn - endData.startColumn,
+              "insertText": trimCodeText(endData.text, false, true)
+            };
+          }
+          const context = params
+            .lines[lineNumber - 1]
+            .substring(range[0] - 1, range[0] - 1 + range[1]);
+          addErrorContext(
+            onError,
+            lineNumber,
+            context,
+            spaceLeft,
+            spaceRight,
+            range,
+            fixInfo
+          );
+        }
       }
-    });
+    }
   }
 };

package/lib/md041.js

@@ -18,7 +18,7 @@ module.exports = {
       );
     if (!foundFrontMatterTitle) {
       const htmlHeadingRe = new RegExp(`^<h${level}[ />]`, "i");
-      params.tokens.every((token) => {
+      params.parsers.markdownit.tokens.every((token) => {
         let isError = false;
         if (token.type === "html_block") {
           if (token.content.startsWith("<!--")) {

package/lib/md044.js

@@ -2,11 +2,14 @@
 
 "use strict";
 
-const { addErrorDetailIf, escapeForRegExp, forEachLine, forEachLink,
-  funcExpExec, linkReferenceDefinitionRe, urlFe, withinAnyRange } =
+const { addErrorDetailIf, escapeForRegExp, withinAnyRange } =
   require("../helpers");
-const { codeBlockAndSpanRanges, htmlElementRanges, lineMetadata } =
-  require("./cache");
+const { filterByPredicate, filterByTypes, parse } =
+  require("../helpers/micromark.cjs");
+
+const ignoredChildTypes = new Set(
+  [ "codeFencedFence", "definition", "reference", "resource" ]
+);
 
 module.exports = {
   "names": [ "MD044", "proper-names" ],
@@ -22,31 +25,25 @@ module.exports = {
     const htmlElements = params.config.html_elements;
     const includeHtmlElements =
       (htmlElements === undefined) ? true : !!htmlElements;
-    const exclusions = [];
-    forEachLine(lineMetadata(), (line, lineIndex) => {
-      if (linkReferenceDefinitionRe.test(line)) {
-        exclusions.push([ lineIndex, 0, line.length ]);
-      } else {
-        let match = null;
-        while ((match = funcExpExec(urlFe, line)) !== null) {
-          // @ts-ignore
-          exclusions.push([ lineIndex, match.index, match[0].length ]);
-        }
-        forEachLink(line, (index, _, text, destination) => {
-          if (destination) {
-            exclusions.push(
-              [ lineIndex, index + text.length, destination.length ]
-            );
-          }
-        });
-      }
-    });
-    if (!includeCodeBlocks) {
-      exclusions.push(...codeBlockAndSpanRanges());
-    }
-    if (!includeHtmlElements) {
-      exclusions.push(...htmlElementRanges());
+    const scannedTypes = new Set([ "data", "htmlFlowData" ]);
+    if (includeCodeBlocks) {
+      scannedTypes.add("codeFlowValue");
+      scannedTypes.add("codeTextData");
     }
+    const contentTokens =
+      filterByPredicate(
+        params.parsers.micromark.tokens,
+        (token) => scannedTypes.has(token.type),
+        (token) => {
+          let { children } = token;
+          if (!includeHtmlElements && (token.type === "htmlFlow")) {
+            children = children.slice(1, -1);
+          }
+          return children.filter((t) => !ignoredChildTypes.has(t.type));
+        }
+      );
+    const exclusions = [];
+    const autoLinked = new Set();
     for (const name of names) {
       const escapedName = escapeForRegExp(name);
       const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
@@ -54,36 +51,53 @@ module.exports = {
       const namePattern =
         `(${startNamePattern})(${escapedName})${endNamePattern}`;
       const nameRe = new RegExp(namePattern, "gi");
-      forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
-        if (includeCodeBlocks || (!inCode && !onFence)) {
-          let match = null;
-          while ((match = nameRe.exec(line)) !== null) {
-            const [ , leftMatch, nameMatch ] = match;
-            const index = match.index + leftMatch.length;
-            const length = nameMatch.length;
-            if (
-              !withinAnyRange(exclusions, lineIndex, index, length) &&
-              !names.includes(nameMatch)
-            ) {
+      for (const token of contentTokens) {
+        let match = null;
+        while ((match = nameRe.exec(token.text)) !== null) {
+          const [ , leftMatch, nameMatch ] = match;
+          const index = token.startColumn - 1 + match.index + leftMatch.length;
+          const length = nameMatch.length;
+          const lineIndex = token.startLine - 1;
+          if (
+            !withinAnyRange(exclusions, lineIndex, index, length) &&
+            !names.includes(nameMatch)
+          ) {
+            let urlRanges = [];
+            if (!autoLinked.has(token)) {
+              urlRanges = filterByTypes(
+                parse(token.text),
+                [ "literalAutolink" ]
+              ).map(
+                (t) => [
+                  lineIndex,
+                  token.startColumn - 1 + t.startColumn - 1,
+                  t.endColumn - t.startColumn
+                ]
+              );
+              exclusions.push(...urlRanges);
+              autoLinked.add(token);
+            }
+            if (!withinAnyRange(urlRanges, lineIndex, index, length)) {
+              const column = index + 1;
               addErrorDetailIf(
                 onError,
-                lineIndex + 1,
+                token.startLine,
                 name,
                 nameMatch,
                 null,
                 null,
-                [ index + 1, length ],
+                [ column, length ],
                 {
-                  "editColumn": index + 1,
+                  "editColumn": column,
                   "deleteCount": length,
                   "insertText": name
                 }
               );
             }
-            exclusions.push([ lineIndex, index, length ]);
           }
+          exclusions.push([ lineIndex, index, length ]);
         }
-      });
+      }
     }
   }
 };

package/lib/md046.js

@@ -15,7 +15,7 @@ module.exports = {
   "tags": [ "code" ],
   "function": function MD046(params, onError) {
     let expectedStyle = String(params.config.style || "consistent");
-    const codeBlocksAndFences = params.tokens.filter(
+    const codeBlocksAndFences = params.parsers.markdownit.tokens.filter(
       (token) => (token.type === "code_block") || (token.type === "fence")
     );
     for (const token of codeBlocksAndFences) {

package/lib/md048.js

@@ -11,7 +11,9 @@ module.exports = {
   "function": function MD048(params, onError) {
     const style = String(params.config.style || "consistent");
     let expectedStyle = style;
-    const fenceTokens = params.tokens.filter((token) => token.type === "fence");
+    const fenceTokens = params.parsers.markdownit.tokens.filter(
+      (token) => token.type === "fence"
+    );
     for (const fenceToken of fenceTokens) {
       const { lineNumber, markup } = fenceToken;
       if (expectedStyle === "consistent") {