markdownlint 0.33.0 → 0.35.0

package/lib/md027.js

@@ -2,54 +2,35 @@
 
 "use strict";
 
-const { addErrorContext, newLineRe } = require("../helpers");
-
-const spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
+const { addErrorContext } = require("../helpers");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
-  "names": [ "MD027", "no-multiple-space-blockquote" ],
+  "names": ["MD027", "no-multiple-space-blockquote"],
   "description": "Multiple spaces after blockquote symbol",
-  "tags": [ "blockquote", "whitespace", "indentation" ],
+  "tags": ["blockquote", "whitespace", "indentation"],
+  "parser": "micromark",
   "function": function MD027(params, onError) {
-    let blockquoteNesting = 0;
-    let listItemNesting = 0;
-    for (const token of params.parsers.markdownit.tokens) {
-      const { content, lineNumber, type } = token;
-      if (type === "blockquote_open") {
-        blockquoteNesting++;
-      } else if (type === "blockquote_close") {
-        blockquoteNesting--;
-      } else if (type === "list_item_open") {
-        listItemNesting++;
-      } else if (type === "list_item_close") {
-        listItemNesting--;
-      } else if ((type === "inline") && blockquoteNesting) {
-        const lineCount = content.split(newLineRe).length;
-        for (let i = 0; i < lineCount; i++) {
-          const line = params.lines[lineNumber + i - 1];
-          const match = line.match(spaceAfterBlockQuoteRe);
-          if (match) {
-            const [
-              fullMatch,
-              { "length": blockquoteLength },
-              { "length": spaceLength }
-            ] = match;
-            if (!listItemNesting || (fullMatch[fullMatch.length - 1] === ">")) {
-              addErrorContext(
-                onError,
-                lineNumber + i,
-                line,
-                null,
-                null,
-                [ 1, fullMatch.length ],
-                {
-                  "editColumn": blockquoteLength + 1,
-                  "deleteCount": spaceLength - 1
-                }
-              );
-            }
+    for (const token of filterByTypesCached([ "linePrefix" ])) {
+      const siblings = token.parent?.children || params.parsers.micromark.tokens;
+      if (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix") {
+        const { startColumn, startLine, text } = token;
+        const { length } = text;
+        const line = params.lines[startLine - 1];
+        addErrorContext(
+          onError,
+          startLine,
+          line,
+          undefined,
+          undefined,
+          [ startColumn, length ],
+          {
+            "editColumn": startColumn,
+            "deleteCount": length
           }
-        }
+        );
       }
     }
   }

package/lib/md028.js

@@ -3,28 +3,40 @@
 "use strict";
 
 const { addError } = require("../helpers");
+const { filterByTypesCached } = require("./cache");
 
+const ignoreTypes = new Set([ "lineEnding", "listItemIndent", "linePrefix" ]);
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD028", "no-blanks-blockquote" ],
   "description": "Blank line inside blockquote",
   "tags": [ "blockquote", "whitespace" ],
+  "parser": "micromark",
   "function": function MD028(params, onError) {
-    let prevToken = {};
-    let prevLineNumber = null;
-    for (const token of params.parsers.markdownit.tokens) {
-      if ((token.type === "blockquote_open") &&
-          (prevToken.type === "blockquote_close")) {
-        for (
-          let lineNumber = prevLineNumber;
-          lineNumber < token.lineNumber;
-          lineNumber++) {
-          addError(onError, lineNumber);
+    for (const token of filterByTypesCached([ "blockQuote" ])) {
+      const errorLineNumbers = [];
+      const siblings = token.parent?.children || params.parsers.micromark.tokens;
+      for (let i = siblings.indexOf(token) + 1; i < siblings.length; i++) {
+        const sibling = siblings[i];
+        const { startLine, type } = sibling;
+        if (type === "lineEndingBlank") {
+          // Possible blank between blockquotes
+          errorLineNumbers.push(startLine);
+        } else if (ignoreTypes.has(type)) {
+          // Ignore invisible formatting
+        } else if (type === "blockQuote") {
+          // Blockquote followed by blockquote
+          for (const lineNumber of errorLineNumbers) {
+            addError(onError, lineNumber);
+          }
+          break;
+        } else {
+          // Blockquote not followed by blockquote
+          break;
         }
       }
-      prevToken = token;
-      if (token.type === "blockquote_open") {
-        prevLineNumber = token.map[1] + 1;
-      }
     }
   }
 };

package/lib/md029.js

@@ -2,9 +2,9 @@
 
 "use strict";
 
-const { addErrorDetailIf, listItemMarkerRe, orderedListItemMarkerRe,
-  rangeFromRegExp } = require("../helpers");
-const { flattenedLists } = require("./cache");
+const { addErrorDetailIf } = require("../helpers");
+const { getDescendantsByType, getTokenTextByType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const listStyleExamples = {
   "one": "1/1/1",
@@ -12,29 +12,37 @@ const listStyleExamples = {
   "zero": "0/0/0"
 };
 
+/**
+ * Gets the value of an ordered list item prefix token.
+ *
+ * @param {import("../helpers/micromark.cjs").Token} listItemPrefix List item prefix token.
+ * @returns {number} List item value.
+ */
+function getOrderedListItemValue(listItemPrefix) {
+  return Number(getTokenTextByType(listItemPrefix.children, "listItemValue"));
+}
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD029", "ol-prefix" ],
   "description": "Ordered list item prefix",
   "tags": [ "ol" ],
+  "parser": "micromark",
   "function": function MD029(params, onError) {
     const style = String(params.config.style || "one_or_ordered");
-    const filteredLists = flattenedLists().filter((list) => !list.unordered);
-    for (const list of filteredLists) {
-      const { items } = list;
-      let current = 1;
+    for (const listOrdered of filterByTypesCached([ "listOrdered" ])) {
+      const listItemPrefixes = getDescendantsByType(listOrdered, [ "listItemPrefix" ]);
+      let expected = 1;
       let incrementing = false;
       // Check for incrementing number pattern 1/2/3 or 0/1/2
-      if (items.length >= 2) {
-        const first = orderedListItemMarkerRe.exec(items[0].line);
-        const second = orderedListItemMarkerRe.exec(items[1].line);
-        if (first && second) {
-          const [ , firstNumber ] = first;
-          const [ , secondNumber ] = second;
-          if ((secondNumber !== "1") || (firstNumber === "0")) {
-            incrementing = true;
-            if (firstNumber === "0") {
-              current = 0;
-            }
+      if (listItemPrefixes.length >= 2) {
+        const firstValue = getOrderedListItemValue(listItemPrefixes[0]);
+        const secondValue = getOrderedListItemValue(listItemPrefixes[1]);
+        if ((secondValue !== 1) || (firstValue === 0)) {
+          incrementing = true;
+          if (firstValue === 0) {
+            expected = 0;
           }
         }
       }
@@ -42,24 +50,25 @@ module.exports = {
       let listStyle = style;
       if (listStyle === "one_or_ordered") {
         listStyle = incrementing ? "ordered" : "one";
-      }
-      // Force expected value for 0/0/0 and 1/1/1 patterns
-      if (listStyle === "zero") {
-        current = 0;
+      } else if (listStyle === "zero") {
+        expected = 0;
       } else if (listStyle === "one") {
-        current = 1;
+        expected = 1;
       }
       // Validate each list item marker
-      for (const item of items) {
-        const match = orderedListItemMarkerRe.exec(item.line);
-        if (match) {
-          addErrorDetailIf(onError, item.lineNumber,
-            String(current), match[1],
-            "Style: " + listStyleExamples[listStyle], null,
-            rangeFromRegExp(item.line, listItemMarkerRe));
-          if (listStyle === "ordered") {
-            current++;
-          }
+      for (const listItemPrefix of listItemPrefixes) {
+        const actual = getOrderedListItemValue(listItemPrefix);
+        addErrorDetailIf(
+          onError,
+          listItemPrefix.startLine,
+          expected,
+          actual,
+          "Style: " + listStyleExamples[listStyle],
+          undefined,
+          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ]
+        );
+        if (listStyle === "ordered") {
+          expected++;
         }
       }
     }

package/lib/md030.js

@@ -3,22 +3,21 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD030", "list-marker-space" ],
   "description": "Spaces after list markers",
   "tags": [ "ol", "ul", "whitespace" ],
+  "parser": "micromark",
   "function": function MD030(params, onError) {
     const ulSingle = Number(params.config.ul_single || 1);
     const olSingle = Number(params.config.ol_single || 1);
     const ulMulti = Number(params.config.ul_multi || 1);
     const olMulti = Number(params.config.ol_multi || 1);
-    const lists = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "listOrdered", "listUnordered" ]
-    );
-    for (const list of lists) {
+    for (const list of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
       const ordered = (list.type === "listOrdered");
       const listItemPrefixes =
         list.children.filter((token) => (token.type === "listItemPrefix"));
@@ -49,8 +48,8 @@ module.exports = {
             startLine,
             expectedSpaces,
             actualSpaces,
-            null,
-            null,
+            undefined,
+            undefined,
             range,
             fixInfo
           );

package/lib/md031.js

@@ -2,39 +2,62 @@
 
 "use strict";
 
-const { addErrorContext, forEachLine, isBlankLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
+const { addErrorContext, isBlankLine } = require("../helpers");
+const { getTokenParentOfType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
 const codeFencePrefixRe = /^(.*?)[`~]/;
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @typedef {readonly string[]} ReadonlyStringArray */
+
+/**
+ * Adds an error for the top or bottom of a code fence.
+ *
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {ReadonlyStringArray} lines Lines of Markdown content.
+ * @param {number} lineNumber Line number.
+ * @param {boolean} top True iff top fence.
+ * @returns {void}
+ */
+function addError(onError, lines, lineNumber, top) {
+  const line = lines[lineNumber - 1];
+  const [ , prefix ] = line.match(codeFencePrefixRe) || [];
+  const fixInfo = (prefix === undefined) ? null : {
+    "lineNumber": lineNumber + (top ? 0 : 1),
+    "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
+  };
+  addErrorContext(
+    onError,
+    lineNumber,
+    line.trim(),
+    undefined,
+    undefined,
+    undefined,
+    fixInfo
+  );
+}
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD031", "blanks-around-fences" ],
   "description": "Fenced code blocks should be surrounded by blank lines",
   "tags": [ "code", "blank_lines" ],
+  "parser": "micromark",
   "function": function MD031(params, onError) {
     const listItems = params.config.list_items;
     const includeListItems = (listItems === undefined) ? true : !!listItems;
     const { lines } = params;
-    forEachLine(lineMetadata(), (line, i, inCode, onFence, inTable, inItem) => {
-      const onTopFence = (onFence > 0);
-      const onBottomFence = (onFence < 0);
-      if ((includeListItems || !inItem) &&
-          ((onTopFence && !isBlankLine(lines[i - 1])) ||
-           (onBottomFence && !isBlankLine(lines[i + 1])))) {
-        const [ , prefix ] = line.match(codeFencePrefixRe) || [];
-        const fixInfo = (prefix === undefined) ? null : {
-          "lineNumber": i + (onTopFence ? 1 : 2),
-          "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
-        };
-        addErrorContext(
-          onError,
-          i + 1,
-          lines[i].trim(),
-          null,
-          null,
-          null,
-          fixInfo);
+    for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
+      if (includeListItems || !(getTokenParentOfType(codeBlock, [ "listOrdered", "listUnordered" ]))) {
+        if (!isBlankLine(lines[codeBlock.startLine - 2])) {
+          addError(onError, lines, codeBlock.startLine, true);
+        }
+        if (!isBlankLine(lines[codeBlock.endLine]) && !isBlankLine(lines[codeBlock.endLine - 1])) {
+          addError(onError, lines, codeBlock.endLine, false);
+        }
       }
-    });
+    }
   }
 };

package/lib/md032.js

@@ -2,43 +2,20 @@
 
 "use strict";
 
-const { addErrorContext, blockquotePrefixRe, isBlankLine } =
-  require("../helpers");
-const { filterByPredicate } = require("../helpers/micromark.cjs");
+const { addErrorContextForLine, isBlankLine } = require("../helpers");
+const { filterByPredicate, nonContentTokens } = 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`
-    }
-  );
-};
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD032", "blanks-around-lists" ],
   "description": "Lists should be surrounded by blank lines",
   "tags": [ "bullet", "ul", "ol", "blank_lines" ],
+  "parser": "micromark",
   "function": function MD032(params, onError) {
     const { lines, parsers } = params;
 
@@ -55,7 +32,12 @@ module.exports = {
       // Look for a blank line above the list
       const firstIndex = list.startLine - 1;
       if (!isBlankLine(lines[firstIndex - 1])) {
-        addBlankLineError(onError, lines, firstIndex);
+        addErrorContextForLine(
+          onError,
+          // @ts-ignore
+          lines,
+          firstIndex
+        );
       }
 
       // Find the "visual" end of the list
@@ -71,7 +53,13 @@ module.exports = {
       // Look for a blank line below the list
       const lastIndex = endLine - 1;
       if (!isBlankLine(lines[lastIndex + 1])) {
-        addBlankLineError(onError, lines, lastIndex, lastIndex + 2);
+        addErrorContextForLine(
+          onError,
+          // @ts-ignore
+          lines,
+          lastIndex,
+          lastIndex + 2
+        );
       }
     }
   }

package/lib/md033.js

@@ -3,19 +3,21 @@
 "use strict";
 
 const { addError, nextLinesRe } = require("../helpers");
-const { filterByTypes, getHtmlTagInfo } =
-  require("../helpers/micromark.cjs");
+const { getHtmlTagInfo } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD033", "no-inline-html" ],
   "description": "Inline HTML",
   "tags": [ "html" ],
+  "parser": "micromark",
   "function": function MD033(params, onError) {
     let allowedElements = params.config.allowed_elements;
     allowedElements = Array.isArray(allowedElements) ? allowedElements : [];
     allowedElements = allowedElements.map((element) => element.toLowerCase());
-    const { tokens } = params.parsers.micromark;
-    for (const token of filterByTypes(tokens, [ "htmlText" ])) {
+    for (const token of filterByTypesCached([ "htmlText" ], true)) {
       const htmlTagInfo = getHtmlTagInfo(token);
       if (
         htmlTagInfo &&

package/lib/md034.js

@@ -3,18 +3,42 @@
 "use strict";
 
 const { addErrorContext } = require("../helpers");
-const { filterByPredicate, filterByTypes, getHtmlTagInfo, inHtmlFlow, parse } =
-  require("../helpers/micromark.cjs");
+const { filterByPredicate, getHtmlTagInfo, inHtmlFlow, parse } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD034", "no-bare-urls" ],
   "description": "Bare URL used",
   "tags": [ "links", "url" ],
+  "parser": "micromark",
   "function": function MD034(params, onError) {
     const literalAutolinks = (tokens) => (
       filterByPredicate(
         tokens,
-        (token) => (token.type === "literalAutolink") && !inHtmlFlow(token),
+        (token) => {
+          if ((token.type === "literalAutolink") && !inHtmlFlow(token)) {
+            // Detect and ignore https://github.com/micromark/micromark/issues/164
+            const siblings = token.parent?.children;
+              // Commented-out due to not being able to exercise in test/code coverage
+              // || micromarkTokens;
+            const index = siblings?.indexOf(token);
+            // @ts-ignore
+            const prev = siblings?.at(index - 1);
+            // @ts-ignore
+            const next = siblings?.at(index + 1);
+            return !(
+              prev &&
+              next &&
+              (prev.type === "data") &&
+              (next.type === "data") &&
+              prev.text.endsWith("<") &&
+              next.text.startsWith(">")
+            );
+          }
+          return false;
+        },
         (token) => {
           const { children } = token;
           const result = [];
@@ -46,10 +70,7 @@ module.exports = {
         }
       )
     );
-    const autoLinks = filterByTypes(
-      params.parsers.micromark.tokens,
-      [ "literalAutolink" ]
-    );
+    const autoLinks = filterByTypesCached([ "literalAutolink" ]);
     if (autoLinks.length > 0) {
       // Re-parse with correct link/image reference definition handling
       const document = params.lines.join("\n");
@@ -68,8 +89,8 @@ module.exports = {
           onError,
           token.startLine,
           token.text,
-          null,
-          null,
+          undefined,
+          undefined,
           range,
           fixInfo
         );

package/lib/md035.js

@@ -3,16 +3,18 @@
 "use strict";
 
 const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD035", "hr-style" ],
   "description": "Horizontal rule style",
   "tags": [ "hr" ],
+  "parser": "micromark",
   "function": function MD035(params, onError) {
     let style = String(params.config.style || "consistent").trim();
-    const thematicBreaks =
-      filterByTypes(params.parsers.micromark.tokens, [ "thematicBreak" ]);
+    const thematicBreaks = filterByTypesCached([ "thematicBreak" ]);
     for (const token of thematicBreaks) {
       const { startLine, text } = token;
       if (style === "consistent") {

package/lib/md036.js

@@ -3,54 +3,49 @@
 "use strict";
 
 const { addErrorContext, allPunctuation } = require("../helpers");
+const { matchAndGetTokensByType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
 
+/** @typedef {import("../helpers/micromark.cjs").TokenType} TokenType */
+/** @type {Map<TokenType, TokenType[]>} */
+const emphasisAndChildrenTypes = new Map([
+  [ "emphasis", [ "emphasisSequence", "emphasisText", "emphasisSequence" ] ],
+  [ "strong", [ "strongSequence", "strongText", "strongSequence" ] ]
+]);
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
 module.exports = {
   "names": [ "MD036", "no-emphasis-as-heading" ],
   "description": "Emphasis used instead of a heading",
   "tags": [ "headings", "emphasis" ],
+  "parser": "micromark",
   "function": function MD036(params, onError) {
     let punctuation = params.config.punctuation;
-    punctuation =
-      String((punctuation === undefined) ? allPunctuation : punctuation);
-    const re = new RegExp("[" + punctuation + "]$");
-    // eslint-disable-next-line jsdoc/require-jsdoc
-    function base(token) {
-      if (token.type === "paragraph_open") {
-        return function inParagraph(t) {
-          // Always paragraph_open/inline/paragraph_close,
-          const children = t.children.filter(function notEmptyText(child) {
-            return (child.type !== "text") || (child.content !== "");
-          });
-          if ((children.length === 3) &&
-              ((children[0].type === "strong_open") ||
-                (children[0].type === "em_open")) &&
-              (children[1].type === "text") &&
-              !re.test(children[1].content)) {
-            addErrorContext(onError, t.lineNumber,
-              children[1].content);
-          }
-          return base;
-        };
-      } else if (token.type === "blockquote_open") {
-        return function inBlockquote(t) {
-          if (t.type !== "blockquote_close") {
-            return inBlockquote;
+    punctuation = String((punctuation === undefined) ? allPunctuation : punctuation);
+    const punctuationRe = new RegExp("[" + punctuation + "]$");
+    const paragraphTokens =
+      filterByTypesCached([ "paragraph" ]).
+        filter((token) =>
+          (token.parent?.type === "content") && !token.parent?.parent && (token.children.length === 1)
+        );
+    for (const paragraphToken of paragraphTokens) {
+      const childToken = paragraphToken.children[0];
+      for (const [ emphasisType, emphasisChildrenTypes ] of emphasisAndChildrenTypes) {
+        if (childToken.type === emphasisType) {
+          const matchingTokens = matchAndGetTokensByType(childToken.children, emphasisChildrenTypes);
+          if (matchingTokens) {
+            const textToken = matchingTokens[1];
+            if (
+              (textToken.children.length === 1) &&
+              (textToken.children[0].type === "data") &&
+              !punctuationRe.test(textToken.text)
+            ) {
+              addErrorContext(onError, textToken.startLine, textToken.text);
+            }
           }
-          return base;
-        };
-      } else if (token.type === "list_item_open") {
-        return function inListItem(t) {
-          if (t.type !== "list_item_close") {
-            return inListItem;
-          }
-          return base;
-        };
+        }
       }
-      return base;
-    }
-    let state = base;
-    for (const token of params.parsers.markdownit.tokens) {
-      state = state(token);
     }
   }
 };