@alexlit/lint-kit 189.1.0 → 190.0.0

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

@@ -0,0 +1,47 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const dollarCommandRe = /^(\s*)(\$\s+)/;
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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 = codeBlock.children.filter((child) => child.type === "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.mjs

@@ -0,0 +1,43 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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.mjs

@@ -0,0 +1,77 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getHeadingStyle } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/**
+ * 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
+      }
+    );
+  }
+}
+
+/** @type {import("markdownlint").Rule[]} */
+export default [
+  {
+    "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.mjs

@@ -0,0 +1,68 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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\\]|[^# \t][^#]*?[^# \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.mjs

@@ -0,0 +1,103 @@
+// @ts-check
+
+import { addErrorDetailIf, isBlankLine } from "../helpers/helpers.cjs";
+import { getBlockQuotePrefixText, getHeadingLevel } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
+const defaultLines = 1;
+
+// eslint-disable-next-line jsdoc/reject-any-type
+const getLinesFunction = (/** @type {any} */ 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 (/** @type {MicromarkToken} */ heading) => linesArray[getHeadingLevel(heading) - 1];
+  }
+  // Coerce linesParam to a number
+  const lines = (linesParam === undefined) ? defaultLines : Number(linesParam);
+  return () => lines;
+};
+
+const getLine = (/** @type {readonly string[]} */ lines, /** @type {number} */ index, /** @type {readonly string[]} */ frontMatterLines, /** @type {boolean} */ includeFrontMatter) => {
+  if ((index >= 0) && (index < lines.length)) {
+    return lines[index];
+  }
+  if (includeFrontMatter && (frontMatterLines.length > 0) && (index < 0) && (index >= -frontMatterLines.length)) {
+    return frontMatterLines[frontMatterLines.length + index];
+  }
+  return "";
+};
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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 includeFrontMatter = !!params.config.include_front_matter;
+    const { lines, frontMatterLines } = params;
+    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
+    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(getLine(lines, startLine - 2 - i, frontMatterLines, includeFrontMatter)); i++) {
+          actualAbove++;
+        }
+        addErrorDetailIf(
+          onError,
+          startLine,
+          linesAbove,
+          actualAbove,
+          "Above",
+          line,
+          undefined,
+          {
+            "insertText": getBlockQuotePrefixText(
+              blockQuotePrefixes,
+              startLine - 1,
+              linesAbove - actualAbove
+            )
+          }
+        );
+      }
+
+      // Check lines below
+      const linesBelow = getLinesBelow(heading);
+      if (linesBelow >= 0) {
+        let actualBelow = 0;
+        for (let i = 0; (i < linesBelow) && isBlankLine(getLine(lines, endLine + i, frontMatterLines, false)); i++) {
+          actualBelow++;
+        }
+        addErrorDetailIf(
+          onError,
+          startLine,
+          linesBelow,
+          actualBelow,
+          "Below",
+          line,
+          undefined,
+          {
+            "lineNumber": endLine + 1,
+            "insertText": getBlockQuotePrefixText(
+              blockQuotePrefixes,
+              endLine + 1,
+              linesBelow - actualBelow
+            )
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,37 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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.mjs

@@ -0,0 +1,45 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getHeadingLevel, getHeadingText } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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.mjs

@@ -0,0 +1,45 @@
+// @ts-check
+
+import { addErrorContext, frontMatterHasTitle } from "../helpers/helpers.cjs";
+import { getHeadingLevel, getHeadingText, isDocfxTab, isHtmlFlowComment, nonContentTokens } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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 { tokens } = params.parsers.micromark;
+    const matchingHeadings = filterByTypesCached([ "atxHeading", "setextHeading" ])
+      .filter((heading) => (level === getHeadingLevel(heading)) && !isDocfxTab(heading));
+    if (matchingHeadings.length > 0) {
+      const foundFrontMatterTitle =
+        frontMatterHasTitle(
+          params.frontMatterLines,
+          params.config.front_matter_title
+        );
+      // Front matter title counts as a top-level heading if present
+      let hasTopLevelHeading = foundFrontMatterTitle;
+      if (!hasTopLevelHeading) {
+        // Check if the first matching heading is a top-level heading
+        const previousTokens = tokens.slice(0, tokens.indexOf(matchingHeadings[0]));
+        hasTopLevelHeading = previousTokens.every(
+          (token) => nonContentTokens.has(token.type) || isHtmlFlowComment(token)
+        );
+      }
+      if (hasTopLevelHeading) {
+        // All other matching headings are violations
+        for (const heading of matchingHeadings.slice(foundFrontMatterTitle ? 0 : 1)) {
+          addErrorContext(
+            onError,
+            heading.startLine,
+            getHeadingText(heading)
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,46 @@
+// @ts-check
+
+import { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
+  endOfLineHtmlEntityRe, escapeForRegExp } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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.mjs

@@ -0,0 +1,50 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("../helpers/micromark-helpers.cjs").TokenType[]} */
+const listTypes = [ "listOrdered", "listUnordered" ];
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD027", "no-multiple-space-blockquote" ],
+  "description": "Multiple spaces after blockquote symbol",
+  "tags": [ "blockquote", "whitespace", "indentation" ],
+  "parser": "micromark",
+  "function": function MD027(params, onError) {
+    const listItems = params.config.list_items;
+    const includeListItems = (listItems === undefined) ? true : !!listItems;
+    const { tokens } = params.parsers.micromark;
+    for (const token of filterByTypesCached([ "linePrefix" ])) {
+      const parent = token.parent;
+      const codeIndented = parent?.type === "codeIndented";
+      const siblings = parent?.children || tokens;
+      if (
+        !codeIndented &&
+        (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix") &&
+        (includeListItems || (
+          !listTypes.includes(siblings[siblings.indexOf(token) + 1]?.type) &&
+          !getParentOfType(token, listTypes)
+        ))
+      ) {
+        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/packages/config-markdownlint/node_modules/markdownlint/lib/md028.mjs

@@ -0,0 +1,39 @@
+// @ts-check
+
+import { addError } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const ignoreTypes = new Set([ "lineEnding", "listItemIndent", "linePrefix" ]);
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD028", "no-blanks-blockquote" ],
+  "description": "Blank line inside blockquote",
+  "tags": [ "blockquote", "whitespace" ],
+  "parser": "micromark",
+  "function": function MD028(params, onError) {
+    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;
+        }
+      }
+    }
+  }
+};