@alexlit/lint-kit 110.1.0 → 110.2.0

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

@@ -0,0 +1,57 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const dollarCommandRe = /^(\s*)(\$\s+)/;
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD014", "commands-show-output" ],
+  "description": "Dollar signs used before commands without showing output",
+  "tags": [ "code" ],
+  "parser": "markdownit",
+  "function": function MD014(params, onError) {
+    for (const type of [ "code_block", "fence" ]) {
+      filterTokens(params, type, (token) => {
+        const margin = (token.type === "fence") ? 1 : 0;
+        const dollarInstances = [];
+        let allDollars = true;
+        for (let i = token.map[0] + margin; i < token.map[1] - margin; i++) {
+          const line = params.lines[i];
+          const lineTrim = line.trim();
+          if (lineTrim) {
+            const match = dollarCommandRe.exec(line);
+            if (match) {
+              const column = match[1].length + 1;
+              const length = match[2].length;
+              dollarInstances.push([ i, lineTrim, column, length ]);
+            } else {
+              allDollars = false;
+            }
+          }
+        }
+        if (allDollars) {
+          for (const instance of dollarInstances) {
+            const [ i, lineTrim, column, length ] = instance;
+            addErrorContext(
+              onError,
+              // @ts-ignore
+              i + 1,
+              lineTrim,
+              null,
+              null,
+              [ column, length ],
+              {
+                "editColumn": column,
+                "deleteCount": length
+              }
+            );
+          }
+        }
+      });
+    }
+  }
+};

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

@@ -0,0 +1,38 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD018", "no-missing-space-atx" ],
+  "description": "No space after hash on atx style heading",
+  "tags": [ "headings", "atx", "spaces" ],
+  "parser": "none",
+  "function": function MD018(params, onError) {
+    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
+      if (!inCode &&
+        /^#+[^# \t]/.test(line) &&
+        !/#\s*$/.test(line) &&
+        !line.startsWith("#️⃣")) {
+        // @ts-ignore
+        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,42 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD019", "no-multiple-space-atx" ],
+  "description": "Multiple spaces after hash on atx style heading",
+  "tags": [ "headings", "atx", "spaces" ],
+  "parser": "markdownit",
+  "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,65 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachLine } = require("../helpers");
+const { lineMetadata } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD020", "no-missing-space-closed-atx" ],
+  "description": "No space inside hashes on closed atx style heading",
+  "tags": [ "headings", "atx_closed", "spaces" ],
+  "parser": "none",
+  "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,65 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, headingStyleFor } =
+  require("../helpers");
+
+const closedAtxRe = /^(#+)([ \t]+)([^ \t]|[^ \t].*[^ \t])([ \t]+)(#+)(\s*)$/;
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD021", "no-multiple-space-closed-atx" ],
+  "description": "Multiple spaces inside hashes on closed atx style heading",
+  "tags": [ "headings", "atx_closed", "spaces" ],
+  "parser": "markdownit",
+  "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,116 @@
+// @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)
+);
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD022", "blanks-around-headings" ],
+  "description": "Headings should be surrounded by blank lines",
+  "tags": [ "headings", "blank_lines" ],
+  "parser": "micromark",
+  "function": function MD022(params, onError) {
+    const getLinesAbove = getLinesFunction(params.config.lines_above);
+    const getLinesBelow = getLinesFunction(params.config.lines_below);
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const { lines } = params;
+    const headings = filterByTypes(
+      micromarkTokens,
+      [ "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,41 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens } = require("../helpers");
+
+const spaceBeforeHeadingRe = /^(\s+|[>\s]+\s\s)[^>\s]/;
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD023", "heading-start-left" ],
+  "description": "Headings must start at the beginning of the line",
+  "tags": [ "headings", "spaces" ],
+  "parser": "markdownit",
+  "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,45 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, forEachHeading } = require("../helpers");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD024", "no-duplicate-heading" ],
+  "description": "Multiple headings with the same content",
+  "tags": [ "headings" ],
+  "parser": "markdownit",
+  "function": function MD024(params, onError) {
+    const siblingsOnly = !!params.config.siblings_only || 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];
+      }
+      // @ts-ignore
+      if (knownContent.includes(content)) {
+        addErrorContext(
+          onError,
+          heading.lineNumber,
+          heading.line.trim()
+        );
+      } else {
+        // @ts-ignore
+        knownContent.push(content);
+      }
+    });
+  }
+};

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

@@ -0,0 +1,35 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, filterTokens, frontMatterHasTitle } =
+  require("../helpers");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD025", "single-title", "single-h1" ],
+  "description": "Multiple top-level headings in the same document",
+  "tags": [ "headings" ],
+  "parser": "markdownit",
+  "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,54 @@
+// @ts-check
+
+"use strict";
+
+const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
+  endOfLineHtmlEntityRe, escapeForRegExp } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD026", "no-trailing-punctuation" ],
+  "description": "Trailing punctuation in heading",
+  "tags": [ "headings" ],
+  "parser": "micromark",
+  "function": function MD026(params, onError) {
+    let punctuation = params.config.punctuation;
+    punctuation = String(
+      (punctuation === undefined) ? allPunctuationNoQuestion : punctuation
+    );
+    const trailingPunctuationRe =
+      new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const headings = filterByTypes(micromarkTokens, [ "atxHeadingText", "setextHeadingText" ]);
+    for (const heading of headings) {
+      const { endColumn, endLine, text } = heading;
+      const match = trailingPunctuationRe.exec(text);
+      if (
+        match &&
+        !endOfLineHtmlEntityRe.test(text) &&
+        !endOfLineGemojiCodeRe.test(text)
+      ) {
+        const fullMatch = match[0];
+        const length = fullMatch.length;
+        const column = endColumn - 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,42 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": ["MD027", "no-multiple-space-blockquote"],
+  "description": "Multiple spaces after blockquote symbol",
+  "tags": ["blockquote", "whitespace", "indentation"],
+  "parser": "micromark",
+  "function": function MD027(params, onError) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    for (const token of filterByTypes(micromarkTokens, [ "linePrefix" ])) {
+      const siblings = token.parent?.children || micromarkTokens;
+      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,
+          null,
+          null,
+          [ startColumn, length ],
+          {
+            "editColumn": startColumn,
+            "deleteCount": length
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,47 @@
+// @ts-check
+
+"use strict";
+
+const { addError } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+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) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    for (const token of filterByTypes(micromarkTokens, [ "blockQuote" ])) {
+      const errorLineNumbers = [];
+      const siblings = token.parent?.children || micromarkTokens;
+      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;
+        }
+      }
+    }
+  }
+};