@alexlit/lint-kit 214.0.1 → 214.1.0

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

@@ -0,0 +1,57 @@
+// @ts-check
+
+import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
+import { getBlockQuotePrefixText } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD058", "blanks-around-tables" ],
+  "description": "Tables should be surrounded by blank lines",
+  "tags": [ "table" ],
+  "parser": "micromark",
+  "function": function MD058(params, onError) {
+    const { lines } = params;
+    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
+
+    // For every table...
+    const tables = filterByTypesCached([ "table" ]);
+    for (const table of tables) {
+
+      // Look for a blank line above the table
+      const firstLineNumber = table.startLine;
+      if (!isBlankLine(lines[firstLineNumber - 2])) {
+        addErrorContext(
+          onError,
+          firstLineNumber,
+          lines[firstLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, firstLineNumber)
+          }
+        );
+      }
+
+      // Look for a blank line below the table
+      const lastLineNumber = table.endLine;
+      if (!isBlankLine(lines[lastLineNumber])) {
+        addErrorContext(
+          onError,
+          lastLineNumber,
+          lines[lastLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "lineNumber": lastLineNumber + 1,
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, lastLineNumber)
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,71 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+/** @type {Set<MicromarkTokenType>} */
+const allowedChildrenTypes = new Set([
+  "codeText",
+  "htmlText"
+]);
+const defaultProhibitedTexts = [
+  "click here",
+  "here",
+  "link",
+  "more"
+];
+
+/**
+ * Normalizes a string by removing extra whitespaces and punctuation.
+ *
+ * @param {string} str String to normalize.
+ * @returns {string} Normalized string.
+ */
+function normalize(str) {
+  return str
+    .replace(/[\W_]+/g, " ")
+    .replace(/\s+/g, " ")
+    .toLowerCase()
+    .trim();
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD059", "descriptive-link-text" ],
+  "description": "Link text should be descriptive",
+  "tags": [ "accessibility", "links" ],
+  "parser": "micromark",
+  "function": function MD059(params, onError) {
+    const prohibitedTexts = new Set(
+      (params.config.prohibited_texts || defaultProhibitedTexts).map(normalize)
+    );
+    if (prohibitedTexts.size > 0) {
+      const links = filterByTypesCached([ "link" ]);
+      for (const link of links) {
+        const labelTexts = getDescendantsByType(link, [ "label", "labelText" ]);
+        for (const labelText of labelTexts) {
+          const { children, endColumn, endLine, parent, startColumn, startLine, text } = labelText;
+          if (
+            !children.some((child) => allowedChildrenTypes.has(child.type)) &&
+            prohibitedTexts.has(normalize(text))
+          ) {
+            const range = (startLine === endLine) ?
+              [ startColumn, endColumn - startColumn ] :
+              undefined;
+            addErrorContext(
+              onError,
+              startLine,
+              // @ts-ignore
+              parent.text,
+              undefined,
+              undefined,
+              range
+            );
+          }
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,229 @@
+// @ts-check
+
+import { filterByTypes } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+import stringWidth from "string-width";
+
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_ */
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {import("markdownlint").RuleOnErrorInfo} RuleOnErrorInfo */
+/** @typedef {import("markdownlint").RuleOnErrorFixInfo} RuleOnErrorFixInfo */
+
+// Regular expression to match text that could represent an unordered list item prefix
+const unorderedListPrefix = /^[>\s]*[-+*]$/;
+
+/**
+ * Adds a RuleOnErrorInfo object to a list of RuleOnErrorInfo objects.
+ *
+ * @param {RuleOnErrorInfo[]} errors List of errors.
+ * @param {readonly string[]} lines File/string lines.
+ * @param {number} lineNumber Line number.
+ * @param {number} column Column number.
+ * @param {string} detail Detail message.
+ * @param {RuleOnErrorFixInfo} [fixInfo] Fix information.
+ * @returns {void}
+ */
+function addError(errors, lines, lineNumber, column, detail, fixInfo) {
+  if (
+    fixInfo &&
+    (fixInfo.insertText === " ") &&
+    fixInfo.editColumn &&
+    unorderedListPrefix.test(lines[lineNumber - 1].slice(0, fixInfo.editColumn - 1))
+  ) {
+    // Do not apply edits that would change a table cell into an unordered list item
+    fixInfo = undefined;
+  }
+  errors.push({
+    lineNumber,
+    detail,
+    "range": [ column, 1 ],
+    fixInfo
+  });
+}
+
+/**
+ * @typedef Column
+ * @property {number} actual Actual column (1-based).
+ * @property {number} effective Effective column (1-based).
+ */
+
+/**
+ * Gets a list of table cell divider columns.
+ *
+ * @param {readonly string[]} lines File/string lines.
+ * @param {MicromarkToken} row Micromark row token.
+ * @returns {Column[]} Divider columns.
+ */
+function getTableDividerColumns(lines, row) {
+  return filterByTypes(
+    row.children,
+    [ "tableCellDivider" ]
+  ).map(
+    (divider) => ({
+      "actual": divider.startColumn,
+      "effective": stringWidth(lines[row.startLine - 1].slice(0, divider.startColumn - 1))
+    })
+  );
+}
+
+/**
+ * Checks the specified table rows for consistency with the "aligned" style.
+ *
+ * @param {readonly string[]} lines File/string lines.
+ * @param {MicromarkToken[]} rows Micromark row tokens.
+ * @param {string} detail Detail message.
+ * @returns {RuleOnErrorInfo[]} List of errors.
+ */
+function checkStyleAligned(lines, rows, detail) {
+  /** @type {RuleOnErrorInfo[]} */
+  const errorInfos = [];
+  const headerRow = rows[0];
+  const headerDividerColumns = getTableDividerColumns(lines, headerRow);
+  for (const row of rows.slice(1)) {
+    const remainingHeaderDividerColumns = new Set(headerDividerColumns.map((column) => column.effective));
+    const rowDividerColumns = getTableDividerColumns(lines, row);
+    for (const dividerColumn of rowDividerColumns) {
+      if ((remainingHeaderDividerColumns.size > 0) && !remainingHeaderDividerColumns.delete(dividerColumn.effective)) {
+        addError(errorInfos, lines, row.startLine, dividerColumn.actual, detail);
+      }
+    }
+  }
+  return errorInfos;
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD060", "table-column-style" ],
+  "description": "Table column style",
+  "tags": [ "table" ],
+  "parser": "micromark",
+  "function": function MD060(params, onError) {
+    const style = String(params.config.style || "any");
+    const styleAlignedAllowed = (style === "any") || (style === "aligned");
+    const styleCompactAllowed = (style === "any") || (style === "compact");
+    const styleTightAllowed = (style === "any") || (style === "tight");
+    const alignedDelimiter = !!params.config.aligned_delimiter;
+    const lines = params.lines;
+
+    // Scan all tables/rows
+    const tables = filterByTypesCached([ "table" ]);
+    for (const table of tables) {
+      const rows = filterByTypes(table.children, [ "tableDelimiterRow", "tableRow" ]);
+
+      // Determine errors for style "aligned"
+      /** @type {RuleOnErrorInfo[]} */
+      const errorsIfAligned = [];
+      if (styleAlignedAllowed) {
+        errorsIfAligned.push(...checkStyleAligned(lines, rows, "Table pipe does not align with header for style \"aligned\""));
+      }
+
+      // Determine errors for styles "compact" and "tight"
+      /** @type {RuleOnErrorInfo[]} */
+      const errorsIfCompact = [];
+      /** @type {RuleOnErrorInfo[]} */
+      const errorsIfTight = [];
+      if (
+        (styleCompactAllowed || styleTightAllowed) &&
+        !(styleAlignedAllowed && (errorsIfAligned.length === 0))
+      ) {
+        if (alignedDelimiter) {
+          const errorInfos = checkStyleAligned(lines, rows.slice(0, 2), "Table pipe does not align with header for option \"aligned_delimiter\"");
+          errorsIfCompact.push(...errorInfos);
+          errorsIfTight.push(...errorInfos);
+        }
+        for (const row of rows) {
+          const tokensOfInterest = filterByTypes(row.children, [ "tableCellDivider", "tableContent", "whitespace" ]);
+          for (let i = 0; i < tokensOfInterest.length; i++) {
+            const { startColumn, startLine, type } = tokensOfInterest[i];
+            if (type === "tableCellDivider") {
+              const previous = tokensOfInterest[i - 1];
+              if (previous) {
+                if (previous.type === "whitespace") {
+                  if (previous.text.length !== 1) {
+                    addError(
+                      errorsIfCompact,
+                      lines,
+                      startLine,
+                      startColumn,
+                      "Table pipe has extra space to the left for style \"compact\"",
+                      { "editColumn": previous.startColumn, "deleteCount": previous.text.length - 1 }
+                    );
+                  }
+                  addError(
+                    errorsIfTight,
+                    lines,
+                    startLine,
+                    startColumn,
+                    "Table pipe has space to the left for style \"tight\"",
+                    { "editColumn": previous.startColumn, "deleteCount": previous.text.length }
+                  );
+                } else {
+                  addError(
+                    errorsIfCompact,
+                    lines,
+                    startLine,
+                    startColumn,
+                    "Table pipe is missing space to the left for style \"compact\"",
+                    { "editColumn": previous.endColumn, "insertText": " " }
+                  );
+                }
+              }
+              const next = tokensOfInterest[i + 1];
+              if (next) {
+                if (next.type === "whitespace") {
+                  if (next.endColumn !== row.endColumn) {
+                    if (next.text.length !== 1) {
+                      addError(
+                        errorsIfCompact,
+                        lines,
+                        startLine,
+                        startColumn,
+                        "Table pipe has extra space to the right for style \"compact\"",
+                        { "editColumn": next.startColumn, "deleteCount": next.text.length - 1 }
+                      );
+                    }
+                    addError(
+                      errorsIfTight,
+                      lines,
+                      startLine,
+                      startColumn,
+                      "Table pipe has space to the right for style \"tight\"",
+                      { "editColumn": next.startColumn, "deleteCount": next.text.length }
+                    );
+                  }
+                } else {
+                  addError(
+                    errorsIfCompact,
+                    lines,
+                    startLine,
+                    startColumn,
+                    "Table pipe is missing space to the right for style \"compact\"",
+                    { "editColumn": next.startColumn, "insertText": " " }
+                  );
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // Report errors for whatever (allowed) style has the fewest
+      let errorInfos = errorsIfAligned;
+      if (
+        styleCompactAllowed &&
+        (!styleAlignedAllowed || (errorsIfCompact.length < errorInfos.length))
+      ) {
+        errorInfos = errorsIfCompact;
+      }
+      if (
+        styleTightAllowed &&
+        ((errorsIfTight.length < errorInfos.length) || (!styleAlignedAllowed && !styleCompactAllowed))
+      ) {
+        errorInfos = errorsIfTight;
+      }
+      for (const errorInfo of errorInfos) {
+        onError(errorInfo);
+      }
+    }
+  }
+};

package/packages/config-markdownlint/node_modules/markdownlint/lib/micromark-parse.mjs

@@ -0,0 +1,338 @@
+// @ts-check
+
+import { directive } from "micromark-extension-directive";
+import { gfmAutolinkLiteral } from "micromark-extension-gfm-autolink-literal";
+import { gfmFootnote } from "micromark-extension-gfm-footnote";
+import { gfmTable } from "micromark-extension-gfm-table";
+import { math } from "micromark-extension-math";
+import { parse as micromarkParse, postprocess as micromarkPostprocess, preprocess as micromarkPreprocess } from "micromark";
+// micromark-core-commonmark must exactly match what's used by micromark for the shim below to work correctly
+// Unfortunately, omitting this dependency from package.json breaks strict dependency resolution (e.g., pnpm)
+import { labelEnd } from "micromark-core-commonmark";
+import { isHtmlFlowComment } from "../helpers/micromark-helpers.cjs";
+import { flatTokensSymbol, htmlFlowSymbol, newlineRe } from "../helpers/shared.cjs";
+
+/** @typedef {import("micromark-util-types").Event} Event */
+/** @typedef {import("micromark-util-types").Extension} Extension */
+/** @typedef {import("micromark-util-types").ParseOptions} MicromarkParseOptions */
+/** @typedef {import("micromark-util-types").State} State */
+/** @typedef {import("micromark-util-types").Token} Token */
+/** @typedef {import("micromark-util-types").Tokenizer} Tokenizer */
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {typeof import("./micromark-types.d.mts")} _ambient_ */
+
+/**
+ * Gets a modified micromark-extension-directive without support for inline directives.
+ *
+ * @see {@link https://github.com/DavidAnson/markdownlint/issues/2080}
+ * @returns {Extension} Modified implementation.
+ */
+function directiveNoInline() {
+  const extension = {
+    ...directive()
+  };
+  delete extension.text;
+  return extension;
+}
+
+/**
+ * Gets the Markdown text for a Micromark token.
+ *
+ * @param {string} markdown Markdown content.
+ * @param {Token} token Micromark token.
+ * @returns {string} Token text.
+ */
+function getText(markdown, token) {
+  return markdown.slice(token.start.offset, token.end.offset);
+}
+
+/**
+ * Parse options.
+ *
+ * @typedef {Object} ParseOptions
+ * @property {boolean} [freezeTokens] Whether to freeze output Tokens.
+ */
+
+/**
+ * Parses a Markdown document and returns Micromark events.
+ *
+ * @param {string} markdown Markdown document.
+ * @param {MicromarkParseOptions} [micromarkParseOptions] Options for micromark.
+ * @returns {Event[]} Micromark events.
+ */
+export function getEvents(
+  markdown,
+  micromarkParseOptions = {}
+) {
+  // Customize extensions list to add useful extensions
+  const extensions = [
+    directiveNoInline(),
+    gfmAutolinkLiteral(),
+    gfmFootnote(),
+    gfmTable(),
+    math(),
+    ...(micromarkParseOptions.extensions || [])
+  ];
+
+  // // Shim labelEnd to identify undefined link labels
+  /** @type {Event[][]} */
+  const artificialEventLists = [];
+  const tokenizeOriginal = labelEnd.tokenize;
+
+  /** @type {Tokenizer} */
+  function tokenizeShim(effects, okOriginal, nokOriginal) {
+    // eslint-disable-next-line consistent-this, no-invalid-this, unicorn/no-this-assignment, unicorn/no-this-outside-of-class
+    const tokenizeContext = this;
+    const events = tokenizeContext.events;
+
+    /** @type {State} */
+    const nokShim = (code) => {
+      // Find start of label (image or link)
+      let indexStart = events.length;
+      while (--indexStart >= 0) {
+        const event = events[indexStart];
+        const [ kind, token ] = event;
+        if (kind === "enter") {
+          const { type } = token;
+          if ((type === "labelImage") || (type === "labelLink")) {
+            // Found it
+            break;
+          }
+        }
+      }
+
+      // If found...
+      if (indexStart >= 0) {
+        // Create artificial enter/exit events and replicate all data/lineEnding events within
+        const eventStart = events[indexStart];
+        const [ , eventStartToken ] = eventStart;
+        const eventEnd = events[events.length - 1];
+        const [ , eventEndToken ] = eventEnd;
+        /** @type {Token} */
+        const undefinedReferenceType = {
+          "type": "undefinedReferenceShortcut",
+          "start": eventStartToken.start,
+          "end": eventEndToken.end
+        };
+        /** @type {Token} */
+        const undefinedReference = {
+          "type": "undefinedReference",
+          "start": eventStartToken.start,
+          "end": eventEndToken.end
+        };
+        const eventsToReplicate = events
+          .slice(indexStart)
+          .filter((event) => {
+            const [ , eventToken ] = event;
+            const { type } = eventToken;
+            return (type === "data") || (type === "lineEnding");
+          });
+
+        // Determine the type of the undefined reference
+        const previousUndefinedEvent = (artificialEventLists.length > 0) && artificialEventLists[artificialEventLists.length - 1][0];
+        const previousUndefinedToken = previousUndefinedEvent && previousUndefinedEvent[1];
+        if (
+          previousUndefinedToken &&
+          (previousUndefinedToken.end.line === undefinedReferenceType.start.line) &&
+          (previousUndefinedToken.end.column === undefinedReferenceType.start.column)
+        ) {
+          // Previous undefined reference event is immediately before this one
+          if (eventsToReplicate.length === 0) {
+            // The pair represent a collapsed reference (ex: [...][])
+            previousUndefinedToken.type = "undefinedReferenceCollapsed";
+            previousUndefinedToken.end = eventEndToken.end;
+          } else {
+            // The pair represent a full reference (ex: [...][...])
+            undefinedReferenceType.type = "undefinedReferenceFull";
+            undefinedReferenceType.start = previousUndefinedToken.start;
+            artificialEventLists.pop();
+          }
+        }
+
+        // Create artificial event list and replicate content
+        const text = eventsToReplicate
+          .filter((event) => event[0] === "enter")
+          .map((event) => getText(markdown, event[1]))
+          .join("")
+          .trim();
+        if ((text.length > 0) && !text.includes("]")) {
+          /** @type {Event[]} */
+          const artificialEvents = [
+            [ "enter", undefinedReferenceType, tokenizeContext ],
+            [ "enter", undefinedReference, tokenizeContext ]
+          ];
+          for (const event of eventsToReplicate) {
+            const [ kind, token ] = event;
+            // Copy token because the current object will get modified by the parser
+            artificialEvents.push([ kind, { ...token }, tokenizeContext ]);
+          }
+          artificialEvents.push(
+            [ "exit", undefinedReference, tokenizeContext ],
+            [ "exit", undefinedReferenceType, tokenizeContext ]
+          );
+          artificialEventLists.push(artificialEvents);
+        }
+      }
+
+      // Continue with original behavior
+      return nokOriginal(code);
+    };
+
+    // Shim nok handler of labelEnd's tokenize
+    return tokenizeOriginal.call(tokenizeContext, effects, okOriginal, nokShim);
+  }
+
+  try {
+    // Shim labelEnd behavior to detect undefined references
+    labelEnd.tokenize = tokenizeShim;
+
+    // Use micromark to parse document into Events
+    const encoding = undefined;
+    const eol = true;
+    const parseContext = micromarkParse({ ...micromarkParseOptions, extensions });
+    const chunks = micromarkPreprocess()(markdown, encoding, eol);
+    const events = micromarkPostprocess(parseContext.document().write(chunks));
+
+    // Append artificial events and return all events
+    // eslint-disable-next-line unicorn/prefer-spread
+    return events.concat(...artificialEventLists);
+  } finally {
+    // Restore shimmed labelEnd behavior
+    labelEnd.tokenize = tokenizeOriginal;
+  }
+}
+
+/**
+ * Parses a Markdown document and returns micromark tokens (internal).
+ *
+ * @param {string} markdown Markdown document.
+ * @param {ParseOptions} [parseOptions] Options.
+ * @param {MicromarkParseOptions} [micromarkParseOptions] Options for micromark.
+ * @param {number} [lineDelta] Offset for start/end line.
+ * @param {MicromarkToken} [ancestor] Parent of top-most tokens.
+ * @returns {MicromarkToken[]} Micromark tokens.
+ */
+function parseInternal(
+  markdown,
+  parseOptions = {},
+  micromarkParseOptions = {},
+  lineDelta = 0,
+  ancestor = undefined
+) {
+  // Get options
+  const freezeTokens = Boolean(parseOptions.freezeTokens);
+
+  // Use micromark to parse document into Events
+  const events = getEvents(markdown, micromarkParseOptions);
+
+  // Create Token objects
+  /** @type {MicromarkToken[]} */
+  const document = [];
+  /** @type {MicromarkToken[]} */
+  let flatTokens = [];
+  /** @type {MicromarkToken} */
+  const root = {
+    "type": "data",
+    "startLine": -1,
+    "startColumn": -1,
+    "endLine": -1,
+    "endColumn": -1,
+    "text": "ROOT",
+    "children": document,
+    "parent": null
+  };
+  const history = [ root ];
+  let current = root;
+  /** @type {MicromarkParseOptions | null} */
+  let reparseOptions = null;
+  let lines = null;
+  let skipHtmlFlowChildren = false;
+  for (const event of events) {
+    const [ kind, token ] = event;
+    const { type, start, end } = token;
+    const { "column": startColumn, "line": startLine } = start;
+    const { "column": endColumn, "line": endLine } = end;
+    const text = getText(markdown, token);
+    if ((kind === "enter") && !skipHtmlFlowChildren) {
+      const previous = current;
+      history.push(previous);
+      current = {
+        type,
+        "startLine": startLine + lineDelta,
+        startColumn,
+        "endLine": endLine + lineDelta,
+        endColumn,
+        text,
+        "children": [],
+        "parent": ((previous === root) ? (ancestor || null) : previous)
+      };
+      if (ancestor) {
+        Object.defineProperty(current, htmlFlowSymbol, { "value": true });
+      }
+      previous.children.push(current);
+      flatTokens.push(current);
+      if ((current.type === "htmlFlow") && !isHtmlFlowComment(current)) {
+        skipHtmlFlowChildren = true;
+        if (!reparseOptions || !lines) {
+          reparseOptions = {
+            ...micromarkParseOptions,
+            "extensions": [
+              {
+                "disable": {
+                  "null": [ "codeIndented", "htmlFlow" ]
+                }
+              }
+            ]
+          };
+          lines = markdown.split(newlineRe);
+        }
+        const reparseMarkdown = lines
+          .slice(current.startLine - 1, current.endLine)
+          .join("\n");
+        const tokens = parseInternal(
+          reparseMarkdown,
+          parseOptions,
+          reparseOptions,
+          current.startLine - 1,
+          current
+        );
+        current.children = tokens;
+        // eslint-disable-next-line unicorn/comment-content
+        // Avoid stack overflow of Array.push(...spread)
+        // @ts-ignore
+        // eslint-disable-next-line unicorn/no-array-concat-in-loop
+        flatTokens = flatTokens.concat(tokens[flatTokensSymbol]);
+      }
+    } else if (kind === "exit") {
+      if (type === "htmlFlow") {
+        skipHtmlFlowChildren = false;
+      }
+      if (!skipHtmlFlowChildren) {
+        if (freezeTokens) {
+          Object.freeze(current.children);
+          Object.freeze(current);
+        }
+        // @ts-ignore
+        current = history.pop();
+      }
+    }
+  }
+
+  // Return document
+  Object.defineProperty(document, flatTokensSymbol, { "value": flatTokens });
+  if (freezeTokens) {
+    Object.freeze(document);
+  }
+  return document;
+}
+
+/**
+ * Parses a Markdown document and returns micromark tokens.
+ *
+ * @param {string} markdown Markdown document.
+ * @param {ParseOptions} [parseOptions] Options.
+ * @returns {MicromarkToken[]} Micromark tokens.
+ */
+export function parse(markdown, parseOptions) {
+  return parseInternal(markdown, parseOptions);
+}