@alexlit/lint-kit 214.0.1 → 214.2.0

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

@@ -0,0 +1,63 @@
+// @ts-check
+
+import { re } from "re2js";
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const startRe = re`^[^\S\r\n]+`;
+const endRe = re`[^\S\r\n]+$`;
+
+/**
+ * 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 = (isStart ? startRe : endRe).exec(labelText.text);
+  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,126 @@
+// @ts-check
+
+import { addError, addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getHeadingLevel, getHeadingText } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+export const headingsItemsRe = /^(?:[*+?]|\^+|[#%]{1,6}\s+\S.*)$/u;
+const prefixedHeadingPartsRe = /^([#%]{1,6})\s+(\S.*)$/u;
+const loopHeadingRe = /^\^+$/u;
+const canMatchNothingHeadingsRe = /^(?:\*|\^+)$/u;
+const maximumLoopsAllowed = 1000;
+
+const headingIsExpected = (/** @type {string} */ actual, /** @type {string} */ expected, /** @type {boolean} */ matchCase) => {
+  if (expected.startsWith("%")) {
+    // Regular expression comparison
+    const [ , actualLevel, actualText ] = prefixedHeadingPartsRe.exec(actual) || [];
+    const [ , expectedLevel, expectedText ] = prefixedHeadingPartsRe.exec(expected) || [];
+    return (
+      (actualLevel.length === expectedLevel.length) &&
+      // eslint-disable-next-line unicorn/no-unreadable-new-expression
+      (new RegExp(expectedText, `${matchCase ? "" : "i"}u`)).test(actualText)
+    );
+  }
+  // Text comparison
+  const actualLower = matchCase ? actual : actual.toLowerCase();
+  const expectedLower = matchCase ? expected : expected.toLowerCase();
+  return actualLower === expectedLower;
+};
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD043", "required-headings" ],
+  "description": "Required heading structure",
+  "tags": [ "headings" ],
+  "parser": "micromark",
+  "function": function MD043(params, onError) {
+    /** @type {string[] | null | undefined} */
+    const headings = params.config.headings;
+    if (!headings) {
+      return;
+    }
+    const requiredHeadings = headings.map((heading) => headingsItemsRe.test(heading) ? heading : "[Invalid syntax]");
+    const matchCase = Boolean(params.config.match_case);
+    let i = 0;
+    let remainingLoopsAllowed = maximumLoopsAllowed;
+    let allowAnyMatchFallback = false;
+    let hasError = false;
+    const getExpected = (/** @type {boolean} */ skipLoopHeadings) => {
+      let expected = null;
+      do {
+        expected = requiredHeadings[i++] || "[No heading]";
+        // eslint-disable-next-line no-unmodified-loop-condition
+      } while (skipLoopHeadings && loopHeadingRe.test(expected));
+      return expected;
+    };
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const headingText = getHeadingText(heading);
+      const headingLevel = getHeadingLevel(heading);
+      const actual = `${"".padEnd(headingLevel, "#")} ${headingText}`;
+      let expected = getExpected(false);
+      if (expected.startsWith("^")) {
+        // Handle loop
+        const current = i;
+        const nextExpected = getExpected(true);
+        if (headingIsExpected(actual, nextExpected, matchCase)) {
+          // No need to loop (again)
+          expected = nextExpected;
+        } else {
+          // Try to loop to previous matching marker
+          remainingLoopsAllowed--;
+          let j = current - 2;
+          for (; j >= 0; j--) {
+            if (requiredHeadings[j] === expected) {
+              // Perform loop
+              i = j + 1;
+              expected = getExpected(false);
+              break;
+            }
+          }
+          if (j < 0) {
+            // No matching loop marker
+            expected = nextExpected;
+          }
+        }
+      }
+      if (remainingLoopsAllowed < 0) {
+        // Too many loops performed
+        addError(onError, heading.startLine, "Too many loops", `Limit: ${maximumLoopsAllowed}`);
+        hasError = true;
+        break;
+      } else if (expected === "*") {
+        // Handle "zero or more of anything"
+        const nextExpected = getExpected(true);
+        if (!headingIsExpected(actual, nextExpected, matchCase)) {
+          allowAnyMatchFallback = true;
+          i--;
+        }
+      } else if (expected === "+") {
+        // Handle "one or more of anything"
+        allowAnyMatchFallback = true;
+      } else if (expected === "?") {
+        // Handle "exactly one of anything"
+        // Nothing to do
+      } else if (headingIsExpected(actual, expected, matchCase)) {
+        // Handle successful match
+        allowAnyMatchFallback = false;
+      } else if (allowAnyMatchFallback) {
+        // Handle "anything" match by restoring index
+        i--;
+      } else {
+        // Report heading mismatch
+        addErrorDetailIf(onError, heading.startLine, expected, actual);
+        hasError = true;
+        break;
+      }
+    }
+    const remainingRequiredHeadings = requiredHeadings.slice(i).filter((heading) => !canMatchNothingHeadingsRe.test(heading));
+    if (
+      !hasError &&
+      (remainingRequiredHeadings.length > 0)
+    ) {
+      // Report unmatched heading(s)
+      addErrorDetailIf(onError, params.lines.length, remainingRequiredHeadings[0], "[End of file]");
+    }
+  }
+};

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) || !!codeBlocks;
+    const htmlElements = params.config.html_elements;
+    const includeHtmlElements =
+      (htmlElements === undefined) || !!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,45 @@
+// @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 { startLine, text } = getDescendantsByType(codeFenced, [ "codeFencedFence", "codeFencedFenceSequence" ])[0];
+      if (expectedStyle === "consistent") {
+        expectedStyle = fencedCodeBlockStyleFor(text);
+      }
+      addErrorDetailIf(
+        onError,
+        startLine,
+        expectedStyle,
+        fencedCodeBlockStyleFor(text)
+      );
+    }
+  }
+};