@alexlit/lint-kit 190.0.1 → 191.0.0

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

@@ -1,57 +0,0 @@
-// @ts-check
-
-import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
-import { getBlockQuotePrefixText } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @typedef {import("micromark-extension-gfm-table")} */
-
-/** @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

@@ -1,71 +0,0 @@
-// @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

@@ -1,209 +0,0 @@
-// @ts-check
-
-import { filterByTypes } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-import stringWidth from "string-width";
-
-/** @typedef {import("micromark-extension-gfm-table")} */
-/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
-/** @typedef {import("markdownlint").RuleOnErrorInfo} RuleOnErrorInfo */
-/** @typedef {import("markdownlint").RuleOnErrorFixInfo} RuleOnErrorFixInfo */
-
-/**
- * Adds a RuleOnErrorInfo object to a list of RuleOnErrorInfo objects.
- *
- * @param {RuleOnErrorInfo[]} errors List of errors.
- * @param {number} lineNumber Line number.
- * @param {number} column Column number.
- * @param {string} detail Detail message.
- * @param {RuleOnErrorFixInfo} [fixInfo] Fix information.
- */
-function addError(errors, lineNumber, column, detail, fixInfo) {
-  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, 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,
-                      startLine,
-                      startColumn,
-                      "Table pipe has extra space to the left for style \"compact\"",
-                      { "editColumn": previous.startColumn, "deleteCount": previous.text.length - 1 }
-                    );
-                  }
-                  addError(
-                    errorsIfTight,
-                    startLine,
-                    startColumn,
-                    "Table pipe has space to the left for style \"tight\"",
-                    { "editColumn": previous.startColumn, "deleteCount": previous.text.length }
-                  );
-                } else {
-                  addError(
-                    errorsIfCompact,
-                    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,
-                        startLine,
-                        startColumn,
-                        "Table pipe has extra space to the right for style \"compact\"",
-                        { "editColumn": next.startColumn, "deleteCount": next.text.length - 1 }
-                      );
-                    }
-                    addError(
-                      errorsIfTight,
-                      startLine,
-                      startColumn,
-                      "Table pipe has space to the right for style \"tight\"",
-                      { "editColumn": next.startColumn, "deleteCount": next.text.length }
-                    );
-                  }
-                } else {
-                  addError(
-                    errorsIfCompact,
-                    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 &&
-        ((errorsIfCompact.length < errorInfos.length) || !styleAlignedAllowed)
-      ) {
-        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

@@ -1,337 +0,0 @@
-// @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 {import("./micromark-types.d.mts")} */
-
-/**
- * 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;
-        // Avoid stack overflow of Array.push(...spread)
-        // @ts-ignore
-        // eslint-disable-next-line unicorn/prefer-spread
-        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);
-}

package/packages/config-markdownlint/node_modules/markdownlint/lib/micromark-types.d.mts

@@ -1,11 +0,0 @@
-export {};
-
-// Augment TokenTypeMap with markdownlint-specific types.
-declare module "micromark-util-types" {
-  export interface TokenTypeMap {
-    undefinedReference: "undefinedReference"
-    undefinedReferenceCollapsed: "undefinedReferenceCollapsed"
-    undefinedReferenceFull: "undefinedReferenceFull"
-    undefinedReferenceShortcut: "undefinedReferenceShortcut"
-  }
-}