@alexlit/lint-kit 214.0.0 → 214.1.0

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

@@ -0,0 +1,115 @@
+// @ts-check
+
+import { addError } from "../helpers/helpers.cjs";
+import { filterByPredicate, getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+
+const intrawordRe = /^\w$/;
+
+/**
+ * Return the string representation of a emphasis or strong markup character.
+ *
+ * @param {string} markup Emphasis or strong string.
+ * @returns {"asterisk" | "underscore"} String representation.
+ */
+function emphasisOrStrongStyleFor(markup) {
+  switch (markup[0]) {
+    case "*":
+      return "asterisk";
+    default:
+      return "underscore";
+  }
+};
+
+/**
+ * @param {import("markdownlint").RuleParams} params Rule parameters.
+ * @param {import("markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {import("micromark-util-types").TokenType} type Token type.
+ * @param {import("micromark-util-types").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") => {
+    const { lines, parsers } = params;
+    const emphasisTokens = filterByPredicate(
+      parsers.micromark.tokens,
+      (token) => token.type === type,
+      (token) => ((token.type === "htmlFlow") ? [] : token.children)
+    );
+    for (const token of emphasisTokens) {
+      const sequences = getDescendantsByType(token, [ typeSequence ]);
+      const startSequence = sequences[0];
+      const endSequence = sequences[sequences.length - 1];
+      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
+                }
+              );
+            }
+          }
+        }
+      }
+    }
+  };
+
+/** @type {import("markdownlint").Rule[]} */
+export default [
+  {
+    "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.mjs

@@ -0,0 +1,173 @@
+// @ts-check
+
+import { addError, getHtmlAttributeRe } from "../helpers/helpers.cjs";
+import { filterByPredicate, filterByTypes, getHtmlTagInfo, isDocfxTab } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+// 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("markdownlint").MicromarkToken} 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, "-")
+      .toWellFormed()
+  );
+}
+
+/**
+ * Unescapes the text of a String-type micromark Token.
+ *
+ * @param {import("markdownlint").MicromarkToken} token String-type micromark Token.
+ * @returns {string} Unescaped token text.
+ */
+function unescapeStringTokenText(token) {
+  return filterByTypes(token.children, [ "characterEscapeValue", "data" ])
+    .map((child) => child.text)
+    .join("");
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD051", "link-fragments" ],
+  "description": "Link fragments should be valid",
+  "tags": [ "links" ],
+  "parser": "micromark",
+  "function": function MD051(params, onError) {
+    const ignoreCase = params.config.ignore_case || false;
+    const ignoredPattern = params.config.ignored_pattern || "";
+    const ignoredPatternRe = new RegExp(ignoredPattern || "^$");
+    /** @type {Map<string, number>} */
+    const fragments = new Map([ [ "#top", 0 ] ]);
+
+    // Process headings
+    const headingTexts = filterByTypesCached([ "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 filterByTypesCached([ "htmlText" ], true)) {
+      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
+    /** @type {import("markdownlint").MicromarkTokenType[][]} */
+    const parentChilds = [
+      [ "link", "resourceDestinationString" ],
+      [ "definition", "definitionDestinationString" ]
+    ];
+    for (const [ parentType, definitionType ] of parentChilds) {
+      const links = filterByTypesCached([ parentType ])
+        .filter(
+          (link) => !((link.parent?.type === "atxHeadingText") && isDocfxTab(link.parent.parent))
+        );
+      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 textSliceOne = text.slice(1);
+          const encodedText = `#${encodeURIComponent(textSliceOne.toWellFormed())}`;
+          if (
+            (text.length > 1) &&
+            text.startsWith("#") &&
+            !fragments.has(encodedText) &&
+            !lineFragmentRe.test(encodedText) &&
+            !ignoredPatternRe.test(textSliceOne)
+          ) {
+            let context = undefined;
+            let range = undefined;
+            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();
+            // eslint-disable-next-line unicorn/prefer-iterator-helpers
+            const mixedCaseKey = [ ...fragments.keys() ]
+              .find((key) => textLower === key.toLowerCase());
+            if (mixedCaseKey) {
+              // @ts-ignore
+              (fixInfo || {}).insertText = mixedCaseKey;
+              if (!ignoreCase && (mixedCaseKey !== text)) {
+                addError(
+                  onError,
+                  link.startLine,
+                  `Expected: ${mixedCaseKey}; Actual: ${text}`,
+                  context,
+                  range,
+                  fixInfo
+                );
+              }
+            } else {
+              addError(
+                onError,
+                link.startLine,
+                undefined,
+                context,
+                range
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,40 @@
+// @ts-check
+
+import { addError } from "../helpers/helpers.cjs";
+import { getReferenceLinkImageData } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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 ignoredLabels = new Set(config.ignored_labels || [ "x" ]);
+    const { definitions, references, shortcuts } = getReferenceLinkImageData();
+    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) && !ignoredLabels.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.mjs

@@ -0,0 +1,60 @@
+// @ts-check
+
+import { addError, ellipsify } from "../helpers/helpers.cjs";
+import { getReferenceLinkImageData } from "./cache.mjs";
+
+const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])\]:/;
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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 } =
+      getReferenceLinkImageData();
+    const singleLineDefinition = (/** @type {string} */ 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 : undefined
+        );
+      }
+    }
+    // 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 : undefined
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,122 @@
+// @ts-check
+
+import { addErrorContext, nextLinesRe } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { getReferenceLinkImageData, filterByTypesCached } from "./cache.mjs";
+
+const backslashEscapeRe = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
+const removeBackslashEscapes = (/** @type {string} **/ text) => text.replace(backslashEscapeRe, "$1");
+const autolinkDisallowedRe = /[ <>]/;
+const autolinkAble = (/** @type {string} */ destination) => {
+  try {
+    // eslint-disable-next-line no-new
+    new URL(destination);
+  } catch {
+    // Not an absolute URL
+    return false;
+  }
+  return !autolinkDisallowedRe.test(destination);
+};
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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;
+    }
+    const { definitions } = getReferenceLinkImageData();
+    const links = filterByTypesCached([ "autolink", "image", "link" ]);
+    for (const link of links) {
+      let label = null;
+      let destination = null;
+      const {
+        endColumn, endLine, startColumn, startLine, text, type
+      } = link;
+      const image = (type === "image");
+      let isError = false;
+      if (type === "autolink") {
+        // link kind is an autolink
+        destination = getDescendantsByType(link, [ [ "autolinkEmail", "autolinkProtocol" ] ])[0]?.text;
+        label = destination;
+        isError = !autolink && Boolean(destination);
+      } else {
+        // link type is "image" or "link"
+        label = getDescendantsByType(link, [ "label", "labelText" ])[0].text;
+        destination =
+          getDescendantsByType(link, [ "resource", "resourceDestination", [ "resourceDestinationLiteral", "resourceDestinationRaw" ], "resourceDestinationString" ])[0]?.text;
+        if (destination) {
+          // link kind is an inline link
+          const title = getDescendantsByType(link, [ "resource", "resourceTitle", "resourceTitleString" ])[0]?.text;
+          isError = !inline || (
+            !urlInline &&
+            autolink &&
+            !image &&
+            !title &&
+            (label === destination) &&
+            autolinkAble(destination)
+          );
+        } else {
+          // link kind is a full/collapsed/shortcut reference link
+          const isShortcut = getDescendantsByType(link, [ "reference" ]).length === 0;
+          const referenceString = getDescendantsByType(link, [ "reference", "referenceString" ])[0]?.text;
+          const isCollapsed = (referenceString === undefined);
+          const definition = definitions.get(referenceString || label);
+          destination = (definition && definition[1]) || "";
+          isError = Boolean(
+            destination &&
+            (isShortcut ? !shortcut : (isCollapsed ? !collapsed : !full))
+          );
+        }
+      }
+      if (isError) {
+        let range = undefined;
+        let fixInfo = undefined;
+        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, ""),
+          undefined,
+          undefined,
+          range,
+          fixInfo
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,82 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
+
+const whitespaceTypes = new Set([ "linePrefix", "whitespace" ]);
+const ignoreWhitespace = (/** @type {MicromarkToken[]} */ tokens) => tokens.filter(
+  (token) => !whitespaceTypes.has(token.type)
+);
+const firstOrNothing = (/** @type {MicromarkToken[]} */ items) => items[0];
+const lastOrNothing = (/** @type {MicromarkToken[]} */ items) => items[items.length - 1];
+const makeRange = (/** @type {number} */ start, /** @type {number} */ end) => [ start, end - start + 1 ];
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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"));
+    let currentTable = null;
+    const rows = filterByTypesCached([ "tableDelimiterRow", "tableRow" ]);
+    for (const row of rows) {
+      if (style === "per_table") {
+        // Reset style for each new table
+        const rowTable = getParentOfType(row, [ "table" ]);
+        if (rowTable !== currentTable) {
+          expectedStyle = "consistent";
+          currentTable = rowTable;
+        }
+      }
+      // 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.mjs

@@ -0,0 +1,50 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const makeRange = (/** @type {number} */ start, /** @type {number} */ end) => [ start, end - start + 1 ];
+
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD056", "table-column-count" ],
+  "description": "Table column count",
+  "tags": [ "table" ],
+  "parser": "micromark",
+  "function": function MD056(params, onError) {
+    const rows = filterByTypesCached([ "tableDelimiterRow", "tableRow" ]);
+    let expectedCount = 0;
+    let currentTable = null;
+    for (const row of rows) {
+      const table = getParentOfType(row, [ "table" ]);
+      if (currentTable !== table) {
+        expectedCount = 0;
+        currentTable = table;
+      }
+      const cells = row.children.filter((child) => [ "tableData", "tableDelimiter", "tableHeader" ].includes(child.type));
+      const actualCount = cells.length;
+      expectedCount ||= actualCount;
+      let detail = undefined;
+      let range = undefined;
+      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,
+        undefined,
+        range
+      );
+    }
+  }
+};