@alexlit/lint-kit 112.3.4 → 113.0.0

package/packages/config-markdownlint/node_modules/markdownlint/lib/md049-md050.js

@@ -0,0 +1,108 @@
+// @ts-check
+
+"use strict";
+
+const { addError, emphasisOrStrongStyleFor } = require("../helpers");
+const { filterByPredicate, tokenIfType } = require("../helpers/micromark.cjs");
+
+const intrawordRe = /^\w$/;
+
+/**
+ * @param {import("./markdownlint").RuleParams} params Rule parameters.
+ * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("markdownlint-micromark").TokenType} type Token type.
+ * @param {import("markdownlint-micromark").TokenType} typeSequence Token sequence type.
+ * @param {"*" | "**"} asterisk Asterisk kind.
+ * @param {"_" | "__"} underline Underline kind.
+ * @param {"asterisk" | "consistent" | "underscore"} style Style string.
+ */
+const impl =
+  (params, onError, type, typeSequence, asterisk, underline, style = "consistent") => {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const { lines } = params;
+    const emphasisTokens = filterByPredicate(
+      micromarkTokens,
+      (token) => token.type === type,
+      (token) => ((token.type === "htmlFlow") ? [] : token.children)
+    );
+    for (const token of emphasisTokens) {
+      const { children } = token;
+      const startSequence = tokenIfType(children[0], typeSequence);
+      const endSequence = tokenIfType(children[children.length - 1], typeSequence);
+      if (startSequence && endSequence) {
+        const markupStyle = emphasisOrStrongStyleFor(startSequence.text);
+        if (style === "consistent") {
+          style = markupStyle;
+        }
+        if (style !== markupStyle) {
+          const underscoreIntraword = (style === "underscore") && (
+            intrawordRe.test(
+              lines[startSequence.startLine - 1][startSequence.startColumn - 2]
+            ) ||
+            intrawordRe.test(
+              lines[endSequence.endLine - 1][endSequence.endColumn - 1]
+            )
+          );
+          if (!underscoreIntraword) {
+            for (const sequence of [ startSequence, endSequence ]) {
+              addError(
+                onError,
+                sequence.startLine,
+                `Expected: ${style}; Actual: ${markupStyle}`,
+                undefined,
+                [ sequence.startColumn, sequence.text.length ],
+                {
+                  "editColumn": sequence.startColumn,
+                  "deleteCount": sequence.text.length,
+                  "insertText": (style === "asterisk") ? asterisk : underline
+                }
+              );
+            }
+          }
+        }
+      }
+    }
+  };
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule[] */
+module.exports = [
+  {
+    "names": [ "MD049", "emphasis-style" ],
+    "description": "Emphasis style",
+    "tags": [ "emphasis" ],
+    "parser": "micromark",
+    "function": function MD049(params, onError) {
+      return impl(
+        params,
+        onError,
+        "emphasis",
+        "emphasisSequence",
+        "*",
+        "_",
+        params.config.style || undefined
+      );
+    }
+  },
+  {
+    "names": [ "MD050", "strong-style" ],
+    "description": "Strong style",
+    "tags": [ "emphasis" ],
+    "parser": "micromark",
+    "function": function MD050(params, onError) {
+      return impl(
+        params,
+        onError,
+        "strong",
+        "strongSequence",
+        "**",
+        "__",
+        params.config.style || undefined
+      );
+    }
+  }
+];

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

