@alexlit/lint-kit 107.0.0 → 107.2.0

package/packages/config-markdownlint/node_modules/markdownlint/lib/md018.js

@@ -0,0 +1,34 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+module.exports = {
+  "names": [ "MD018", "no-missing-space-atx" ],
+  "description": "No space after hash on atx style heading",
+  "tags": [ "headings", "atx", "spaces" ],
+  "function": function MD018(params, onError) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      if (!inCode &&
+        /^#+[^# \t]/.test(line) &&
+        !/#\s*$/.test(line) &&
+        !line.startsWith("#️⃣")) {
+        const hashCount = /^#+/.exec(line)[0].length;
+        addErrorContext(
+          onError,
+          lineIndex + 1,
+          line.trim(),
+          null,
+          null,
+          [ 1, hashCount + 1 ],
+          {
+            "editColumn": hashCount + 1,
+            "insertText": " "
+          }
+        );
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md019.js

@@ -0,0 +1,39 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+module.exports = {
+  "names": [ "MD019", "no-multiple-space-atx" ],
+  "description": "Multiple spaces after hash on atx style heading",
+  "tags": [ "headings", "atx", "spaces" ],
+  "function": function MD019(params, onError) {
+    filterTokens(params, "heading_open", (token) => {
+      if (headingStyleFor(token) === "atx") {
+        const { line, lineNumber } = token;
+        const match = /^(#+)([ \t]{2,})\S/.exec(line);
+        if (match) {
+          const [
+            ,
+            { "length": hashLength },
+            { "length": spacesLength }
+          ] = match;
+          addErrorContext(
+            onError,
+            lineNumber,
+            line.trim(),
+            null,
+            null,
+            [ 1, hashLength + spacesLength + 1 ],
+            {
+              "editColumn": hashLength + 1,
+              "deleteCount": spacesLength - 1
+            }
+          );
+        }
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md020.js

@@ -0,0 +1,62 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+module.exports = {
+  "names": [ "MD020", "no-missing-space-closed-atx" ],
+  "description": "No space inside hashes on closed atx style heading",
+  "tags": [ "headings", "atx_closed", "spaces" ],
+  "function": function MD020(params, onError) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      if (!inCode) {
+        const match =
+          /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
+        if (match) {
+          const [
+            ,
+            leftHash,
+            { "length": leftSpaceLength },
+            content,
+            { "length": rightSpaceLength },
+            rightEscape,
+            rightHash,
+            { "length": trailSpaceLength }
+          ] = match;
+          const leftHashLength = leftHash.length;
+          const rightHashLength = rightHash.length;
+          const left = !leftSpaceLength;
+          const right = !rightSpaceLength || rightEscape;
+          const rightEscapeReplacement = rightEscape ? `${rightEscape} ` : "";
+          if (left || right) {
+            const range = left ?
+              [
+                1,
+                leftHashLength + 1
+              ] :
+              [
+                line.length - trailSpaceLength - rightHashLength,
+                rightHashLength + 1
+              ];
+            addErrorContext(
+              onError,
+              lineIndex + 1,
+              line.trim(),
+              left,
+              right,
+              range,
+              {
+                "editColumn": 1,
+                "deleteCount": line.length,
+                "insertText":
+                  `${leftHash} ${content} ${rightEscapeReplacement}${rightHash}`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md021.js

@@ -0,0 +1,62 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+const closedAtxRe = /^(#+)([ \t]+)([^ \t]|[^ \t].*[^ \t])([ \t]+)(#+)(\s*)$/;
+
+module.exports = {
+  "names": [ "MD021", "no-multiple-space-closed-atx" ],
+  "description": "Multiple spaces inside hashes on closed atx style heading",
+  "tags": [ "headings", "atx_closed", "spaces" ],
+  "function": function MD021(params, onError) {
+    filterTokens(params, "heading_open", (token) => {
+      if (headingStyleFor(token) === "atx_closed") {
+        const { line, lineNumber } = token;
+        const match = closedAtxRe.exec(line);
+        if (match) {
+          const [
+            ,
+            leftHash,
+            { "length": leftSpaceLength },
+            content,
+            { "length": rightSpaceLength },
+            rightHash,
+            { "length": trailSpaceLength }
+          ] = match;
+          const left = leftSpaceLength > 1;
+          const right = rightSpaceLength > 1;
+          if (left || right) {
+            const length = line.length;
+            const leftHashLength = leftHash.length;
+            const rightHashLength = rightHash.length;
+            const range = left ?
+              [
+                1,
+                leftHashLength + leftSpaceLength + 1
+              ] :
+              [
+                length - trailSpaceLength - rightHashLength - rightSpaceLength,
+                rightSpaceLength + rightHashLength + 1
+              ];
+            addErrorContext(
+              onError,
+              lineNumber,
+              line.trim(),
+              left,
+              right,
+              range,
+              {
+                "editColumn": 1,
+                "deleteCount": length,
+                "insertText": `${leftHash} ${content} ${rightHash}`
+              }
+            );
+          }
+        }
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md022.js

@@ -0,0 +1,108 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, blockquotePrefixRe, isBlankLine } =
+  require("../helpers");
+const { filterByTypes, getHeadingLevel, inHtmlFlow } =
+  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 || "")
+    .match(blockquotePrefixRe)[0]
+    .trimEnd()
+    // eslint-disable-next-line unicorn/prefer-spread
+    .concat("\n")
+    .repeat(count)
+);
+
+module.exports = {
+  "names": [ "MD022", "blanks-around-headings" ],
+  "description": "Headings should be surrounded by blank lines",
+  "tags": [ "headings", "blank_lines" ],
+  "function": function MD022(params, onError) {
+    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" ]
+    ).filter((heading) => !inHtmlFlow(heading));
+    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
+            )
+          }
+        );
+      }
+
+      // 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
+            )
+          }
+        );
+      }
+    }
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md023.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const spaceBeforeHeadingRe = /^(\s+|[>\s]+\s\s)[^>\s]/;
+
+module.exports = {
+  "names": [ "MD023", "heading-start-left" ],
+  "description": "Headings must start at the beginning of the line",
+  "tags": [ "headings", "spaces" ],
+  "function": function MD023(params, onError) {
+    filterTokens(params, "heading_open", function forToken(token) {
+      const { lineNumber, line } = token;
+      const match = line.match(spaceBeforeHeadingRe);
+      if (match) {
+        const [ prefixAndFirstChar, prefix ] = match;
+        let deleteCount = prefix.length;
+        const prefixLengthNoSpace = prefix.trimEnd().length;
+        if (prefixLengthNoSpace) {
+          deleteCount -= prefixLengthNoSpace - 1;
+        }
+        addErrorContext(
+          onError,
+          lineNumber,
+          line,
+          null,
+          null,
+          [ 1, prefixAndFirstChar.length ],
+          {
+            "editColumn": prefixLengthNoSpace + 1,
+            "deleteCount": deleteCount
+          });
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md024.js

@@ -0,0 +1,38 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachHeading } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD024", "no-duplicate-heading" ],
+  "description": "Multiple headings with the same content",
+  "tags": [ "headings" ],
+  "function": function MD024(params, onError) {
+    const siblingsOnly = !!params.config.siblings_only ||
+      !!params.config.allow_different_nesting || false;
+    const knownContents = [ null, [] ];
+    let lastLevel = 1;
+    let knownContent = knownContents[lastLevel];
+    forEachHeading(params, (heading, content) => {
+      if (siblingsOnly) {
+        const newLevel = heading.tag.slice(1);
+        while (lastLevel < newLevel) {
+          lastLevel++;
+          knownContents[lastLevel] = [];
+        }
+        while (lastLevel > newLevel) {
+          knownContents[lastLevel] = [];
+          lastLevel--;
+        }
+        knownContent = knownContents[newLevel];
+      }
+      if (knownContent.includes(content)) {
+        addErrorContext(onError, heading.lineNumber,
+          heading.line.trim());
+      } else {
+        knownContent.push(content);
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md025.js

@@ -0,0 +1,32 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, frontMatterHasTitle } =
+  require("../helpers");
+
+module.exports = {
+  "names": [ "MD025", "single-title", "single-h1" ],
+  "description": "Multiple top-level headings in the same document",
+  "tags": [ "headings" ],
+  "function": function MD025(params, onError) {
+    const level = Number(params.config.level || 1);
+    const tag = "h" + level;
+    const foundFrontMatterTitle =
+      frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      );
+    let hasTopLevelHeading = false;
+    filterTokens(params, "heading_open", function forToken(token) {
+      if (token.tag === tag) {
+        if (hasTopLevelHeading || foundFrontMatterTitle) {
+          addErrorContext(onError, token.lineNumber,
+            token.line.trim());
+        } else if (token.lineNumber === 1) {
+          hasTopLevelHeading = true;
+        }
+      }
+    });
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md026.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+"use strict";
+
+const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
+  endOfLineHtmlEntityRe, escapeForRegExp } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+
+module.exports = {
+  "names": [ "MD026", "no-trailing-punctuation" ],
+  "description": "Trailing punctuation in heading",
+  "tags": [ "headings" ],
+  "function": function MD026(params, onError) {
+    let punctuation = params.config.punctuation;
+    punctuation = String(
+      (punctuation === undefined) ? allPunctuationNoQuestion : punctuation
+    );
+    const trailingPunctuationRe =
+      new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
+    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 = startColumn + match.index;
+        const length = fullMatch.length;
+        addError(
+          onError,
+          endLine,
+          `Punctuation: '${fullMatch}'`,
+          undefined,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length
+          }
+        );
+      }
+    }
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md027.js

@@ -0,0 +1,56 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, newLineRe } = require("../helpers");
+
+const spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/;
+
+module.exports = {
+  "names": [ "MD027", "no-multiple-space-blockquote" ],
+  "description": "Multiple spaces after blockquote symbol",
+  "tags": [ "blockquote", "whitespace", "indentation" ],
+  "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
+                }
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md028.js

@@ -0,0 +1,30 @@
+// @ts-check
+
+"use strict";
+
+const { addError } = require("../helpers");
+
+module.exports = {
+  "names": [ "MD028", "no-blanks-blockquote" ],
+  "description": "Blank line inside blockquote",
+  "tags": [ "blockquote", "whitespace" ],
+  "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);
+        }
+      }
+      prevToken = token;
+      if (token.type === "blockquote_open") {
+        prevLineNumber = token.map[1] + 1;
+      }
+    }
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md029.js

@@ -0,0 +1,67 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, listItemMarkerRe, orderedListItemMarkerRe,
+  rangeFromRegExp } = require("../helpers");
+const { flattenedLists } = require("./cache");
+
+const listStyleExamples = {
+  "one": "1/1/1",
+  "ordered": "1/2/3",
+  "zero": "0/0/0"
+};
+
+module.exports = {
+  "names": [ "MD029", "ol-prefix" ],
+  "description": "Ordered list item prefix",
+  "tags": [ "ol" ],
+  "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;
+      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;
+            }
+          }
+        }
+      }
+      // Determine effective style
+      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 === "one") {
+        current = 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++;
+          }
+        }
+      }
+    }
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/md030.js

@@ -0,0 +1,61 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+module.exports = {
+  "names": [ "MD030", "list-marker-space" ],
+  "description": "Spaces after list markers",
+  "tags": [ "ol", "ul", "whitespace" ],
+  "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) {
+      const ordered = (list.type === "listOrdered");
+      const listItemPrefixes =
+        list.children.filter((token) => (token.type === "listItemPrefix"));
+      const allSingleLine =
+        (list.endLine - list.startLine + 1) === listItemPrefixes.length;
+      const expectedSpaces = ordered ?
+        (allSingleLine ? olSingle : olMulti) :
+        (allSingleLine ? ulSingle : ulMulti);
+      for (const listItemPrefix of listItemPrefixes) {
+        const range = [
+          listItemPrefix.startColumn,
+          listItemPrefix.endColumn - listItemPrefix.startColumn
+        ];
+        const listItemPrefixWhitespaces = listItemPrefix.children.filter(
+          (token) => (token.type === "listItemPrefixWhitespace")
+        );
+        for (const listItemPrefixWhitespace of listItemPrefixWhitespaces) {
+          const { endColumn, startColumn, startLine } =
+            listItemPrefixWhitespace;
+          const actualSpaces = endColumn - startColumn;
+          const fixInfo = {
+            "editColumn": startColumn,
+            "deleteCount": actualSpaces,
+            "insertText": "".padEnd(expectedSpaces)
+          };
+          addErrorDetailIf(
+            onError,
+            startLine,
+            expectedSpaces,
+            actualSpaces,
+            null,
+            null,
+            range,
+            fixInfo
+          );
+        }
+      }
+    }
+  }
+};