@alexlit/lint-kit 127.2.0 → 127.4.0

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

@@ -0,0 +1,105 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+const { getReferenceLinkImageData } = require("./cache");
+const { addRangeToSet, getDescendantsByType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+const longLineRePrefix = "^.{";
+const longLineRePostfixRelaxed = "}.*\\s.*$";
+const longLineRePostfixStrict = "}.+$";
+const sternModeRe = /^(?:[#>\s]*\s)?\S*$/;
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD013", "line-length" ],
+  "description": "Line length",
+  "tags": [ "line_length" ],
+  "parser": "micromark",
+  "function": function MD013(params, onError) {
+    const lineLength = Number(params.config.line_length || 80);
+    const headingLineLength =
+      Number(params.config.heading_line_length || lineLength);
+    const codeLineLength =
+      Number(params.config.code_block_line_length || lineLength);
+    const strict = !!params.config.strict;
+    const stern = !!params.config.stern;
+    const longLineRePostfix =
+      (strict || stern) ? longLineRePostfixStrict : longLineRePostfixRelaxed;
+    const longLineRe =
+      new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
+    const longHeadingLineRe =
+      new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
+    const longCodeLineRe =
+      new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
+    const codeBlocks = params.config.code_blocks;
+    const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
+    const tables = params.config.tables;
+    const includeTables = (tables === undefined) ? true : !!tables;
+    const headings = params.config.headings;
+    const includeHeadings = (headings === undefined) ? true : !!headings;
+    const headingLineNumbers = new Set();
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      addRangeToSet(headingLineNumbers, heading.startLine, heading.endLine);
+    }
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
+    const tableLineNumbers = new Set();
+    for (const table of filterByTypesCached([ "table" ])) {
+      addRangeToSet(tableLineNumbers, table.startLine, table.endLine);
+    }
+    const linkLineNumbers = new Set();
+    for (const link of filterByTypesCached([ "autolink", "image", "link", "literalAutolink" ])) {
+      addRangeToSet(linkLineNumbers, link.startLine, link.endLine);
+    }
+    const paragraphDataLineNumbers = new Set();
+    for (const paragraph of filterByTypesCached([ "paragraph" ])) {
+      for (const data of getDescendantsByType(paragraph, [ "data" ])) {
+        addRangeToSet(paragraphDataLineNumbers, data.startLine, data.endLine);
+      }
+    }
+    const linkOnlyLineNumbers = new Set();
+    for (const lineNumber of linkLineNumbers) {
+      if (!paragraphDataLineNumbers.has(lineNumber)) {
+        linkOnlyLineNumbers.add(lineNumber);
+      }
+    }
+    const definitionLineIndices = new Set(getReferenceLinkImageData().definitionLineIndices);
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
+      const lineNumber = lineIndex + 1;
+      const isHeading = headingLineNumbers.has(lineNumber);
+      const inCode = codeBlockLineNumbers.has(lineNumber);
+      const inTable = tableLineNumbers.has(lineNumber);
+      const length = inCode ?
+        codeLineLength :
+        (isHeading ? headingLineLength : lineLength);
+      const lengthRe = inCode ?
+        longCodeLineRe :
+        (isHeading ? longHeadingLineRe : longLineRe);
+      if ((includeCodeBlocks || !inCode) &&
+          (includeTables || !inTable) &&
+          (includeHeadings || !isHeading) &&
+          !definitionLineIndices.has(lineIndex) &&
+          (strict ||
+           (!(stern && sternModeRe.test(line)) &&
+            !linkOnlyLineNumbers.has(lineNumber))) &&
+          lengthRe.test(line)) {
+        addErrorDetailIf(
+          onError,
+          lineNumber,
+          length,
+          line.length,
+          undefined,
+          undefined,
+          [ length + 1, line.length - length ]
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,54 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+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": "micromark",
+  "function": function MD014(params, onError) {
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      const codeFlowValues = filterByTypes(
+        codeBlock.children,
+        [ "codeFlowValue" ]
+      );
+      const dollarMatches = codeFlowValues.
+        map((codeFlowValue) => ({
+          "result": codeFlowValue.text.match(dollarCommandRe),
+          "startColumn": codeFlowValue.startColumn,
+          "startLine": codeFlowValue.startLine,
+          "text": codeFlowValue.text
+        })).
+        filter((dollarMatch) => dollarMatch.result);
+      if (dollarMatches.length === codeFlowValues.length) {
+        for (const dollarMatch of dollarMatches) {
+          // @ts-ignore
+          const column = dollarMatch.startColumn + dollarMatch.result[1].length;
+          // @ts-ignore
+          const length = dollarMatch.result[2].length;
+          addErrorContext(
+            onError,
+            dollarMatch.startLine,
+            dollarMatch.text,
+            undefined,
+            undefined,
+            [ column, length ],
+            {
+              "editColumn": column,
+              "deleteCount": length
+            }
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,46 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = 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": "micromark",
+  "function": function MD018(params, onError) {
+    const { lines } = params;
+    const ignoreBlockLineNumbers = new Set();
+    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow" ])) {
+      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
+    }
+    for (const [ lineIndex, line ] of lines.entries()) {
+      if (
+        !ignoreBlockLineNumbers.has(lineIndex + 1) &&
+        /^#+[^# \t]/.test(line) &&
+        !/#\s*$/.test(line) &&
+        !line.startsWith("#️⃣")
+      ) {
+        // @ts-ignore
+        const hashCount = /^#+/.exec(line)[0].length;
+        addErrorContext(
+          onError,
+          lineIndex + 1,
+          line.trim(),
+          undefined,
+          undefined,
+          [ 1, hashCount + 1 ],
+          {
+            "editColumn": hashCount + 1,
+            "insertText": " "
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,80 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers/helpers");
+const { getHeadingStyle } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+/**
+ * Validate heading sequence and whitespace length at start or end.
+ *
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("./markdownlint").MicromarkToken} heading ATX heading token.
+ * @param {number} delta Direction to scan.
+ * @returns {void}
+ */
+function validateHeadingSpaces(onError, heading, delta) {
+  const { children, startLine, text } = heading;
+  let index = (delta > 0) ? 0 : (children.length - 1);
+  while (
+    children[index] &&
+    (children[index].type !== "atxHeadingSequence")
+  ) {
+    index += delta;
+  }
+  const headingSequence = children[index];
+  const whitespace = children[index + delta];
+  if (
+    (headingSequence?.type === "atxHeadingSequence") &&
+    (whitespace?.type === "whitespace") &&
+    (whitespace.text.length > 1)
+  ) {
+    const column = whitespace.startColumn + 1;
+    const length = whitespace.endColumn - column;
+    addErrorContext(
+      onError,
+      startLine,
+      text.trim(),
+      delta > 0,
+      delta < 0,
+      [ column, length ],
+      {
+        "editColumn": column,
+        "deleteCount": length
+      }
+    );
+  }
+}
+
+// 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": "micromark",
+    "function": function MD019(params, onError) {
+      const atxHeadings = filterByTypesCached([ "atxHeading" ])
+        .filter((heading) => getHeadingStyle(heading) === "atx");
+      for (const atxHeading of atxHeadings) {
+        validateHeadingSpaces(onError, atxHeading, 1);
+      }
+    }
+  },
+  {
+    "names": [ "MD021", "no-multiple-space-closed-atx" ],
+    "description": "Multiple spaces inside hashes on closed atx style heading",
+    "tags": [ "headings", "atx_closed", "spaces" ],
+    "parser": "micromark",
+    "function": function MD021(params, onError) {
+      const atxClosedHeadings = filterByTypesCached([ "atxHeading" ])
+        .filter((heading) => getHeadingStyle(heading) === "atx_closed");
+      for (const atxClosedHeading of atxClosedHeadings) {
+        validateHeadingSpaces(onError, atxClosedHeading, 1);
+        validateHeadingSpaces(onError, atxClosedHeading, -1);
+      }
+    }
+  }
+];

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

@@ -0,0 +1,71 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { addRangeToSet } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = 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": "micromark",
+  "function": function MD020(params, onError) {
+    const { lines } = params;
+    const ignoreBlockLineNumbers = new Set();
+    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow" ])) {
+      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
+    }
+    for (const [ lineIndex, line ] of lines.entries()) {
+      if (!ignoreBlockLineNumbers.has(lineIndex + 1)) {
+        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/md022.js

@@ -0,0 +1,106 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, blockquotePrefixRe, isBlankLine } = require("../helpers");
+const { getHeadingLevel } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+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);
+    const { lines } = params;
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      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,
+          undefined,
+          {
+            "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,
+          undefined,
+          {
+            "lineNumber": endLine + 1,
+            "insertText": getBlockQuote(
+              lines[endLine],
+              linesBelow - actualBelow
+            )
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,40 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { filterByTypesCached } = require("./cache");
+
+// 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": "micromark",
+  "function": function MD023(params, onError) {
+    const headings = filterByTypesCached([ "atxHeading", "linePrefix", "setextHeading" ]);
+    for (let i = 0; i < headings.length - 1; i++) {
+      if (
+        (headings[i].type === "linePrefix") &&
+        (headings[i + 1].type !== "linePrefix") &&
+        (headings[i].startLine === headings[i + 1].startLine)
+      ) {
+        const { endColumn, startColumn, startLine } = headings[i];
+        const length = endColumn - startColumn;
+        addErrorContext(
+          onError,
+          startLine,
+          params.lines[startLine - 1],
+          true,
+          false,
+          [ startColumn, length ],
+          {
+            "editColumn": startColumn,
+            "deleteCount": length
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,48 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { getHeadingLevel, getHeadingText } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+// 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": "micromark",
+  "function": function MD024(params, onError) {
+    const siblingsOnly = !!params.config.siblings_only || false;
+    const knownContents = [ null, [] ];
+    let lastLevel = 1;
+    let knownContent = knownContents[lastLevel];
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const headingText = getHeadingText(heading);
+      if (siblingsOnly) {
+        const newLevel = getHeadingLevel(heading);
+        while (lastLevel < newLevel) {
+          lastLevel++;
+          knownContents[lastLevel] = [];
+        }
+        while (lastLevel > newLevel) {
+          knownContents[lastLevel] = [];
+          lastLevel--;
+        }
+        knownContent = knownContents[newLevel];
+      }
+      // @ts-ignore
+      if (knownContent.includes(headingText)) {
+        addErrorContext(
+          onError,
+          heading.startLine,
+          headingText.trim()
+        );
+      } else {
+        // @ts-ignore
+        knownContent.push(headingText);
+      }
+    }
+  }
+};

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

@@ -0,0 +1,40 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, frontMatterHasTitle } = require("../helpers");
+const { getHeadingLevel, getHeadingText } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+// 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": "micromark",
+  "function": function MD025(params, onError) {
+    const level = Number(params.config.level || 1);
+    const foundFrontMatterTitle =
+      frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      );
+    let hasTopLevelHeading = false;
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const headingLevel = getHeadingLevel(heading);
+      if (headingLevel === level) {
+        if (hasTopLevelHeading || foundFrontMatterTitle) {
+          const headingText = getHeadingText(heading);
+          addErrorContext(
+            onError,
+            heading.startLine,
+            headingText
+          );
+        } else if (heading.startLine === 1) {
+          hasTopLevelHeading = true;
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,49 @@
+// @ts-check
+
+"use strict";
+
+const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
+  endOfLineHtmlEntityRe, escapeForRegExp } = require("../helpers");
+const { filterByTypesCached } = require("./cache");
+
+// 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) + "]+$");
+    const headings = filterByTypesCached([ "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,37 @@
+// @ts-check
+
+"use strict";
+
+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"],
+  "description": "Multiple spaces after blockquote symbol",
+  "tags": ["blockquote", "whitespace", "indentation"],
+  "parser": "micromark",
+  "function": function MD027(params, onError) {
+    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
+          }
+        );
+      }
+    }
+  }
+};