@@ -0,0 +1,176 @@
+// @ts-check
+
+"use strict";
+
+const { addError, addErrorDetailIf, getHtmlAttributeRe } =
+  require("../helpers");
+const { filterByPredicate, filterByTypes, getHtmlTagInfo } =
+  require("../helpers/micromark.cjs");
+
+// Regular expression for identifying HTML anchor names
+const idRe = getHtmlAttributeRe("id");
+const nameRe = getHtmlAttributeRe("name");
+const anchorRe = /\{(#[a-z\d]+(?:[-_][a-z\d]+)*)\}/gu;
+const lineFragmentRe = /^#(?:L\d+(?:C\d+)?-L\d+(?:C\d+)?|L\d+)$/;
+
+// Sets for filtering heading tokens during conversion
+const childrenExclude = new Set([ "image", "reference", "resource" ]);
+const tokensInclude = new Set(
+  [ "characterEscapeValue", "codeTextData", "data", "mathTextData" ]
+);
+
+/**
+ * Converts a Markdown heading into an HTML fragment according to the rules
+ * used by GitHub.
+ *
+ * @param {import("../helpers/micromark.cjs").Token} headingText Heading text token.
+ * @returns {string} Fragment string for heading.
+ */
+function convertHeadingToHTMLFragment(headingText) {
+  const inlineText =
+    filterByPredicate(
+      headingText.children,
+      (token) => tokensInclude.has(token.type),
+      (token) => (childrenExclude.has(token.type) ? [] : token.children)
+    )
+      .map((token) => token.text)
+      .join("");
+  return "#" + encodeURIComponent(
+    inlineText
+      .toLowerCase()
+      // RegExp source with Ruby's \p{Word} expanded into its General Categories
+      // https://github.com/gjtorikian/html-pipeline/blob/main/lib/html/pipeline/toc_filter.rb
+      // https://ruby-doc.org/core-3.0.2/Regexp.html
+      .replace(
+        /[^\p{Letter}\p{Mark}\p{Number}\p{Connector_Punctuation}\- ]/gu,
+        ""
+      )
+      .replace(/ /gu, "-")
+  );
+}
+
+/**
+ * Unescapes the text of a String-type micromark Token.
+ *
+ * @param {import("../helpers/micromark.cjs").Token} token String-type micromark Token.
+ * @returns {string} Unescaped token text.
+ */
+function unescapeStringTokenText(token) {
+  return filterByTypes(token.children, [ "characterEscapeValue", "data" ])
+    .map((child) => child.text)
+    .join("");
+}
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD051", "link-fragments" ],
+  "description": "Link fragments should be valid",
+  "tags": [ "links" ],
+  "parser": "micromark",
+  "function": function MD051(params, onError) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const fragments = new Map();
+
+    // Process headings
+    const headingTexts = filterByTypes(micromarkTokens, [ "atxHeadingText", "setextHeadingText" ]);
+    for (const headingText of headingTexts) {
+      const fragment = convertHeadingToHTMLFragment(headingText);
+      if (fragment !== "#") {
+        const count = fragments.get(fragment) || 0;
+        if (count) {
+          fragments.set(`${fragment}-${count}`, 0);
+        }
+        fragments.set(fragment, count + 1);
+        let match = null;
+        while ((match = anchorRe.exec(headingText.text)) !== null) {
+          const [ , anchor ] = match;
+          if (!fragments.has(anchor)) {
+            fragments.set(anchor, 1);
+          }
+        }
+      }
+    }
+
+    // Process HTML anchors
+    for (const token of filterByTypes(micromarkTokens, [ "htmlText" ])) {
+      const htmlTagInfo = getHtmlTagInfo(token);
+      if (htmlTagInfo && !htmlTagInfo.close) {
+        const anchorMatch = idRe.exec(token.text) ||
+          (htmlTagInfo.name.toLowerCase() === "a" && nameRe.exec(token.text));
+        if (anchorMatch && anchorMatch.length > 0) {
+          fragments.set(`#${anchorMatch[1]}`, 0);
+        }
+      }
+    }
+
+    // Process link and definition fragments
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").TokenType[][] */
+    const parentChilds = [
+      [ "link", "resourceDestinationString" ],
+      [ "definition", "definitionDestinationString" ]
+    ];
+    for (const [ parentType, definitionType ] of parentChilds) {
+      const links = filterByTypes(micromarkTokens, [ parentType ]);
+      for (const link of links) {
+        const definitions = filterByTypes(link.children, [ definitionType ]);
+        for (const definition of definitions) {
+          const { endColumn, startColumn } = definition;
+          const text = unescapeStringTokenText(definition);
+          const encodedText = `#${encodeURIComponent(text.slice(1))}`;
+          if (
+            (text.length > 1) &&
+            text.startsWith("#") &&
+            !fragments.has(encodedText) &&
+            !lineFragmentRe.test(encodedText)
+          ) {
+            // eslint-disable-next-line no-undef-init
+            let context = undefined;
+            // eslint-disable-next-line no-undef-init
+            let range = undefined;
+            // eslint-disable-next-line no-undef-init
+            let fixInfo = undefined;
+            if (link.startLine === link.endLine) {
+              context = link.text;
+              range = [ link.startColumn, link.endColumn - link.startColumn ];
+              fixInfo = {
+                "editColumn": startColumn,
+                "deleteCount": endColumn - startColumn
+              };
+            }
+            const textLower = text.toLowerCase();
+            const mixedCaseKey = [ ...fragments.keys() ]
+              .find((key) => textLower === key.toLowerCase());
+            if (mixedCaseKey) {
+              // @ts-ignore
+              (fixInfo || {}).insertText = mixedCaseKey;
+              addErrorDetailIf(
+                onError,
+                link.startLine,
+                mixedCaseKey,
+                text,
+                undefined,
+                context,
+                range,
+                fixInfo
+              );
+            } else {
+              addError(
+                onError,
+                link.startLine,
+                undefined,
+                context,
+                range
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,42 @@
+// @ts-check
+
+"use strict";
+
+const { addError } = require("../helpers");
+const { referenceLinkImageData } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD052", "reference-links-images" ],
+  "description":
+    "Reference links and images should use a label that is defined",
+  "tags": [ "images", "links" ],
+  "parser": "none",
+  "function": function MD052(params, onError) {
+    const { config, lines } = params;
+    const shortcutSyntax = config.shortcut_syntax || false;
+    const { definitions, references, shortcuts } = referenceLinkImageData();
+    const entries = shortcutSyntax ?
+      [ ...references.entries(), ...shortcuts.entries() ] :
+      references.entries();
+    // Look for links/images that use an undefined link reference
+    for (const reference of entries) {
+      const [ label, datas ] = reference;
+      if (!definitions.has(label)) {
+        for (const data of datas) {
+          const [ lineIndex, index, length ] = data;
+          // Context will be incomplete if reporting for a multi-line link
+          const context = lines[lineIndex].slice(index, index + length);
+          addError(
+            onError,
+            lineIndex + 1,
+            `Missing link or image reference definition: "${label}"`,
+            context,
+            [ index + 1, context.length ]
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,62 @@
+// @ts-check
+
+"use strict";
+
+const { addError, ellipsify, linkReferenceDefinitionRe } =
+  require("../helpers");
+const { referenceLinkImageData } = require("./cache");
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD053", "link-image-reference-definitions" ],
+  "description": "Link and image reference definitions should be needed",
+  "tags": [ "images", "links" ],
+  "parser": "none",
+  "function": function MD053(params, onError) {
+    const ignored = new Set(params.config.ignored_definitions || [ "//" ]);
+    const lines = params.lines;
+    const { references, shortcuts, definitions, duplicateDefinitions } =
+      referenceLinkImageData();
+    const singleLineDefinition = (line) => (
+      line.replace(linkReferenceDefinitionRe, "").trim().length > 0
+    );
+    const deleteFixInfo = {
+      "deleteCount": -1
+    };
+    // Look for unused link references (unreferenced by any link/image)
+    for (const definition of definitions.entries()) {
+      const [ label, [ lineIndex ] ] = definition;
+      if (
+        !ignored.has(label) &&
+        !references.has(label) &&
+        !shortcuts.has(label)
+      ) {
+        const line = lines[lineIndex];
+        addError(
+          onError,
+          lineIndex + 1,
+          `Unused link or image reference definition: "${label}"`,
+          ellipsify(line),
+          [ 1, line.length ],
+          singleLineDefinition(line) ? deleteFixInfo : 0
+        );
+      }
+    }
+    // Look for duplicate link references (defined more than once)
+    for (const duplicateDefinition of duplicateDefinitions) {
+      const [ label, lineIndex ] = duplicateDefinition;
+      if (!ignored.has(label)) {
+        const line = lines[lineIndex];
+        addError(
+          onError,
+          lineIndex + 1,
+          `Duplicate link or image reference definition: "${label}"`,
+          ellipsify(line),
+          [ 1, line.length ],
+          singleLineDefinition(line) ? deleteFixInfo : 0
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,130 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorContext, nextLinesRe } = require("../helpers");
+const { filterByTypes, filterByPredicate, getTokenTextByType } =
+  require("../helpers/micromark.cjs");
+const { referenceLinkImageData } = require("./cache");
+
+const backslashEscapeRe = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
+const removeBackslashEscapes = (text) => text.replace(backslashEscapeRe, "$1");
+const autolinkDisallowedRe = /[ <>]/;
+const autolinkAble = (destination) => {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(destination);
+  } catch {
+    // Not an absolute URL
+    return false;
+  }
+  return !autolinkDisallowedRe.test(destination);
+};
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD054", "link-image-style" ],
+  "description": "Link and image style",
+  "tags": [ "images", "links" ],
+  "parser": "micromark",
+  "function": (params, onError) => {
+    const config = params.config;
+    const autolink = (config.autolink === undefined) || !!config.autolink;
+    const inline = (config.inline === undefined) || !!config.inline;
+    const full = (config.full === undefined) || !!config.full;
+    const collapsed = (config.collapsed === undefined) || !!config.collapsed;
+    const shortcut = (config.shortcut === undefined) || !!config.shortcut;
+    const urlInline = (config.url_inline === undefined) || !!config.url_inline;
+    if (autolink && inline && full && collapsed && shortcut && urlInline) {
+      // Everything allowed, nothing to check
+      return;
+    }
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const { definitions } = referenceLinkImageData();
+    const links = filterByTypes(micromarkTokens, [ "autolink", "image", "link" ]);
+    for (const link of links) {
+      let label = null;
+      let destination = null;
+      const {
+        children, endColumn, endLine, startColumn, startLine, text, type
+      } = link;
+      const image = (type === "image");
+      let isError = false;
+      if (type === "autolink") {
+        // link kind is an autolink
+        destination = getTokenTextByType(children, "autolinkProtocol");
+        label = destination;
+        isError = !autolink;
+      } else {
+        // link type is "image" or "link"
+        const descendents = filterByPredicate(children);
+        label = getTokenTextByType(descendents, "labelText");
+        destination =
+          getTokenTextByType(descendents, "resourceDestinationString");
+        if (destination) {
+          // link kind is an inline link
+          const title = getTokenTextByType(descendents, "resourceTitleString");
+          isError = !inline || (
+            !urlInline &&
+            autolink &&
+            !image &&
+            !title &&
+            (label === destination) &&
+            autolinkAble(destination)
+          );
+        } else {
+          // link kind is a full/collapsed/shortcut reference link
+          const isShortcut = !children.some((t) => t.type === "reference");
+          const referenceString = getTokenTextByType(descendents, "referenceString");
+          const isCollapsed = (referenceString === null);
+          const definition = definitions.get(referenceString || label);
+          destination = definition && definition[1];
+          isError = destination &&
+            (isShortcut ? !shortcut : (isCollapsed ? !collapsed : !full));
+        }
+      }
+      if (isError) {
+        let range = null;
+        let fixInfo = null;
+        if (startLine === endLine) {
+          range = [ startColumn, endColumn - startColumn ];
+          let insertText = null;
+          const canInline = (inline && label);
+          const canAutolink = (autolink && !image && autolinkAble(destination));
+          if (canInline && (urlInline || !canAutolink)) {
+            // Most useful form
+            const prefix = (image ? "!" : "");
+            // @ts-ignore
+            const escapedLabel = label.replace(/[[\]]/g, "\\$&");
+            const escapedDestination = destination.replace(/[()]/g, "\\$&");
+            insertText = `${prefix}[${escapedLabel}](${escapedDestination})`;
+          } else if (canAutolink) {
+            // Simplest form
+            insertText = `<${removeBackslashEscapes(destination)}>`;
+          }
+          if (insertText) {
+            fixInfo = {
+              "editColumn": range[0],
+              insertText,
+              "deleteCount": range[1]
+            };
+          }
+        }
+        addErrorContext(
+          onError,
+          startLine,
+          text.replace(nextLinesRe, ""),
+          null,
+          null,
+          range,
+          fixInfo
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,80 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+const whitespaceTypes = new Set([ "linePrefix", "whitespace" ]);
+const ignoreWhitespace = (tokens) => tokens.filter(
+  (token) => !whitespaceTypes.has(token.type)
+);
+const firstOrNothing = (items) => items[0];
+const lastOrNothing = (items) => items[items.length - 1];
+const makeRange = (start, end) => [ start, end - start + 1 ];
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD055", "table-pipe-style" ],
+  "description": "Table pipe style",
+  "tags": [ "table" ],
+  "parser": "micromark",
+  "function": function MD055(params, onError) {
+    const style = String(params.config.style || "consistent");
+    let expectedStyle = style;
+    let expectedLeadingPipe =
+      ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "trailing_only"));
+    let expectedTrailingPipe =
+      ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "leading_only"));
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const tables = filterByTypes(micromarkTokens, [ "table" ]);
+    for (const table of tables) {
+      const rows = filterByTypes(table.children, [ "tableDelimiterRow", "tableRow" ]);
+      for (const row of rows) {
+        // The following uses of first/lastOrNothing lack fallback handling
+        // because it seems not to be possible (i.e., 0% coverage)
+        const firstCell = firstOrNothing(row.children);
+        const leadingToken = firstOrNothing(ignoreWhitespace(firstCell.children));
+        const actualLeadingPipe = (leadingToken.type === "tableCellDivider");
+        const lastCell = lastOrNothing(row.children);
+        const trailingToken = lastOrNothing(ignoreWhitespace(lastCell.children));
+        const actualTrailingPipe = (trailingToken.type === "tableCellDivider");
+        const actualStyle = actualLeadingPipe ?
+          (actualTrailingPipe ? "leading_and_trailing" : "leading_only") :
+          (actualTrailingPipe ? "trailing_only" : "no_leading_or_trailing");
+        if (expectedStyle === "consistent") {
+          expectedStyle = actualStyle;
+          expectedLeadingPipe = actualLeadingPipe;
+          expectedTrailingPipe = actualTrailingPipe;
+        }
+        if (actualLeadingPipe !== expectedLeadingPipe) {
+          addErrorDetailIf(
+            onError,
+            firstCell.startLine,
+            expectedStyle,
+            actualStyle,
+            `${expectedLeadingPipe ? "Missing" : "Unexpected"} leading pipe`,
+            undefined,
+            makeRange(row.startColumn, firstCell.startColumn)
+          );
+        }
+        if (actualTrailingPipe !== expectedTrailingPipe) {
+          addErrorDetailIf(
+            onError,
+            lastCell.endLine,
+            expectedStyle,
+            actualStyle,
+            `${expectedTrailingPipe ? "Missing" : "Unexpected"} trailing pipe`,
+            undefined,
+            makeRange(lastCell.endColumn - 1, row.endColumn - 1)
+          );
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,52 @@
+// @ts-check
+
+"use strict";
+
+const { addErrorDetailIf } = require("../helpers");
+const { filterByTypes } = require("../helpers/micromark.cjs");
+
+const makeRange = (start, end) => [ start, end - start + 1 ];
+
+// eslint-disable-next-line jsdoc/valid-types
+/** @type import("./markdownlint").Rule */
+module.exports = {
+  "names": [ "MD056", "table-column-count" ],
+  "description": "Table column count",
+  "tags": [ "table" ],
+  "parser": "micromark",
+  "function": function MD056(params, onError) {
+    // eslint-disable-next-line jsdoc/valid-types
+    /** @type import("../helpers/micromark.cjs").Token[] */
+    const micromarkTokens =
+      // @ts-ignore
+      params.parsers.micromark.tokens;
+    const tables = filterByTypes(micromarkTokens, [ "table" ]);
+    for (const table of tables) {
+      const rows = filterByTypes(table.children, [ "tableDelimiterRow", "tableRow" ]);
+      let expectedCount = 0;
+      for (const row of rows) {
+        const cells = filterByTypes(row.children, [ "tableData", "tableDelimiter", "tableHeader" ]);
+        const actualCount = cells.length;
+        expectedCount ||= actualCount;
+        let detail = null;
+        let range = null;
+        if (actualCount < expectedCount) {
+          detail = "Too few cells, row will be missing data";
+          range = [ row.endColumn - 1, 1 ];
+        } else if (expectedCount < actualCount) {
+          detail = "Too many cells, extra data will be missing";
+          range = makeRange(cells[expectedCount].startColumn, row.endColumn - 1);
+        }
+        addErrorDetailIf(
+          onError,
+          row.endLine,
+          expectedCount,
+          actualCount,
+          detail,
+          null,
+          range
+        );
+      }
+    }
+  }
+}