@alexlit/lint-kit 127.2.0 → 127.3.0

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

@@ -0,0 +1,100 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { tokenIfType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+const leftSpaceRe = /^\s(?:[^`]|$)/;
+const rightSpaceRe = /[^`]\s$/;
+const trimCodeText = (text, start, end) => {
+  text = text.replace(/^\s+$/, "");
+  if (start) {
+    text = text.replace(/^\s+?(\s`|\S)/, "$1");
+  }
+  if (end) {
+    text = text.replace(/(`\s|\S)\s+$/, "$1");
+  }
+  return text;
+};
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD038", "no-space-in-code" ],
+  "description": "Spaces inside code span elements",
+  "tags": [ "whitespace", "code" ],
+  "parser": "micromark",
+  "function": function MD038(params, onError) {
+    const codeTexts = filterByTypesCached([ "codeText" ]);
+    for (const codeText of codeTexts) {
+      const { children } = codeText;
+      const first = 0;
+      const last = children.length - 1;
+      const startSequence = tokenIfType(children[first], "codeTextSequence");
+      const endSequence = tokenIfType(children[last], "codeTextSequence");
+      const startData =
+        tokenIfType(children[first + 1], "codeTextData") ||
+        tokenIfType(children[first + 2], "codeTextData");
+      const endData =
+        tokenIfType(children[last - 1], "codeTextData") ||
+        tokenIfType(children[last - 2], "codeTextData");
+      if (startSequence && endSequence && startData && endData) {
+        const spaceLeft = leftSpaceRe.test(startData.text);
+        const spaceRight = rightSpaceRe.test(endData.text);
+        if (spaceLeft || spaceRight) {
+          let lineNumber = startSequence.startLine;
+          let range = null;
+          let fixInfo = null;
+          if (startSequence.startLine === endSequence.endLine) {
+            range = [
+              startSequence.startColumn,
+              endSequence.endColumn - startSequence.startColumn
+            ];
+            fixInfo = {
+              "editColumn": startSequence.endColumn,
+              "deleteCount": endSequence.startColumn - startSequence.endColumn,
+              "insertText": trimCodeText(startData.text, true, true)
+            };
+          } else if (spaceLeft && (startSequence.endLine === startData.startLine)) {
+            range = [
+              startSequence.startColumn,
+              startData.endColumn - startSequence.startColumn
+            ];
+            fixInfo = {
+              "editColumn": startSequence.endColumn,
+              "deleteCount": startData.endColumn - startData.startColumn,
+              "insertText": trimCodeText(startData.text, true, false)
+            };
+          } else if (spaceRight && (endData.text.trim().length > 0)) {
+            lineNumber = endSequence.endLine;
+            range = [
+              endData.startColumn,
+              endSequence.endColumn - endData.startColumn
+            ];
+            fixInfo = {
+              "editColumn": endData.startColumn,
+              "deleteCount": endData.endColumn - endData.startColumn,
+              "insertText": trimCodeText(endData.text, false, true)
+            };
+          }
+          if (range) {
+            const context = params
+              .lines[lineNumber - 1]
+              .substring(range[0] - 1, range[0] - 1 + range[1]);
+            addErrorContext(
+              onError,
+              lineNumber,
+              context,
+              spaceLeft,
+              spaceRight,
+              range,
+              fixInfo
+            );
+          }
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,83 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+const { getReferenceLinkImageData, filterByTypesCached } = require("./cache");
+
+/**
+ * Adds an error for a label space issue.
+ *
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("../helpers/micromark.cjs").Token} label Label token.
+ * @param {import("../helpers/micromark.cjs").Token} 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
+  );
+}
+
+/**
+ * Determines if a link is a valid link (and not a fake shortcut link due to parser tricks).
+ *
+ * @param {import("../helpers/micromark.cjs").Token} label Label token.
+ * @param {import("../helpers/micromark.cjs").Token} labelText LabelText token.
+ * @param {Map<string, any>} definitions Map of link definitions.
+ * @returns {boolean} True iff the link is valid.
+ */
+function validLink(label, labelText, definitions) {
+  return (label.parent?.children.length !== 1) || definitions.has(labelText.text.trim());
+}
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD039", "no-space-in-links" ],
+  "description": "Spaces inside link text",
+  "tags": [ "whitespace", "links" ],
+  "parser": "micromark",
+  "function": function MD039(params, onError) {
+    const { definitions } = getReferenceLinkImageData();
+    const labels = filterByTypesCached([ "label" ]).
+      filter((label) => label.parent?.type === "link");
+    for (const label of labels) {
+      const labelTexts = filterByTypes(
+        label.children,
+        [ "labelText" ]
+      );
+      for (const labelText of labelTexts) {
+        if (
+          (labelText.text.trimStart().length !== labelText.text.length) &&
+          validLink(label, labelText, definitions)
+        ) {
+          addLabelSpaceError(onError, label, labelText, true);
+        }
+        if (
+          (labelText.text.trimEnd().length !== labelText.text.length) &&
+          validLink(label, labelText, definitions)
+        ) {
+          addLabelSpaceError(onError, label, labelText, false);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,37 @@
+// @ts-check
+
+"use strict";
+
+const { addError, addErrorContext } = require("../helpers");
+const { getTokenTextByType, tokenIfType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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 = tokenIfType(fencedCode.children[0], "codeFencedFence");
+      if (openingFence) {
+        const { children, startLine, text } = openingFence;
+        const info = getTokenTextByType(children, "codeFencedFenceInfo");
+        if (!info) {
+          addErrorContext(onError, startLine, text);
+        } else if ((allowed.length > 0) && !allowed.includes(info)) {
+          addError(onError, startLine, `"${info}" is not allowed`);
+        }
+        if (languageOnly && getTokenTextByType(children, "codeFencedFenceMeta")) {
+          addError(onError, startLine, `Info string contains more than language: "${text}"`);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,37 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, frontMatterHasTitle } = require("../helpers");
+const { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } =
+  require("../helpers/micromark.cjs");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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 level = Number(params.config.level || 1);
+    if (!frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title)) {
+      params.parsers.micromark.tokens.
+        filter((token) => !nonContentTokens.has(token.type) && !isHtmlFlowComment(token)).
+        every((token) => {
+          let isError = true;
+          if ((token.type === "atxHeading") || (token.type === "setextHeading")) {
+            isError = (getHeadingLevel(token) !== level);
+          } else if (token.type === "htmlFlow") {
+            const htmlTexts = filterByTypes(token.children, [ "htmlText" ], true);
+            const tagInfo = (htmlTexts.length > 0) && getHtmlTagInfo(htmlTexts[0]);
+            isError = !tagInfo || (tagInfo.name.toLowerCase() !== `h${level}`);
+          }
+          if (isError) {
+            addErrorContext(onError, token.startLine, params.lines[token.startLine - 1]);
+          }
+          return false;
+        });
+    }
+  }
+};

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

@@ -0,0 +1,63 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext } = require("../helpers");
+const { getDescendantsByType } = require("../helpers/micromark.cjs");
+const { getReferenceLinkImageData, filterByTypesCached } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD042", "no-empty-links" ],
+  "description": "No empty links",
+  "tags": [ "links" ],
+  "parser": "micromark",
+  "function": function MD042(params, onError) {
+    const { definitions } = getReferenceLinkImageData();
+    const isReferenceDefinitionHash = (token) => {
+      const definition = definitions.get(token.text.trim());
+      return (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 resourceDestination = getDescendantsByType(resource, [ "resourceDestination" ]);
+      const resourceDestinationString = [
+        ...getDescendantsByType(resourceDestination, [ "resourceDestinationRaw", "resourceDestinationString" ]),
+        ...getDescendantsByType(resourceDestination, [ "resourceDestinationLiteral", "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.js

@@ -0,0 +1,73 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, addErrorDetailIf } = 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": [ "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 = () => requiredHeadings[i++] || "[None]";
+    const handleCase = (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 (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.js

@@ -0,0 +1,110 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, escapeForRegExp, withinAnyRange } =
+  require("../helpers");
+const { filterByPredicate, filterByTypes, parse } =
+  require("../helpers/micromark.cjs");
+
+const ignoredChildTypes = new Set(
+  [ "codeFencedFence", "definition", "reference", "resource" ]
+);
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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((a, 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))
+        )
+      );
+    const exclusions = [];
+    const autoLinked = 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 index = token.startColumn - 1 + match.index + leftMatch.length;
+          const length = nameMatch.length;
+          const lineIndex = token.startLine - 1;
+          if (
+            !withinAnyRange(exclusions, lineIndex, index, length) &&
+            !names.includes(nameMatch)
+          ) {
+            let urlRanges = [];
+            if (!autoLinked.has(token)) {
+              urlRanges = filterByTypes(
+                parse(token.text),
+                [ "literalAutolink" ]
+              ).map(
+                (t) => [
+                  lineIndex,
+                  token.startColumn - 1 + t.startColumn - 1,
+                  t.endColumn - t.startColumn
+                ]
+              );
+              exclusions.push(...urlRanges);
+              autoLinked.add(token);
+            }
+            if (!withinAnyRange(urlRanges, lineIndex, index, length)) {
+              const column = index + 1;
+              addErrorDetailIf(
+                onError,
+                token.startLine,
+                name,
+                nameMatch,
+                undefined,
+                undefined,
+                [ column, length ],
+                {
+                  "editColumn": column,
+                  "deleteCount": length,
+                  "insertText": name
+                }
+              );
+            }
+          }
+          exclusions.push([ lineIndex, index, length ]);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,62 @@
+// @ts-check
+
+"use strict";
+
+const { addError, getHtmlAttributeRe, nextLinesRe } = require("../helpers");
+const { filterByTypes, getHtmlTagInfo } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+const altRe = getHtmlAttributeRe("alt");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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 = filterByTypes(image.children, [ "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)
+      ) {
+        const range = [
+          startColumn,
+          text.replace(nextLinesRe, "").length
+        ];
+        addError(
+          onError,
+          startLine,
+          undefined,
+          undefined,
+          range
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,34 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+const { filterByTypesCached } = require("./cache");
+
+const tokenTypeToStyle = {
+  "codeFenced": "fenced",
+  "codeIndented": "indented"
+};
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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.js

@@ -0,0 +1,31 @@
+// @ts-check
+
+"use strict";
+
+const { addError, isBlankLine } = require("../helpers");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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.js

@@ -0,0 +1,39 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf, fencedCodeBlockStyleFor } = require("../helpers");
+const { tokenIfType } = require("../helpers/micromark.cjs");
+const { filterByTypesCached } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "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 codeFencedFence = tokenIfType(codeFenced.children[0], "codeFencedFence");
+      if (codeFencedFence) {
+        const codeFencedFenceSequence = tokenIfType(codeFencedFence.children[0], "codeFencedFenceSequence");
+        if (codeFencedFenceSequence) {
+          const { startLine, text } = codeFencedFenceSequence;
+          if (expectedStyle === "consistent") {
+            expectedStyle = fencedCodeBlockStyleFor(text);
+          }
+          addErrorDetailIf(
+            onError,
+            startLine,
+            expectedStyle,
+            fencedCodeBlockStyleFor(text)
+          );
+        }
+      }
+    }
+  }
+};