markdownlint 0.26.2 → 0.28.0

package/lib/md033.js

@@ -2,16 +2,11 @@
 
 "use strict";
 
-const {
-  addError, forEachLine, htmlElementRe, withinAnyRange, unescapeMarkdown
-} = require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = 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
-  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+const nextLinesRe = /[\r\n][\s\S]*$/;
 
 module.exports = {
   "names": [ "MD033", "no-inline-html" ],
@@ -21,28 +16,51 @@ module.exports = {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    const exclusions = codeBlockAndSpanRanges();
-    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, match[0].length)
-        ) {
-          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,60 +2,67 @@
 
 "use strict";
 
-const { addErrorContext, bareUrlRe, filterTokens } = require("../helpers");
+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) {
-    filterTokens(params, "inline", (token) => {
-      let inLink = false;
-      for (const child of token.children) {
-        const { content, line, lineNumber, type } = child;
-        let match = null;
-        if (type === "link_open") {
-          inLink = true;
-        } else if (type === "link_close") {
-          inLink = false;
-        } else if ((type === "text") && !inLink) {
-          while ((match = bareUrlRe.exec(content)) !== null) {
-            const [ bareUrl ] = match;
-            const matchIndex = match.index;
-            const bareUrlLength = bareUrl.length;
-            // Allow "[https://example.com]" to avoid conflicts with
-            // MD011/no-reversed-links; allow quoting as another way
-            // of deliberately including a bare URL
-            const leftChar = content[matchIndex - 1];
-            const rightChar = content[matchIndex + bareUrlLength];
-            if (
-              !((leftChar === "[") && (rightChar === "]")) &&
-              !((leftChar === "\"") && (rightChar === "\"")) &&
-              !((leftChar === "'") && (rightChar === "'"))
-            ) {
-              const index = line.indexOf(content);
-              const range = (index === -1) ? null : [
-                index + matchIndex + 1,
-                bareUrlLength
-              ];
-              const fixInfo = range ? {
-                "editColumn": range[0],
-                "deleteCount": range[1],
-                "insertText": `<${bareUrl}>`
-              } : null;
-              addErrorContext(
-                onError,
-                lineNumber,
-                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\t]+$/);
-      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/md037.js

@@ -6,8 +6,8 @@ const { addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine,
   withinAnyRange } = require("../helpers");
 const { htmlElementRanges, lineMetadata } = require("./cache");
 
-const emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
-const embeddedUnderscoreRe = /([A-Za-z0-9])_([A-Za-z0-9])/g;
+const emphasisRe = /(^|[^\\]|\\\\)(?:(\*{1,3})|(_{1,3}))/g;
+const embeddedUnderscoreRe = /([A-Za-z\d])_([A-Za-z\d])/g;
 const asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
 const leftSpaceRe = /^\s+/;
 const rightSpaceRe = /\s+$/;

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 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/md039.js

@@ -5,7 +5,7 @@
 const { addErrorContext, filterTokens } = require("../helpers");
 
 const spaceInLinkRe =
-  /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=((?:\([^)]*\))|(?:\[[^\]]*\])))/;
+  /\[(?:\s[^\]]*|[^\]]*?\s)\](?=(\([^)]*\)|\[[^\]]*\]))/;
 
 module.exports = {
   "names": [ "MD039", "no-space-in-links" ],

package/lib/md040.js

@@ -2,16 +2,35 @@
 
 "use strict";
 
-const { addErrorContext, filterTokens } = require("../helpers");
+const { addError, addErrorContext, filterTokens } = require("../helpers");
 
 module.exports = {
   "names": [ "MD040", "fenced-code-language" ],
   "description": "Fenced code blocks should have a language specified",
   "tags": [ "code", "language" ],
   "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) {
-      if (!token.info.trim()) {
+      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}"`
+        );
       }
     });
   }

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/md043.js

@@ -11,6 +11,7 @@ module.exports = {
   "tags": [ "headings", "headers" ],
   "function": function MD043(params, onError) {
     const requiredHeadings = params.config.headings || params.config.headers;
+    const matchCase = params.config.match_case || false;
     if (Array.isArray(requiredHeadings)) {
       const levels = {};
       for (const level of [ 1, 2, 3, 4, 5, 6 ]) {
@@ -21,6 +22,7 @@ module.exports = {
       let hasError = false;
       let anyHeadings = false;
       const getExpected = () => requiredHeadings[i++] || "[None]";
+      const handleCase = (str) => (matchCase ? str : str.toLowerCase());
       forEachHeading(params, (heading, content) => {
         if (!hasError) {
           anyHeadings = true;
@@ -28,13 +30,13 @@ module.exports = {
           const expected = getExpected();
           if (expected === "*") {
             const nextExpected = getExpected();
-            if (nextExpected.toLowerCase() !== actual.toLowerCase()) {
+            if (handleCase(nextExpected) !== handleCase(actual)) {
               matchAny = true;
               i--;
             }
           } else if (expected === "+") {
             matchAny = true;
-          } else if (expected.toLowerCase() === actual.toLowerCase()) {
+          } else if (handleCase(expected) === handleCase(actual)) {
             matchAny = false;
           } else if (matchAny) {
             i--;

package/lib/md044.js

@@ -2,11 +2,14 @@
 
 "use strict";
 
-const { addErrorDetailIf, bareUrlRe, escapeForRegExp, forEachLine,
-  forEachLink, withinAnyRange, linkReferenceDefinitionRe } =
+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,30 +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 = bareUrlRe.exec(line)) !== null) {
-          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_*";
@@ -53,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 ]);
         }
-      });
+      }
     }
   }
 };