markdownlint 0.20.2 → 0.21.1

package/lib/md037.js

@@ -1,141 +1,150 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, emphasisMarkersInCodeSpans, forEachLine,
-  includesSorted, isBlankLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
-
-const emphasisRe = /(^|[^\\])(?:(\*\*?\*?)|(__?_?))/g;
-const asteriskListItemMarkerRe = /^(\s*)\*(\s+)/;
-const leftSpaceRe = /^\s+/;
-const rightSpaceRe = /\s+$/;
-
-module.exports = {
-  "names": [ "MD037", "no-space-in-emphasis" ],
-  "description": "Spaces inside emphasis markers",
-  "tags": [ "whitespace", "emphasis" ],
-  "function": function MD037(params, onError) {
-    // eslint-disable-next-line init-declarations
-    let effectiveEmphasisLength, emphasisIndex, emphasisKind, emphasisLength,
-      pendingError = null;
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    function resetRunTracking() {
-      emphasisIndex = -1;
-      emphasisLength = 0;
-      emphasisKind = "";
-      effectiveEmphasisLength = 0;
-      pendingError = null;
-    }
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    function handleRunEnd(line, lineIndex, contextLength, match, matchIndex) {
-      // Close current run
-      let content = line.substring(emphasisIndex, matchIndex);
-      if (!emphasisLength) {
-        content = content.trimStart();
-      }
-      if (!match) {
-        content = content.trimEnd();
-      }
-      const leftSpace = leftSpaceRe.test(content);
-      const rightSpace = rightSpaceRe.test(content);
-      if (leftSpace || rightSpace) {
-        // Report the violation
-        const contextStart = emphasisIndex - emphasisLength;
-        const contextEnd = matchIndex + contextLength;
-        const context = line.substring(contextStart, contextEnd);
-        const column = contextStart + 1;
-        const length = contextEnd - contextStart;
-        const leftMarker = line.substring(contextStart, emphasisIndex);
-        const rightMarker = match ? (match[2] || match[3]) : "";
-        const fixedText = `${leftMarker}${content.trim()}${rightMarker}`;
-        return [
-          onError,
-          lineIndex + 1,
-          context,
-          leftSpace,
-          rightSpace,
-          [ column, length ],
-          {
-            "editColumn": column,
-            "deleteCount": length,
-            "insertText": fixedText
-          }
-        ];
-      }
-      return null;
-    }
-    // Initialize
-    const ignoreMarkersByLine = emphasisMarkersInCodeSpans(params);
-    resetRunTracking();
-    forEachLine(
-      lineMetadata(),
-      (line, lineIndex, inCode, onFence, inTable, inItem, onBreak) => {
-        const onItemStart = (inItem === 1);
-        if (inCode || inTable || onBreak || onItemStart || isBlankLine(line)) {
-          // Emphasis resets when leaving a block
-          resetRunTracking();
-        }
-        if (inCode || onBreak) {
-          // Emphasis has no meaning here
-          return;
-        }
-        if (onItemStart) {
-          // Trim overlapping '*' list item marker
-          line = line.replace(asteriskListItemMarkerRe, "$1 $2");
-        }
-        let match = null;
-        // Match all emphasis-looking runs in the line...
-        while ((match = emphasisRe.exec(line))) {
-          const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex] || [];
-          const matchIndex = match.index + match[1].length;
-          if (includesSorted(ignoreMarkersForLine, matchIndex)) {
-            // Ignore emphasis markers inside code spans
-            continue;
-          }
-          const matchLength = match[0].length - match[1].length;
-          const matchKind = (match[2] || match[3])[0];
-          if (emphasisIndex === -1) {
-            // New run
-            emphasisIndex = matchIndex + matchLength;
-            emphasisLength = matchLength;
-            emphasisKind = matchKind;
-            effectiveEmphasisLength = matchLength;
-          } else if (
-            (matchLength === effectiveEmphasisLength) &&
-            (matchKind === emphasisKind)
-          ) {
-            // Ending an existing run, report any pending error
-            if (pendingError) {
-              addErrorContext(...pendingError);
-              pendingError = null;
-            }
-            const error = handleRunEnd(
-              line, lineIndex, effectiveEmphasisLength, match, matchIndex);
-            if (error) {
-              addErrorContext(...error);
-            }
-            // Reset
-            resetRunTracking();
-          } else if (matchLength === 3) {
-            // Swap internal run length (1->2 or 2->1)
-            effectiveEmphasisLength = matchLength - effectiveEmphasisLength;
-          } else if (effectiveEmphasisLength === 3) {
-            // Downgrade internal run (3->1 or 3->2)
-            effectiveEmphasisLength -= matchLength;
-          } else {
-            // Upgrade to internal run (1->3 or 2->3)
-            effectiveEmphasisLength += matchLength;
-          }
-        }
-        if (emphasisIndex !== -1) {
-          pendingError = pendingError ||
-            handleRunEnd(line, lineIndex, 0, null, line.length);
-          // Adjust for pending run on new line
-          emphasisIndex = 0;
-          emphasisLength = 0;
-        }
-      }
-    );
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine } =
+  require("../helpers");
+const { lineMetadata } = require("./cache");
+
+const emphasisRe = /(^|[^\\]|\\\\)(?:(\*\*?\*?)|(__?_?))/g;
+const asteriskListItemMarkerRe = /^([\s>]*)\*(\s+)/;
+const leftSpaceRe = /^\s+/;
+const rightSpaceRe = /\s+$/;
+
+module.exports = {
+  "names": [ "MD037", "no-space-in-emphasis" ],
+  "description": "Spaces inside emphasis markers",
+  "tags": [ "whitespace", "emphasis" ],
+  "function": function MD037(params, onError) {
+    // eslint-disable-next-line init-declarations
+    let effectiveEmphasisLength, emphasisIndex, emphasisKind, emphasisLength,
+      pendingError = null;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function resetRunTracking() {
+      emphasisIndex = -1;
+      emphasisLength = 0;
+      emphasisKind = "";
+      effectiveEmphasisLength = 0;
+      pendingError = null;
+    }
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function handleRunEnd(line, lineIndex, contextLength, match, matchIndex) {
+      // Close current run
+      let content = line.substring(emphasisIndex, matchIndex);
+      if (!emphasisLength) {
+        content = content.trimLeft();
+      }
+      if (!match) {
+        content = content.trimRight();
+      }
+      const leftSpace = leftSpaceRe.test(content);
+      const rightSpace = rightSpaceRe.test(content);
+      if (leftSpace || rightSpace) {
+        // Report the violation
+        const contextStart = emphasisIndex - emphasisLength;
+        const contextEnd = matchIndex + contextLength;
+        const context = line.substring(contextStart, contextEnd);
+        const column = contextStart + 1;
+        const length = contextEnd - contextStart;
+        const leftMarker = line.substring(contextStart, emphasisIndex);
+        const rightMarker = match ? (match[2] || match[3]) : "";
+        const fixedText = `${leftMarker}${content.trim()}${rightMarker}`;
+        return [
+          onError,
+          lineIndex + 1,
+          context,
+          leftSpace,
+          rightSpace,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length,
+            "insertText": fixedText
+          }
+        ];
+      }
+      return null;
+    }
+    // Initialize
+    const ignoreMarkersByLine = emphasisMarkersInContent(params);
+    resetRunTracking();
+    forEachLine(
+      lineMetadata(),
+      (line, lineIndex, inCode, onFence, inTable, inItem, onBreak) => {
+        const onItemStart = (inItem === 1);
+        if (inCode || inTable || onBreak || onItemStart || isBlankLine(line)) {
+          // Emphasis resets when leaving a block
+          resetRunTracking();
+        }
+        if (inCode || onBreak) {
+          // Emphasis has no meaning here
+          return;
+        }
+        if (onItemStart) {
+          // Trim overlapping '*' list item marker
+          line = line.replace(asteriskListItemMarkerRe, "$1 $2");
+        }
+        let match = null;
+        // Match all emphasis-looking runs in the line...
+        while ((match = emphasisRe.exec(line))) {
+          const ignoreMarkersForLine = ignoreMarkersByLine[lineIndex] || [];
+          const matchIndex = match.index + match[1].length;
+          if (ignoreMarkersForLine.includes(matchIndex)) {
+            // Ignore emphasis markers inside code spans and links
+            continue;
+          }
+          const matchLength = match[0].length - match[1].length;
+          const matchKind = (match[2] || match[3])[0];
+          if (emphasisIndex === -1) {
+            // New run
+            emphasisIndex = matchIndex + matchLength;
+            emphasisLength = matchLength;
+            emphasisKind = matchKind;
+            effectiveEmphasisLength = matchLength;
+          } else if (matchKind === emphasisKind) {
+            // Matching emphasis markers
+            if (matchLength === effectiveEmphasisLength) {
+              // Ending an existing run, report any pending error
+              if (pendingError) {
+                addErrorContext(...pendingError);
+                pendingError = null;
+              }
+              const error = handleRunEnd(
+                line, lineIndex, effectiveEmphasisLength, match, matchIndex);
+              if (error) {
+                addErrorContext(...error);
+              }
+              // Reset
+              resetRunTracking();
+            } else if (matchLength === 3) {
+              // Swap internal run length (1->2 or 2->1)
+              effectiveEmphasisLength = matchLength - effectiveEmphasisLength;
+            } else if (effectiveEmphasisLength === 3) {
+              // Downgrade internal run (3->1 or 3->2)
+              effectiveEmphasisLength -= matchLength;
+            } else {
+              // Upgrade to internal run (1->3 or 2->3)
+              effectiveEmphasisLength += matchLength;
+            }
+            // Back up one character so RegExp has a chance to match the
+            // next marker (ex: "**star**_underscore_")
+            if (emphasisRe.lastIndex > 1) {
+              emphasisRe.lastIndex--;
+            }
+          } else if (emphasisRe.lastIndex > 1) {
+            // Back up one character so RegExp has a chance to match the
+            // mis-matched marker (ex: "*text_*")
+            emphasisRe.lastIndex--;
+          }
+        }
+        if (emphasisIndex !== -1) {
+          pendingError = pendingError ||
+            handleRunEnd(line, lineIndex, 0, null, line.length);
+          // Adjust for pending run on new line
+          emphasisIndex = 0;
+          emphasisLength = 0;
+        }
+      }
+    );
+  }
+};

