@alexlit/lint-kit 189.1.0 → 190.0.1

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

@@ -0,0 +1,59 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/**
+ * Adds an error for a label space issue.
+ *
+ * @param {import("markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("markdownlint").MicromarkToken} label Label token.
+ * @param {import("markdownlint").MicromarkToken} labelText LabelText token.
+ * @param {boolean} isStart True iff error is at the start of the link.
+ */
+function addLabelSpaceError(onError, label, labelText, isStart) {
+  const match = labelText.text.match(isStart ? /^[^\S\r\n]+/ : /[^\S\r\n]+$/);
+  const range = match ?
+    [
+      (isStart ? (labelText.startColumn) : (labelText.endColumn - match[0].length)),
+      match[0].length
+    ] :
+    undefined;
+  addErrorContext(
+    onError,
+    isStart ? (labelText.startLine + (match ? 0 : 1)) : (labelText.endLine - (match ? 0 : 1)),
+    label.text.replace(/\s+/g, " "),
+    isStart,
+    !isStart,
+    range,
+    range ?
+      {
+        "editColumn": range[0],
+        "deleteCount": range[1]
+      } :
+      undefined
+  );
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD039", "no-space-in-links" ],
+  "description": "Spaces inside link text",
+  "tags": [ "whitespace", "links" ],
+  "parser": "micromark",
+  "function": function MD039(params, onError) {
+    const labels = filterByTypesCached([ "label" ])
+      .filter((label) => label.parent?.type === "link");
+    for (const label of labels) {
+      const labelTexts = label.children.filter((child) => child.type === "labelText");
+      for (const labelText of labelTexts) {
+        if (labelText.text.trimStart().length !== labelText.text.length) {
+          addLabelSpaceError(onError, label, labelText, true);
+        }
+        if (labelText.text.trimEnd().length !== labelText.text.length) {
+          addLabelSpaceError(onError, label, labelText, false);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,32 @@
+// @ts-check
+
+import { addError, addErrorContext } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD040", "fenced-code-language" ],
+  "description": "Fenced code blocks should have a language specified",
+  "tags": [ "code", "language" ],
+  "parser": "micromark",
+  "function": function MD040(params, onError) {
+    let allowed = params.config.allowed_languages;
+    allowed = Array.isArray(allowed) ? allowed : [];
+    const languageOnly = !!params.config.language_only;
+    const fencedCodes = filterByTypesCached([ "codeFenced" ]);
+    for (const fencedCode of fencedCodes) {
+      const openingFence = getDescendantsByType(fencedCode, [ "codeFencedFence" ])[0];
+      const { startLine, text } = openingFence;
+      const info = getDescendantsByType(openingFence, [ "codeFencedFenceInfo" ])[0]?.text;
+      if (!info) {
+        addErrorContext(onError, startLine, text);
+      } else if ((allowed.length > 0) && !allowed.includes(info)) {
+        addError(onError, startLine, `"${info}" is not allowed`);
+      }
+      if (languageOnly && getDescendantsByType(openingFence, [ "codeFencedFenceMeta" ]).length > 0) {
+        addError(onError, startLine, `Info string contains more than language: "${text}"`);
+      }
+    }
+  }
+};

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

@@ -0,0 +1,71 @@
+// @ts-check
+
+import { addErrorContext, frontMatterHasTitle } from "../helpers/helpers.cjs";
+import { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } from "../helpers/micromark-helpers.cjs";
+
+const headingTagNameRe = /^h[1-6]$/;
+
+/**
+ * Gets the HTML tag name of an htmlFlow token.
+ *
+ * @param {import("markdownlint").MicromarkToken} token Micromark Token.
+ * @returns {string | null} Tag name.
+ */
+function getHtmlFlowTagName(token) {
+  const { children, type } = token;
+  if (type === "htmlFlow") {
+    const htmlTexts = filterByTypes(children, [ "htmlText" ], true);
+    const tagInfo = (htmlTexts.length > 0) && getHtmlTagInfo(htmlTexts[0]);
+    if (tagInfo) {
+      return tagInfo.name.toLowerCase();
+    }
+  }
+  return null;
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD041", "first-line-heading", "first-line-h1" ],
+  "description": "First line in a file should be a top-level heading",
+  "tags": [ "headings" ],
+  "parser": "micromark",
+  "function": function MD041(params, onError) {
+    const allowPreamble = !!params.config.allow_preamble;
+    const level = Number(params.config.level || 1);
+    const { tokens } = params.parsers.micromark;
+    if (
+      !frontMatterHasTitle(
+        params.frontMatterLines,
+        params.config.front_matter_title
+      )
+    ) {
+      let errorLineNumber = 0;
+      for (const token of tokens) {
+        const { startLine, type } = token;
+        if (!nonContentTokens.has(type) && !isHtmlFlowComment(token)) {
+          let tagName = null;
+          if ((type === "atxHeading") || (type === "setextHeading")) {
+            // First heading needs to have the expected level
+            if (getHeadingLevel(token) !== level) {
+              errorLineNumber = startLine;
+            }
+            break;
+          } else if ((tagName = getHtmlFlowTagName(token)) && headingTagNameRe.test(tagName)) {
+            // First HTML element needs to have an <h?> with the expected level
+            if (tagName !== `h${level}`) {
+              errorLineNumber = startLine;
+            }
+            break;
+          } else if (!allowPreamble) {
+            // First non-content needs to be a heading with the expected level
+            errorLineNumber = startLine;
+            break;
+          }
+        }
+      }
+      if (errorLineNumber > 0) {
+        addErrorContext(onError, errorLineNumber, params.lines[errorLineNumber - 1]);
+      }
+    }
+  }
+};

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

@@ -0,0 +1,58 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { getReferenceLinkImageData, filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD042", "no-empty-links" ],
+  "description": "No empty links",
+  "tags": [ "links" ],
+  "parser": "micromark",
+  "function": function MD042(params, onError) {
+    const { definitions } = getReferenceLinkImageData();
+    const isReferenceDefinitionHash = (/** @type {MicromarkToken} */ token) => {
+      const definition = definitions.get(token.text.trim());
+      return Boolean(definition && (definition[1] === "#"));
+    };
+    const links = filterByTypesCached([ "link" ]);
+    for (const link of links) {
+      const labelText = getDescendantsByType(link, [ "label", "labelText" ]);
+      const reference = getDescendantsByType(link, [ "reference" ]);
+      const resource = getDescendantsByType(link, [ "resource" ]);
+      const referenceString = getDescendantsByType(reference, [ "referenceString" ]);
+      const resourceDestinationString = getDescendantsByType(resource, [ "resourceDestination", [ "resourceDestinationLiteral", "resourceDestinationRaw" ], "resourceDestinationString" ]);
+      const hasLabelText = labelText.length > 0;
+      const hasReference = reference.length > 0;
+      const hasResource = resource.length > 0;
+      const hasReferenceString = referenceString.length > 0;
+      const hasResourceDestinationString = resourceDestinationString.length > 0;
+      let error = false;
+      if (
+        hasLabelText &&
+        ((!hasReference && !hasResource) || (hasReference && !hasReferenceString))
+      ) {
+        error = isReferenceDefinitionHash(labelText[0]);
+      } else if (hasReferenceString && !hasResourceDestinationString) {
+        error = isReferenceDefinitionHash(referenceString[0]);
+      } else if (!hasReferenceString && hasResourceDestinationString) {
+        error = (resourceDestinationString[0].text.trim() === "#");
+      } else if (!hasReferenceString && !hasResourceDestinationString) {
+        error = true;
+      }
+      if (error) {
+        addErrorContext(
+          onError,
+          link.startLine,
+          link.text,
+          undefined,
+          undefined,
+          [ link.startColumn, link.endColumn - link.startColumn ]
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,72 @@
+// @ts-check
+
+import { addErrorContext, addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getHeadingLevel, getHeadingText } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD043", "required-headings" ],
+  "description": "Required heading structure",
+  "tags": [ "headings" ],
+  "parser": "micromark",
+  "function": function MD043(params, onError) {
+    const requiredHeadings = params.config.headings;
+    if (!Array.isArray(requiredHeadings)) {
+      // Nothing to check; avoid doing any work
+      return;
+    }
+    const matchCase = params.config.match_case || false;
+    let i = 0;
+    let matchAny = false;
+    let hasError = false;
+    let anyHeadings = false;
+    const getExpected = () => String(requiredHeadings[i++] || "[None]");
+    const handleCase = (/** @type {string} */ str) => (matchCase ? str : str.toLowerCase());
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      if (!hasError) {
+        const headingText = getHeadingText(heading);
+        const headingLevel = getHeadingLevel(heading);
+        anyHeadings = true;
+        const actual = `${"".padEnd(headingLevel, "#")} ${headingText}`;
+        const expected = getExpected();
+        if (expected === "*") {
+          const nextExpected = getExpected();
+          if (handleCase(nextExpected) !== handleCase(actual)) {
+            matchAny = true;
+            i--;
+          }
+        } else if (expected === "+") {
+          matchAny = true;
+        } else if (expected === "?") {
+          // Allow current, match next
+        } else if (handleCase(expected) === handleCase(actual)) {
+          matchAny = false;
+        } else if (matchAny) {
+          i--;
+        } else {
+          addErrorDetailIf(
+            onError,
+            heading.startLine,
+            expected,
+            actual
+          );
+          hasError = true;
+        }
+      }
+    }
+    const extraHeadings = requiredHeadings.length - i;
+    if (
+      !hasError &&
+      ((extraHeadings > 1) ||
+        ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
+      (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
+    ) {
+      addErrorContext(
+        onError,
+        params.lines.length,
+        requiredHeadings[i]
+      );
+    }
+  }
+};

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

@@ -0,0 +1,110 @@
+// @ts-check
+
+import { addErrorDetailIf, escapeForRegExp, hasOverlap } from "../helpers/helpers.cjs";
+import { filterByPredicate, filterByTypes } from "../helpers/micromark-helpers.cjs";
+import { parse } from "./micromark-parse.mjs";
+
+const ignoredChildTypes = new Set(
+  [ "codeFencedFence", "definition", "reference", "resource" ]
+);
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD044", "proper-names" ],
+  "description": "Proper names should have the correct capitalization",
+  "tags": [ "spelling" ],
+  "parser": "micromark",
+  "function": function MD044(params, onError) {
+    let names = params.config.names;
+    names = Array.isArray(names) ? names : [];
+    names.sort((/** @type {string} */ a, /** @type {string} */ b) => (b.length - a.length) || a.localeCompare(b));
+    if (names.length === 0) {
+      // Nothing to check; avoid doing any work
+      return;
+    }
+    const codeBlocks = params.config.code_blocks;
+    const includeCodeBlocks =
+      (codeBlocks === undefined) ? true : !!codeBlocks;
+    const htmlElements = params.config.html_elements;
+    const includeHtmlElements =
+      (htmlElements === undefined) ? true : !!htmlElements;
+    const scannedTypes = new Set([ "data" ]);
+    if (includeCodeBlocks) {
+      scannedTypes.add("codeFlowValue");
+      scannedTypes.add("codeTextData");
+    }
+    if (includeHtmlElements) {
+      scannedTypes.add("htmlFlowData");
+      scannedTypes.add("htmlTextData");
+    }
+    const contentTokens =
+      filterByPredicate(
+        params.parsers.micromark.tokens,
+        (token) => scannedTypes.has(token.type),
+        (token) => (
+          token.children.filter((t) => !ignoredChildTypes.has(t.type))
+        )
+      );
+    /** @type {import("../helpers/helpers.cjs").FileRange[]} */
+    const exclusions = [];
+    const scannedTokens = new Set();
+    for (const name of names) {
+      const escapedName = escapeForRegExp(name);
+      const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
+      const endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
+      const namePattern = `(${startNamePattern})(${escapedName})${endNamePattern}`;
+      const nameRe = new RegExp(namePattern, "gi");
+      for (const token of contentTokens) {
+        let match = null;
+        while ((match = nameRe.exec(token.text)) !== null) {
+          const [ , leftMatch, nameMatch ] = match;
+          const column = token.startColumn + match.index + leftMatch.length;
+          const length = nameMatch.length;
+          const lineNumber = token.startLine;
+          /** @type {import("../helpers/helpers.cjs").FileRange} */
+          const nameRange = {
+            "startLine": lineNumber,
+            "startColumn": column,
+            "endLine": lineNumber,
+            "endColumn": column + length - 1
+          };
+          if (
+            !names.includes(nameMatch) &&
+            !exclusions.some((exclusion) => hasOverlap(exclusion, nameRange))
+          ) {
+            /** @type {import("../helpers/helpers.cjs").FileRange[]} */
+            let autolinkRanges = [];
+            if (!scannedTokens.has(token)) {
+              autolinkRanges = filterByTypes(parse(token.text), [ "literalAutolink" ])
+                .map((tok) => ({
+                  "startLine": lineNumber,
+                  "startColumn": token.startColumn + tok.startColumn - 1,
+                  "endLine": lineNumber,
+                  "endColumn": token.endColumn + tok.endColumn - 1
+                }));
+              exclusions.push(...autolinkRanges);
+              scannedTokens.add(token);
+            }
+            if (!autolinkRanges.some((autolinkRange) => hasOverlap(autolinkRange, nameRange))) {
+              addErrorDetailIf(
+                onError,
+                token.startLine,
+                name,
+                nameMatch,
+                undefined,
+                undefined,
+                [ column, length ],
+                {
+                  "editColumn": column,
+                  "deleteCount": length,
+                  "insertText": name
+                }
+              );
+            }
+          }
+          exclusions.push(nameRange);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,61 @@
+// @ts-check
+
+import { addError, getHtmlAttributeRe, nextLinesRe } from "../helpers/helpers.cjs";
+import { getHtmlTagInfo, getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const altRe = getHtmlAttributeRe("alt");
+const ariaHiddenRe = getHtmlAttributeRe("aria-hidden");
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD045", "no-alt-text" ],
+  "description": "Images should have alternate text (alt text)",
+  "tags": [ "accessibility", "images" ],
+  "parser": "micromark",
+  "function": function MD045(params, onError) {
+    // Process Markdown images
+    const images = filterByTypesCached([ "image" ]);
+    for (const image of images) {
+      const labelTexts = getDescendantsByType(image, [ "label", "labelText" ]);
+      if (labelTexts.some((labelText) => labelText.text.length === 0)) {
+        const range = (image.startLine === image.endLine) ?
+          [ image.startColumn, image.endColumn - image.startColumn ] :
+          undefined;
+        addError(
+          onError,
+          image.startLine,
+          undefined,
+          undefined,
+          range
+        );
+      }
+    }
+
+    // Process HTML images
+    const htmlTexts = filterByTypesCached([ "htmlText" ], true);
+    for (const htmlText of htmlTexts) {
+      const { startColumn, startLine, text } = htmlText;
+      const htmlTagInfo = getHtmlTagInfo(htmlText);
+      if (
+        htmlTagInfo &&
+        !htmlTagInfo.close &&
+        (htmlTagInfo.name.toLowerCase() === "img") &&
+        !altRe.test(text) &&
+        (ariaHiddenRe.exec(text)?.[1].toLowerCase() !== "true")
+      ) {
+        const range = [
+          startColumn,
+          text.replace(nextLinesRe, "").length
+        ];
+        addError(
+          onError,
+          startLine,
+          undefined,
+          undefined,
+          range
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,31 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+
+const tokenTypeToStyle = (/** @type {MicromarkTokenType} */ tokenType) => (tokenType === "codeFenced") ? "fenced" : "indented";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD046", "code-block-style" ],
+  "description": "Code block style",
+  "tags": [ "code" ],
+  "parser": "micromark",
+  "function": function MD046(params, onError) {
+    let expectedStyle = String(params.config.style || "consistent");
+    for (const token of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      const { startLine, type } = token;
+      if (expectedStyle === "consistent") {
+        expectedStyle = tokenTypeToStyle(type);
+      }
+      addErrorDetailIf(
+        onError,
+        startLine,
+        expectedStyle,
+        tokenTypeToStyle(type)
+      );
+    }
+  }
+};

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

@@ -0,0 +1,28 @@
+// @ts-check
+
+import { addError, isBlankLine } from "../helpers/helpers.cjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD047", "single-trailing-newline" ],
+  "description": "Files should end with a single newline character",
+  "tags": [ "blank_lines" ],
+  "parser": "none",
+  "function": function MD047(params, onError) {
+    const lastLineNumber = params.lines.length;
+    const lastLine = params.lines[lastLineNumber - 1];
+    if (!isBlankLine(lastLine)) {
+      addError(
+        onError,
+        lastLineNumber,
+        undefined,
+        undefined,
+        [ lastLine.length, 1 ],
+        {
+          "insertText": "\n",
+          "editColumn": lastLine.length + 1
+        }
+      );
+    }
+  }
+};

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

@@ -0,0 +1,47 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/**
+ * Return the string representation of a fence markup character.
+ *
+ * @param {string} markup Fence string.
+ * @returns {"tilde" | "backtick"} String representation.
+ */
+function fencedCodeBlockStyleFor(markup) {
+  switch (markup[0]) {
+    case "~":
+      return "tilde";
+    default:
+      return "backtick";
+  }
+};
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD048", "code-fence-style" ],
+  "description": "Code fence style",
+  "tags": [ "code" ],
+  "parser": "micromark",
+  "function": function MD048(params, onError) {
+    const style = String(params.config.style || "consistent");
+    let expectedStyle = style;
+    const codeFenceds = filterByTypesCached([ "codeFenced" ]);
+    for (const codeFenced of codeFenceds) {
+      const codeFencedFenceSequence =
+        getDescendantsByType(codeFenced, [ "codeFencedFence", "codeFencedFenceSequence" ])[0];
+      const { startLine, text } = codeFencedFenceSequence;
+      if (expectedStyle === "consistent") {
+        expectedStyle = fencedCodeBlockStyleFor(text);
+      }
+      addErrorDetailIf(
+        onError,
+        startLine,
+        expectedStyle,
+        fencedCodeBlockStyleFor(text)
+      );
+    }
+  }
+};