markdownlint 0.29.0 → 0.31.0

package/lib/md022.js

@@ -2,8 +2,25 @@
 
 "use strict";
 
-const { addErrorDetailIf, blockquotePrefixRe, filterTokens, isBlankLine } =
+const { addErrorDetailIf, blockquotePrefixRe, isBlankLine } =
   require("../helpers");
+const { filterByTypes, getHeadingLevel } =
+  require("../helpers/micromark.cjs");
+
+const defaultLines = 1;
+
+const getLinesFunction = (linesParam) => {
+  if (Array.isArray(linesParam)) {
+    const linesArray = new Array(6).fill(defaultLines);
+    for (const [ index, value ] of [ ...linesParam.entries() ].slice(0, 6)) {
+      linesArray[index] = value;
+    }
+    return (heading) => linesArray[getHeadingLevel(heading) - 1];
+  }
+  // Coerce linesParam to a number
+  const lines = (linesParam === undefined) ? defaultLines : Number(linesParam);
+  return () => lines;
+};
 
 const getBlockQuote = (str, count) => (
   (str || "")
@@ -19,50 +36,73 @@ module.exports = {
   "description": "Headings should be surrounded by blank lines",
   "tags": [ "headings", "headers", "blank_lines" ],
   "function": function MD022(params, onError) {
-    let linesAbove = params.config.lines_above;
-    linesAbove = Number((linesAbove === undefined) ? 1 : linesAbove);
-    let linesBelow = params.config.lines_below;
-    linesBelow = Number((linesBelow === undefined) ? 1 : linesBelow);
-    const { lines } = params;
-    filterTokens(params, "heading_open", (token) => {
-      const [ topIndex, nextIndex ] = token.map;
-      let actualAbove = 0;
-      for (let i = 0; i < linesAbove; i++) {
-        if (isBlankLine(lines[topIndex - i - 1])) {
+    const getLinesAbove = getLinesFunction(params.config.lines_above);
+    const getLinesBelow = getLinesFunction(params.config.lines_below);
+    const { lines, parsers } = params;
+    const headings = filterByTypes(
+      parsers.micromark.tokens,
+      [ "atxHeading", "setextHeading" ]
+    );
+    for (const heading of headings) {
+      const { startLine, endLine } = heading;
+      const line = lines[startLine - 1].trim();
+
+      // Check lines above
+      const linesAbove = getLinesAbove(heading);
+      if (linesAbove >= 0) {
+        let actualAbove = 0;
+        for (
+          let i = 0;
+          (i < linesAbove) && isBlankLine(lines[startLine - 2 - i]);
+          i++
+        ) {
           actualAbove++;
         }
+        addErrorDetailIf(
+          onError,
+          startLine,
+          linesAbove,
+          actualAbove,
+          "Above",
+          line,
+          null,
+          {
+            "insertText": getBlockQuote(
+              lines[startLine - 2],
+              linesAbove - actualAbove
+            )
+          }
+        );
       }
-      addErrorDetailIf(
-        onError,
-        topIndex + 1,
-        linesAbove,
-        actualAbove,
-        "Above",
-        lines[topIndex].trim(),
-        null,
-        {
-          "insertText":
-            getBlockQuote(lines[topIndex - 1], linesAbove - actualAbove)
-        });
-      let actualBelow = 0;
-      for (let i = 0; i < linesBelow; i++) {
-        if (isBlankLine(lines[nextIndex + i])) {
+
+      // Check lines below
+      const linesBelow = getLinesBelow(heading);
+      if (linesBelow >= 0) {
+        let actualBelow = 0;
+        for (
+          let i = 0;
+          (i < linesBelow) && isBlankLine(lines[endLine + i]);
+          i++
+        ) {
           actualBelow++;
         }
+        addErrorDetailIf(
+          onError,
+          startLine,
+          linesBelow,
+          actualBelow,
+          "Below",
+          line,
+          null,
+          {
+            "lineNumber": endLine + 1,
+            "insertText": getBlockQuote(
+              lines[endLine],
+              linesBelow - actualBelow
+            )
+          }
+        );
       }
-      addErrorDetailIf(
-        onError,
-        topIndex + 1,
-        linesBelow,
-        actualBelow,
-        "Below",
-        lines[topIndex].trim(),
-        null,
-        {
-          "lineNumber": nextIndex + 1,
-          "insertText":
-            getBlockQuote(lines[nextIndex], linesBelow - actualBelow)
-        });
-    });
+    }
   }
 };

package/lib/md026.js

@@ -2,10 +2,10 @@
 
 "use strict";
 
-const { addError, allPunctuationNoQuestion, escapeForRegExp, forEachHeading } =
-  require("../helpers");
+const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
+  endOfLineHtmlEntityRe, escapeForRegExp } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
 
-const endOfLineHtmlEntityRe = /&#?[\da-zA-Z]+;$/;
 
 module.exports = {
   "names": [ "MD026", "no-trailing-punctuation" ],
@@ -18,19 +18,26 @@ module.exports = {
     );
     const trailingPunctuationRe =
       new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
-    forEachHeading(params, (heading) => {
-      const { line, lineNumber } = heading;
-      const trimmedLine = line.replace(/([^\s#])[\s#]+$/, "$1");
-      const match = trailingPunctuationRe.exec(trimmedLine);
-      if (match && !endOfLineHtmlEntityRe.test(trimmedLine)) {
+    const headings = filterByTypes(
+      params.parsers.micromark.tokens,
+      [ "atxHeadingText", "setextHeadingText" ]
+    );
+    for (const heading of headings) {
+      const { endLine, startColumn, text } = heading;
+      const match = trailingPunctuationRe.exec(text);
+      if (
+        match &&
+        !endOfLineHtmlEntityRe.test(text) &&
+        !endOfLineGemojiCodeRe.test(text)
+      ) {
         const fullMatch = match[0];
-        const column = match.index + 1;
+        const column = startColumn + match.index;
         const length = fullMatch.length;
         addError(
           onError,
-          lineNumber,
+          endLine,
           `Punctuation: '${fullMatch}'`,
-          null,
+          undefined,
           [ column, length ],
           {
             "editColumn": column,
@@ -38,6 +45,6 @@ module.exports = {
           }
         );
       }
-    });
+    }
   }
 };

package/lib/md032.js

@@ -4,46 +4,77 @@
 
 const { addErrorContext, blockquotePrefixRe, isBlankLine } =
   require("../helpers");
-const { flattenedLists } = require("./cache");
+const { filterByPredicate } = require("../helpers/micromark.cjs");
+
+const nonContentTokens = new Set([
+  "blockQuoteMarker",
+  "blockQuotePrefix",
+  "blockQuotePrefixWhitespace",
+  "lineEnding",
+  "lineEndingBlank",
+  "linePrefix",
+  "listItemIndent"
+]);
+const isList = (token) => (
+  (token.type === "listOrdered") || (token.type === "listUnordered")
+);
+const addBlankLineError = (onError, lines, lineIndex, lineNumber) => {
+  const line = lines[lineIndex];
+  const quotePrefix = line.match(blockquotePrefixRe)[0].trimEnd();
+  addErrorContext(
+    onError,
+    lineIndex + 1,
+    line.trim(),
+    null,
+    null,
+    null,
+    {
+      lineNumber,
+      "insertText": `${quotePrefix}\n`
+    }
+  );
+};
 
 module.exports = {
   "names": [ "MD032", "blanks-around-lists" ],
   "description": "Lists should be surrounded by blank lines",
   "tags": [ "bullet", "ul", "ol", "blank_lines" ],
   "function": function MD032(params, onError) {
-    const { lines } = params;
-    const filteredLists = flattenedLists().filter((list) => !list.nesting);
-    for (const list of filteredLists) {
-      const firstIndex = list.open.map[0];
+    const { lines, parsers } = params;
+
+    // For every top-level list...
+    const topLevelLists = filterByPredicate(
+      parsers.micromark.tokens,
+      isList,
+      (token) => (
+        (isList(token) || (token.type === "htmlFlow")) ? [] : token.children
+      )
+    );
+    for (const list of topLevelLists) {
+
+      // Look for a blank line above the list
+      const firstIndex = list.startLine - 1;
       if (!isBlankLine(lines[firstIndex - 1])) {
-        const line = lines[firstIndex];
-        const quotePrefix = line.match(blockquotePrefixRe)[0].trimEnd();
-        addErrorContext(
-          onError,
-          firstIndex + 1,
-          line.trim(),
-          null,
-          null,
-          null,
-          {
-            "insertText": `${quotePrefix}\n`
-          });
+        addBlankLineError(onError, lines, firstIndex);
+      }
+
+      // Find the "visual" end of the list
+      let endLine = list.endLine;
+      const flattenedChildren = filterByPredicate(
+        list.children,
+        () => true
+      );
+      for (const child of flattenedChildren.reverse()) {
+        if (!nonContentTokens.has(child.type)) {
+          endLine = child.endLine;
+          break;
+        }
       }
-      const lastIndex = list.lastLineIndex - 1;
+
+      // Look for a blank line below the list
+      const lastIndex = endLine - 1;
       if (!isBlankLine(lines[lastIndex + 1])) {
-        const line = lines[lastIndex];
-        const quotePrefix = line.match(blockquotePrefixRe)[0].trimEnd();
-        addErrorContext(
-          onError,
-          lastIndex + 1,
-          line.trim(),
-          null,
-          null,
-          null,
-          {
-            "lineNumber": lastIndex + 2,
-            "insertText": `${quotePrefix}\n`
-          });
+        addBlankLineError(onError, lines, lastIndex, lastIndex + 2);
       }
     }
   }

package/lib/md033.js

@@ -3,7 +3,7 @@
 "use strict";
 
 const { addError } = require("../helpers");
-const { filterByTypes, getHtmlTagInfo, parse } =
+const { filterByTypes, getHtmlTagInfo } =
   require("../helpers/micromark.cjs");
 
 const nextLinesRe = /[\r\n][\s\S]*$/;
@@ -16,50 +16,25 @@ module.exports = {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    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 ]
-          );
-        }
+    const { tokens } = params.parsers.micromark;
+    for (const token of filterByTypes(tokens, [ "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,
+          "Element: " + htmlTagInfo.name,
+          undefined,
+          range
+        );
       }
     }
   }

package/lib/md037.js

@@ -2,184 +2,90 @@
 
 "use strict";
 
-const { addErrorContext, emphasisMarkersInContent, forEachLine, isBlankLine,
-  withinAnyRange } = require("../helpers");
-const { htmlElementRanges, lineMetadata } = require("./cache");
-
-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+$/;
-const tablePipeRe = /\|/;
-const allUnderscoresRe = /_/g;
+const { addError } = require("../helpers");
+const { filterByPredicate } = require("../helpers/micromark.cjs");
 
 module.exports = {
   "names": [ "MD037", "no-space-in-emphasis" ],
   "description": "Spaces inside emphasis markers",
   "tags": [ "whitespace", "emphasis" ],
   "function": function MD037(params, onError) {
-    const exclusions = htmlElementRanges();
-    // 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;
+
+    // Initialize variables
+    const { lines, parsers } = params;
+    const emphasisTokensByMarker = new Map();
+    for (const marker of [ "_", "__", "___", "*", "**", "***" ]) {
+      emphasisTokensByMarker.set(marker, []);
     }
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    function handleRunEnd(
-      line, lineIndex, contextLength, match, matchIndex, inTable
-    ) {
-      // Close current run
-      let content = line.substring(emphasisIndex, matchIndex);
-      if (!emphasisLength) {
-        content = content.trimStart();
-      }
-      if (!match) {
-        content = content.trimEnd();
+    const tokens = filterByPredicate(
+      parsers.micromark.tokens,
+      (token) => token.children.some((child) => child.type === "data")
+    );
+    for (const token of tokens) {
+
+      // Build lists of bare tokens for each emphasis marker type
+      for (const emphasisTokens of emphasisTokensByMarker.values()) {
+        emphasisTokens.length = 0;
       }
-      const leftSpace = leftSpaceRe.test(content);
-      const rightSpace = rightSpaceRe.test(content);
-      if (
-        (leftSpace || rightSpace) &&
-        (!inTable || !tablePipeRe.test(content))
-      ) {
-        // Report the violation
-        const contextStart = emphasisIndex - emphasisLength;
-        const contextEnd = matchIndex + contextLength;
-        const column = contextStart + 1;
-        const length = contextEnd - contextStart;
-        if (!withinAnyRange(exclusions, lineIndex, column, length)) {
-          const context = line.substring(contextStart, contextEnd);
-          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
-            }
-          ];
+      for (const child of token.children) {
+        const { text, type } = child;
+        if ((type === "data") && (text.length <= 3)) {
+          const emphasisTokens = emphasisTokensByMarker.get(text);
+          if (emphasisTokens) {
+            emphasisTokens.push(child);
+          }
         }
       }
-      return null;
-    }
-    // Initialize
-    const ignoreMarkersByLine = emphasisMarkersInContent(params);
-    resetRunTracking();
-    forEachLine(
-      lineMetadata(),
-      (line, lineIndex, inCode, onFence, inTable, inItem, onBreak, inMath) => {
-        const onItemStart = (inItem === 1);
-        if (
-          inCode ||
-          onFence ||
-          inTable ||
-          onBreak ||
-          onItemStart ||
-          isBlankLine(line)
-        ) {
-          // Emphasis resets when leaving a block
-          resetRunTracking();
-        }
-        if (
-          inCode ||
-          onFence ||
-          onBreak ||
-          inMath
-        ) {
-          // Emphasis has no meaning here
-          return;
-        }
-        let patchedLine = line.replace(
-          embeddedUnderscoreRe,
-          (match) => match.replace(allUnderscoresRe, " ")
-        );
-        if (onItemStart) {
-          // Trim overlapping '*' list item marker
-          patchedLine = patchedLine.replace(asteriskListItemMarkerRe, "$1 $2");
-        }
-        let match = null;
-        // Match all emphasis-looking runs in the line...
-        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
-            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) {
-                // @ts-ignore
-                addErrorContext(...pendingError);
-                pendingError = null;
+
+      // Process bare tokens for each emphasis marker type
+      for (const entry of emphasisTokensByMarker.entries()) {
+        const [ marker, emphasisTokens ] = entry;
+        for (let i = 0; i + 1 < emphasisTokens.length; i += 2) {
+
+          // Process start token of start/end pair
+          const startToken = emphasisTokens[i];
+          const startLine = lines[startToken.startLine - 1];
+          const startSlice = startLine.slice(startToken.endColumn - 1);
+          const startMatch = startSlice.match(/^\s+\S/);
+          if (startMatch) {
+            const [ startSpaceCharacter ] = startMatch;
+            const startContext = `${marker}${startSpaceCharacter}`;
+            addError(
+              onError,
+              startToken.startLine,
+              undefined,
+              startContext,
+              [ startToken.startColumn, startContext.length ],
+              {
+                "editColumn": startToken.endColumn,
+                "deleteCount": startSpaceCharacter.length - 1
               }
-              const error = handleRunEnd(
-                line,
-                lineIndex,
-                effectiveEmphasisLength,
-                match,
-                matchIndex,
-                inTable
-              );
-              if (error) {
-                // @ts-ignore
-                addErrorContext(...error);
+            );
+          }
+
+          // Process end token of start/end pair
+          const endToken = emphasisTokens[i + 1];
+          const endLine = lines[endToken.startLine - 1];
+          const endSlice = endLine.slice(0, endToken.startColumn - 1);
+          const endMatch = endSlice.match(/\S\s+$/);
+          if (endMatch) {
+            const [ endSpaceCharacter ] = endMatch;
+            const endContext = `${endSpaceCharacter}${marker}`;
+            addError(
+              onError,
+              endToken.startLine,
+              undefined,
+              endContext,
+              [ endToken.endColumn - endContext.length, endContext.length ],
+              {
+                "editColumn":
+                  endToken.startColumn - (endSpaceCharacter.length - 1),
+                "deleteCount": endSpaceCharacter.length - 1
               }
-              // 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, inTable);
-          // Adjust for pending run on new line
-          emphasisIndex = 0;
-          emphasisLength = 0;
-        }
       }
-    );
+    }
   }
 };