package/lib/md038.js

@@ -1,68 +1,68 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, filterTokens, forEachInlineCodeSpan, newLineRe } =
-  require("../helpers");
-
-const leftSpaceRe = /^\s([^`]|$)/;
-const rightSpaceRe = /[^`]\s$/;
-const singleLeftRightSpaceRe = /^\s(?:\S.*\S|\S)\s$/;
-
-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((child) => child.type === "code_inline")) {
-        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;
-            }
-            const allowed = singleLeftRightSpaceRe.test(code);
-            if ((left || right) && !allowed) {
-              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
-                }
-              );
-            }
-          });
-      }
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, forEachInlineCodeSpan, newLineRe } =
+  require("../helpers");
+
+const leftSpaceRe = /^\s([^`]|$)/;
+const rightSpaceRe = /[^`]\s$/;
+const singleLeftRightSpaceRe = /^\s(?:\S.*\S|\S)\s$/;
+
+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((child) => child.type === "code_inline")) {
+        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;
+            }
+            const allowed = singleLeftRightSpaceRe.test(code);
+            if ((left || right) && !allowed) {
+              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
+                }
+              );
+            }
+          });
+      }
+    });
+  }
+};

package/lib/md039.js

@@ -1,64 +1,64 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, filterTokens } = require("../helpers");
-
-const spaceInLinkRe = /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=\(\S*\))/;
-
-module.exports = {
-  "names": [ "MD039", "no-space-in-links" ],
-  "description": "Spaces inside link text",
-  "tags": [ "whitespace", "links" ],
-  "function": function MD039(params, onError) {
-    filterTokens(params, "inline", (token) => {
-      const { children } = token;
-      let { lineNumber } = token;
-      let inLink = false;
-      let linkText = "";
-      let lineIndex = 0;
-      children.forEach((child) => {
-        const { content, type } = child;
-        if (type === "link_open") {
-          inLink = true;
-          linkText = "";
-        } else if (type === "link_close") {
-          inLink = false;
-          const left = linkText.trimLeft().length !== linkText.length;
-          const right = linkText.trimRight().length !== linkText.length;
-          if (left || right) {
-            const line = params.lines[lineNumber - 1];
-            let range = null;
-            let fixInfo = null;
-            const match = line.slice(lineIndex).match(spaceInLinkRe);
-            if (match) {
-              const column = match.index + lineIndex + 1;
-              const length = match[0].length;
-              range = [ column, length ];
-              fixInfo = {
-                "editColumn": column + 1,
-                "deleteCount": length - 2,
-                "insertText": linkText.trim()
-              };
-              lineIndex = column + length - 1;
-            }
-            addErrorContext(
-              onError,
-              lineNumber,
-              `[${linkText}]`,
-              left,
-              right,
-              range,
-              fixInfo
-            );
-          }
-        } else if ((type === "softbreak") || (type === "hardbreak")) {
-          lineNumber++;
-          lineIndex = 0;
-        } else if (inLink) {
-          linkText += content;
-        }
-      });
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const spaceInLinkRe = /\[(?:\s+(?:[^\]]*?)\s*|(?:[^\]]*?)\s+)](?=\(\S*\))/;
+
+module.exports = {
+  "names": [ "MD039", "no-space-in-links" ],
+  "description": "Spaces inside link text",
+  "tags": [ "whitespace", "links" ],
+  "function": function MD039(params, onError) {
+    filterTokens(params, "inline", (token) => {
+      const { children } = token;
+      let { lineNumber } = token;
+      let inLink = false;
+      let linkText = "";
+      let lineIndex = 0;
+      children.forEach((child) => {
+        const { content, type } = child;
+        if (type === "link_open") {
+          inLink = true;
+          linkText = "";
+        } else if (type === "link_close") {
+          inLink = false;
+          const left = linkText.trimLeft().length !== linkText.length;
+          const right = linkText.trimRight().length !== linkText.length;
+          if (left || right) {
+            const line = params.lines[lineNumber - 1];
+            let range = null;
+            let fixInfo = null;
+            const match = line.slice(lineIndex).match(spaceInLinkRe);
+            if (match) {
+              const column = match.index + lineIndex + 1;
+              const length = match[0].length;
+              range = [ column, length ];
+              fixInfo = {
+                "editColumn": column + 1,
+                "deleteCount": length - 2,
+                "insertText": linkText.trim()
+              };
+              lineIndex = column + length - 1;
+            }
+            addErrorContext(
+              onError,
+              lineNumber,
+              `[${linkText}]`,
+              left,
+              right,
+              range,
+              fixInfo
+            );
+          }
+        } else if ((type === "softbreak") || (type === "hardbreak")) {
+          lineNumber++;
+          lineIndex = 0;
+        } else if (inLink) {
+          linkText += content;
+        }
+      });
+    });
+  }
+};

package/lib/md040.js

@@ -1,18 +1,18 @@
-// @ts-check
-
-"use strict";
-
-const { 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) {
-    filterTokens(params, "fence", function forToken(token) {
-      if (!token.info.trim()) {
-        addErrorContext(onError, token.lineNumber, token.line);
-      }
-    });
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { 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) {
+    filterTokens(params, "fence", function forToken(token) {
+      if (!token.info.trim()) {
+        addErrorContext(onError, token.lineNumber, token.line);
+      }
+    });
+  }
+};

package/lib/md041.js

@@ -1,31 +1,31 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, frontMatterHasTitle } = require("../helpers");
-
-module.exports = {
-  "names": [ "MD041", "first-line-heading", "first-line-h1" ],
-  "description": "First line in file should be a top level heading",
-  "tags": [ "headings", "headers" ],
-  "function": function MD041(params, onError) {
-    const level = Number(params.config.level || 1);
-    const tag = "h" + level;
-    const foundFrontMatterTitle =
-      frontMatterHasTitle(
-        params.frontMatterLines,
-        params.config.front_matter_title
-      );
-    if (!foundFrontMatterTitle) {
-      params.tokens.every((token) => {
-        if (token.type === "html_block") {
-          return true;
-        }
-        if ((token.type !== "heading_open") || (token.tag !== tag)) {
-          addErrorContext(onError, token.lineNumber, token.line);
-        }
-        return false;
-      });
-    }
-  }
-};
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, frontMatterHasTitle } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD041", "first-line-heading", "first-line-h1" ],
+  "description": "First line in file should be a top level heading",
+  "tags": [ "headings", "headers" ],
+  "function": function MD041(params, onError) {
+    const level = Number(params.config.level || 1);
+    const tag = "h" + level;
+    const foundFrontMatterTitle =
+      frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      );
+    if (!foundFrontMatterTitle) {
+      params.tokens.every((token) => {
+        if (token.type === "html_block") {
+          return true;
+        }
+        if ((token.type !== "heading_open") || (token.tag !== tag)) {
+          addErrorContext(onError, token.lineNumber, token.line);
+        }
+        return false;
+      });
+    }
+  }
+};