markdownlint 0.23.0 → 0.25.1

package/lib/md007.js

@@ -13,12 +13,14 @@ module.exports = {
   "function": function MD007(params, onError) {
     const indent = Number(params.config.indent || 2);
     const startIndented = !!params.config.start_indented;
+    const startIndent = Number(params.config.start_indent || indent);
     flattenedLists().forEach((list) => {
       if (list.unordered && list.parentsUnordered) {
         list.items.forEach((item) => {
           const { lineNumber, line } = item;
-          const expectedNesting = list.nesting + (startIndented ? 1 : 0);
-          const expectedIndent = expectedNesting * indent;
+          const expectedIndent =
+            (startIndented ? startIndent : 0) +
+            (list.nesting * indent);
           const actualIndent = indentFor(item);
           let range = null;
           let editColumn = 1;

package/lib/md010.js

@@ -2,8 +2,8 @@
 
 "use strict";
 
-const { addError, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addError, forEachLine, overlapsAnyRange } = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 
 const tabRe = /\t+/g;
 
@@ -13,24 +13,33 @@ module.exports = {
   "tags": [ "whitespace", "hard_tab" ],
   "function": function MD010(params, onError) {
     const codeBlocks = params.config.code_blocks;
-    const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
+    const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
+    const spacesPerTab = params.config.spaces_per_tab;
+    const spaceMultiplier = (spacesPerTab === undefined) ?
+      1 :
+      Math.max(0, Number(spacesPerTab));
+    const exclusions = includeCode ? [] : codeBlockAndSpanRanges();
     forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      if (!inCode || includeCodeBlocks) {
+      if (includeCode || !inCode) {
         let match = null;
         while ((match = tabRe.exec(line)) !== null) {
-          const column = match.index + 1;
+          const { index } = match;
+          const column = index + 1;
           const length = match[0].length;
-          addError(
-            onError,
-            lineIndex + 1,
-            "Column: " + column,
-            null,
-            [ column, length ],
-            {
-              "editColumn": column,
-              "deleteCount": length,
-              "insertText": "".padEnd(length)
-            });
+          if (!overlapsAnyRange(exclusions, lineIndex, index, length)) {
+            addError(
+              onError,
+              lineIndex + 1,
+              "Column: " + column,
+              null,
+              [ column, length ],
+              {
+                "editColumn": column,
+                "deleteCount": length,
+                "insertText": "".padEnd(length * spaceMultiplier)
+              }
+            );
+          }
         }
       }
     });

package/lib/md011.js

@@ -2,40 +2,44 @@
 
 "use strict";
 
-const { addError, forEachInlineChild, unescapeMarkdown } =
-  require("../helpers");
+const { addError, forEachLine, overlapsAnyRange } = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 
-const reversedLinkRe = /\(([^)]+)\)\[([^\]^][^\]]*)]/g;
+const reversedLinkRe =
+  /(^|[^\\])\(([^)]+)\)\[([^\]^][^\]]*)](?!\()/g;
 
 module.exports = {
   "names": [ "MD011", "no-reversed-links" ],
   "description": "Reversed link syntax",
   "tags": [ "links" ],
   "function": function MD011(params, onError) {
-    forEachInlineChild(params, "text", (token) => {
-      const { lineNumber, content } = token;
-      let match = null;
-      while ((match = reversedLinkRe.exec(content)) !== null) {
-        const [ reversedLink, linkText, linkDestination ] = match;
-        const line = params.lines[lineNumber - 1];
-        const column = unescapeMarkdown(line).indexOf(reversedLink) + 1;
-        const length = reversedLink.length;
-        const range = column ? [ column, length ] : null;
-        const fixInfo = column ?
-          {
-            "editColumn": column,
-            "deleteCount": length,
-            "insertText": `[${linkText}](${linkDestination})`
-          } :
-          null;
-        addError(
-          onError,
-          lineNumber,
-          reversedLink,
-          null,
-          range,
-          fixInfo
-        );
+    const exclusions = codeBlockAndSpanRanges();
+    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
+      if (!inCode && !onFence) {
+        let match = null;
+        while ((match = reversedLinkRe.exec(line)) !== null) {
+          const [ reversedLink, preChar, linkText, linkDestination ] = match;
+          const index = match.index + preChar.length;
+          const length = match[0].length - preChar.length;
+          if (
+            !linkText.endsWith("\\") &&
+            !linkDestination.endsWith("\\") &&
+            !overlapsAnyRange(exclusions, lineIndex, index, length)
+          ) {
+            addError(
+              onError,
+              lineIndex + 1,
+              reversedLink.slice(preChar.length),
+              null,
+              [ index + 1, length ],
+              {
+                "editColumn": index + 1,
+                "deleteCount": length,
+                "insertText": `[${linkText}](${linkDestination})`
+              }
+            );
+          }
+        }
       }
     });
   }

package/lib/md033.js

@@ -2,12 +2,13 @@
 
 "use strict";
 
-const { addError, forEachLine, unescapeMarkdown } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const {
+  addError, forEachLine, overlapsAnyRange, unescapeMarkdown
+} = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 
 const htmlElementRe = /<(([A-Za-z][A-Za-z0-9-]*)(?:\s[^>]*)?)\/?>/g;
 const linkDestinationRe = /]\(\s*$/;
-const inlineCodeRe = /^[^`]*(`+[^`]+`+[^`]+)*`+[^`]*$/;
 // See https://spec.commonmark.org/0.29/#autolinks
 const emailAddressRe =
   // eslint-disable-next-line max-len
@@ -21,19 +22,22 @@ 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()) &&
+        if (
+          !allowedElements.includes(element.toLowerCase()) &&
           !tag.endsWith("\\>") &&
-          !emailAddressRe.test(content)) {
+          !emailAddressRe.test(content) &&
+          !overlapsAnyRange(exclusions, lineIndex, match.index, match[0].length)
+        ) {
           const prefix = line.substring(0, match.index);
-          if (!linkDestinationRe.test(prefix) && !inlineCodeRe.test(prefix)) {
+          if (!linkDestinationRe.test(prefix)) {
             const unescaped = unescapeMarkdown(prefix + "<", "_");
-            if (!unescaped.endsWith("_") &&
-              ((unescaped + "`").match(/`/g).length % 2)) {
+            if (!unescaped.endsWith("_")) {
               addError(onError, lineIndex + 1, "Element: " + element,
                 null, [ match.index + 1, tag.length ]);
             }

package/lib/md035.js

@@ -10,12 +10,12 @@ module.exports = {
   "tags": [ "hr" ],
   "function": function MD035(params, onError) {
     let style = String(params.config.style || "consistent");
-    filterTokens(params, "hr", function forToken(token) {
-      const lineTrim = token.line.trim();
+    filterTokens(params, "hr", (token) => {
+      const { lineNumber, markup } = token;
       if (style === "consistent") {
-        style = lineTrim;
+        style = markup;
       }
-      addErrorDetailIf(onError, token.lineNumber, style, lineTrim);
+      addErrorDetailIf(onError, lineNumber, style, markup);
     });
   }
 };

package/lib/md037.js

@@ -7,6 +7,7 @@ const { addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine } =
 const { lineMetadata } = require("./cache");
 
 const emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
+const embeddedUnderscoreRe = /([A-Za-z0-9])_([A-Za-z0-9])/g;
 const asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
 const leftSpaceRe = /^\s+/;
 const rightSpaceRe = /\s+$/;
@@ -78,22 +79,35 @@ module.exports = {
       lineMetadata(),
       (line, lineIndex, inCode, onFence, inTable, inItem, onBreak, inMath) => {
         const onItemStart = (inItem === 1);
-        if (inCode || inTable || onBreak || onItemStart || isBlankLine(line)) {
+        if (
+          inCode ||
+          onFence ||
+          inTable ||
+          onBreak ||
+          onItemStart ||
+          isBlankLine(line)
+        ) {
           // Emphasis resets when leaving a block
           resetRunTracking();
         }
-        if (inCode || onBreak || inMath) {
+        if (
+          inCode ||
+          onFence ||
+          onBreak ||
+          inMath
+        ) {
           // Emphasis has no meaning here
           return;
         }
+        let patchedLine = line.replace(embeddedUnderscoreRe, "$1 $2");
         if (onItemStart) {
           // Trim overlapping '*' list item marker
-          line = line.replace(asteriskListItemMarkerRe, "$1 $2");
+          patchedLine = patchedLine.replace(asteriskListItemMarkerRe, "$1 $2");
         }
         let match = null;
         // Match all emphasis-looking runs in the line...
-        while ((match = emphasisRe.exec(line))) {
-          const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex] || [];
+        while ((match = emphasisRe.exec(patchedLine))) {
+          const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex];
           const matchIndex = match.index + match[1].length;
           if (ignoreMarkersForLine.includes(matchIndex)) {
             // Ignore emphasis markers inside code spans and links

package/lib/md039.js

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

package/lib/md043.js

@@ -20,7 +20,6 @@ module.exports = {
       let matchAny = false;
       let hasError = false;
       let anyHeadings = false;
-      // eslint-disable-next-line func-style
       const getExpected = () => requiredHeadings[i++] || "[None]";
       forEachHeading(params, (heading, content) => {
         if (!hasError) {
@@ -28,8 +27,11 @@ module.exports = {
           const actual = levels[heading.tag] + " " + content;
           const expected = getExpected();
           if (expected === "*") {
-            matchAny = true;
-            getExpected();
+            const nextExpected = getExpected();
+            if (nextExpected.toLowerCase() !== actual.toLowerCase()) {
+              matchAny = true;
+              i--;
+            }
           } else if (expected === "+") {
             matchAny = true;
           } else if (expected.toLowerCase() === actual.toLowerCase()) {
@@ -43,9 +45,11 @@ module.exports = {
           }
         }
       });
+      const extraHeadings = requiredHeadings.length - i;
       if (
         !hasError &&
-        (i < requiredHeadings.length) &&
+        ((extraHeadings > 1) ||
+          ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
         (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
       ) {
         addErrorContext(onError, params.lines.length,

package/lib/md044.js

@@ -2,11 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, bareUrlRe, escapeForRegExp, filterTokens,
-  forEachInlineChild, newLineRe } = require("../helpers");
-
-const startNonWordRe = /^\W/;
-const endNonWordRe = /\W$/;
+const { addErrorDetailIf, bareUrlRe, escapeForRegExp, forEachLine,
+  overlapsAnyRange, linkRe, linkReferenceRe } = require("../helpers");
+const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
 
 module.exports = {
   "names": [ "MD044", "proper-names" ],
@@ -15,80 +13,65 @@ module.exports = {
   "function": function MD044(params, onError) {
     let names = params.config.names;
     names = Array.isArray(names) ? names : [];
+    names.sort((a, b) => (b.length - a.length) || a.localeCompare(b));
     const codeBlocks = params.config.code_blocks;
     const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
-    // Text of automatic hyperlinks is implicitly a URL
-    const autolinkText = new Set();
-    filterTokens(params, "inline", (token) => {
-      let inAutoLink = false;
-      token.children.forEach((child) => {
-        const { info, type } = child;
-        if ((type === "link_open") && (info === "auto")) {
-          inAutoLink = true;
-        } else if (type === "link_close") {
-          inAutoLink = false;
-        } else if ((type === "text") && inAutoLink) {
-          autolinkText.add(child);
+    const exclusions = [];
+    forEachLine(lineMetadata(), (line, lineIndex) => {
+      if (linkReferenceRe.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 ]);
         }
-      });
+        while ((match = linkRe.exec(line)) !== null) {
+          const [ , text, destination ] = match;
+          if (destination) {
+            exclusions.push(
+              [ lineIndex, match.index + text.length, destination.length ]
+            );
+          }
+        }
+      }
     });
-    // For each proper name...
-    names.forEach((name) => {
+    if (!includeCodeBlocks) {
+      exclusions.push(...codeBlockAndSpanRanges());
+    }
+    for (const name of names) {
       const escapedName = escapeForRegExp(name);
-      const startNamePattern = startNonWordRe.test(name) ? "" : "\\S*\\b";
-      const endNamePattern = endNonWordRe.test(name) ? "" : "\\b\\S*";
+      const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
+      const endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
       const namePattern =
-        `(${startNamePattern})(${escapedName})(${endNamePattern})`;
-      const anyNameRe = new RegExp(namePattern, "gi");
-      // eslint-disable-next-line jsdoc/require-jsdoc
-      function forToken(token) {
-        if (!autolinkText.has(token)) {
-          const fenceOffset = (token.type === "fence") ? 1 : 0;
-          token.content.split(newLineRe).forEach((line, index) => {
-            let match = null;
-            while ((match = anyNameRe.exec(line)) !== null) {
-              const [ fullMatch, leftMatch, nameMatch, rightMatch ] = match;
-              if (fullMatch.search(bareUrlRe) === -1) {
-                const wordMatch = fullMatch
-                  .replace(new RegExp(`^\\W{0,${leftMatch.length}}`), "")
-                  .replace(new RegExp(`\\W{0,${rightMatch.length}}$`), "");
-                if (!names.includes(wordMatch)) {
-                  const lineNumber = token.lineNumber + index + fenceOffset;
-                  const fullLine = params.lines[lineNumber - 1];
-                  const matchLength = wordMatch.length;
-                  const matchIndex = fullLine.indexOf(wordMatch);
-                  const range = (matchIndex === -1) ?
-                    null :
-                    [ matchIndex + 1, matchLength ];
-                  const fixInfo = (matchIndex === -1) ?
-                    null :
-                    {
-                      "editColumn": matchIndex + 1,
-                      "deleteCount": matchLength,
-                      "insertText": name
-                    };
-                  addErrorDetailIf(
-                    onError,
-                    lineNumber,
-                    name,
-                    nameMatch,
-                    null,
-                    null,
-                    range,
-                    fixInfo
-                  );
+        `(${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 (!overlapsAnyRange(exclusions, lineIndex, index, length)) {
+              addErrorDetailIf(
+                onError,
+                lineIndex + 1,
+                name,
+                nameMatch,
+                null,
+                null,
+                [ index + 1, length ],
+                {
+                  "editColumn": index + 1,
+                  "deleteCount": length,
+                  "insertText": name
                 }
-              }
+              );
             }
-          });
+            exclusions.push([ lineIndex, index, length ]);
+          }
         }
-      }
-      forEachInlineChild(params, "text", forToken);
-      if (includeCodeBlocks) {
-        forEachInlineChild(params, "code_inline", forToken);
-        filterTokens(params, "code_block", forToken);
-        filterTokens(params, "fence", forToken);
-      }
-    });
+      });
+    }
   }
 };

package/lib/md049.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+"use strict";
+
+const { addError, emphasisOrStrongStyleFor, forEachInlineChild,
+  getNextChildToken, getRangeAndFixInfoIfFound } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD049", "emphasis-style" ],
+  "description": "Emphasis style should be consistent",
+  "tags": [ "emphasis" ],
+  "function": function MD049(params, onError) {
+    let expectedStyle = String(params.config.style || "consistent");
+    forEachInlineChild(params, "em_open", (token, parent) => {
+      const { lineNumber, markup } = token;
+      const markupStyle = emphasisOrStrongStyleFor(markup);
+      if (expectedStyle === "consistent") {
+        expectedStyle = markupStyle;
+      }
+      if (expectedStyle !== markupStyle) {
+        let rangeAndFixInfo = {};
+        const contentToken = getNextChildToken(
+          parent, token, "text", "em_close"
+        );
+        if (contentToken) {
+          const { content } = contentToken;
+          const actual = `${markup}${content}${markup}`;
+          const expectedMarkup = (expectedStyle === "asterisk") ? "*" : "_";
+          const expected = `${expectedMarkup}${content}${expectedMarkup}`;
+          rangeAndFixInfo = getRangeAndFixInfoIfFound(
+            params.lines, lineNumber - 1, actual, expected
+          );
+        }
+        addError(
+          onError,
+          lineNumber,
+          `Expected: ${expectedStyle}; Actual: ${markupStyle}`,
+          null,
+          rangeAndFixInfo.range,
+          rangeAndFixInfo.fixInfo
+        );
+      }
+    });
+  }
+};

package/lib/md050.js

@@ -0,0 +1,45 @@
+// @ts-check
+
+"use strict";
+
+const { addError, emphasisOrStrongStyleFor, forEachInlineChild,
+  getNextChildToken, getRangeAndFixInfoIfFound } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD050", "strong-style" ],
+  "description": "Strong style should be consistent",
+  "tags": [ "emphasis" ],
+  "function": function MD050(params, onError) {
+    let expectedStyle = String(params.config.style || "consistent");
+    forEachInlineChild(params, "strong_open", (token, parent) => {
+      const { lineNumber, markup } = token;
+      const markupStyle = emphasisOrStrongStyleFor(markup);
+      if (expectedStyle === "consistent") {
+        expectedStyle = markupStyle;
+      }
+      if (expectedStyle !== markupStyle) {
+        let rangeAndFixInfo = {};
+        const contentToken = getNextChildToken(
+          parent, token, "text", "strong_close"
+        );
+        if (contentToken) {
+          const { content } = contentToken;
+          const actual = `${markup}${content}${markup}`;
+          const expectedMarkup = (expectedStyle === "asterisk") ? "**" : "__";
+          const expected = `${expectedMarkup}${content}${expectedMarkup}`;
+          rangeAndFixInfo = getRangeAndFixInfoIfFound(
+            params.lines, lineNumber - 1, actual, expected
+          );
+        }
+        addError(
+          onError,
+          lineNumber,
+          `Expected: ${expectedStyle}; Actual: ${markupStyle}`,
+          null,
+          rangeAndFixInfo.range,
+          rangeAndFixInfo.fixInfo
+        );
+      }
+    });
+  }
+};

package/lib/rules.js

@@ -2,9 +2,7 @@
 
 "use strict";
 
-const packageJson = require("../package.json");
-const homepage = packageJson.homepage;
-const version = packageJson.version;
+const { homepage, version } = require("./constants");
 
 const rules = [
   require("./md001"),
@@ -50,7 +48,9 @@ const rules = [
   require("./md045"),
   require("./md046"),
   require("./md047"),
-  require("./md048")
+  require("./md048"),
+  require("./md049"),
+  require("./md050")
 ];
 rules.forEach((rule) => {
   const name = rule.names[0].toLowerCase();