@alexlit/lint-kit 216.1.0 → 217.0.1

package/packages/config-markdownlint/node_modules/markdownlint/helpers/micromark-helpers.cjs

@@ -1,328 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { flatTokensSymbol, htmlFlowSymbol, newlineRe } = require("./shared.cjs");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @typedef {import("micromark-util-types", { with: { "resolution-mode": "import" } }).TokenType} TokenType */
-/** @typedef {import("../lib/exports.mjs").MicromarkToken} Token */
-// eslint-disable-next-line jsdoc/valid-types
-/** @typedef {typeof import("../lib/micromark-types.d.mts", { with: { "resolution-mode": "import" } })} _ambient_ */
-
-/**
- * Determines if a Micromark token is within an htmlFlow type.
- *
- * @param {Token} token Micromark token.
- * @returns {boolean} True iff the token is within an htmlFlow type.
- */
-function inHtmlFlow(token) {
-  return Object.hasOwn(token, htmlFlowSymbol);
-}
-
-/**
- * Returns whether a token is an htmlFlow type containing an HTML comment.
- *
- * @param {Token} token Micromark token.
- * @returns {boolean} True iff token is htmlFlow containing a comment.
- */
-function isHtmlFlowComment(token) {
-  const { text, type } = token;
-  if (
-    (type === "htmlFlow") &&
-    text.startsWith("<!--") &&
-    text.endsWith("-->")
-  ) {
-    const comment = text.slice(4, -3);
-    return (
-      !comment.startsWith(">") &&
-      !comment.startsWith("->") &&
-      !comment.endsWith("-")
-      // The following condition from the CommonMark specification is commented
-      // to avoid parsing HTML comments that include "--" because that is NOT a
-      // condition of the HTML specification.
-      // https://spec.commonmark.org/0.30/#raw-html
-      // https://html.spec.whatwg.org/multipage/syntax.html#comments
-      // && !comment.includes("--")
-    );
-  }
-  return false;
-}
-
-/**
- * Adds a range of numbers to a set.
- *
- * @param {Set<number>} set Set of numbers.
- * @param {number} start Starting number.
- * @param {number} end Ending number.
- * @returns {void}
- */
-function addRangeToSet(set, start, end) {
-  for (let i = start; i <= end; i++) {
-    set.add(i);
-  }
-}
-
-/**
- * @callback AllowedPredicate
- * @param {Token} token Micromark token.
- * @returns {boolean} True iff allowed.
- */
-
-/**
- * @callback TransformPredicate
- * @param {Token} token Micromark token.
- * @returns {Token[]} Child tokens.
- */
-
-/**
- * Filter a list of Micromark tokens by predicate.
- *
- * @param {Token[]} tokens Micromark tokens.
- * @param {AllowedPredicate} allowed Allowed token predicate.
- * @param {TransformPredicate} [transformChildren] Transform predicate.
- * @returns {Token[]} Filtered tokens.
- */
-function filterByPredicate(tokens, allowed, transformChildren) {
-  const result = [];
-  const queue = [
-    {
-      "array": tokens,
-      "index": 0
-    }
-  ];
-  while (queue.length > 0) {
-    const current = queue[queue.length - 1];
-    const { array, index } = current;
-    if (index < array.length) {
-      const token = array[current.index++];
-      if (allowed(token)) {
-        result.push(token);
-      }
-      const { children } = token;
-      if (children.length > 0) {
-        const transformed =
-          transformChildren ? transformChildren(token) : children;
-        queue.push(
-          {
-            "array": transformed,
-            "index": 0
-          }
-        );
-      }
-    } else {
-      queue.pop();
-    }
-  }
-  return result;
-}
-
-/**
- * Filter a list of Micromark tokens by type.
- *
- * @param {Token[]} tokens Micromark tokens.
- * @param {TokenType[]} types Types to allow.
- * @param {boolean} [htmlFlow] Whether to include htmlFlow content.
- * @returns {Token[]} Filtered tokens.
- */
-function filterByTypes(tokens, types, htmlFlow) {
-  const predicate = (/** @type {Token} */ token) => types.includes(token.type) && (htmlFlow || !inHtmlFlow(token));
-  /** @type {Token[]} */
-  const flatTokens =
-    // @ts-ignore
-    tokens[flatTokensSymbol];
-  return flatTokens ?
-    flatTokens.filter(predicate) :
-    filterByPredicate(tokens, predicate);
-}
-
-/**
- * Gets the blockquote prefix text (if any) for the specified line number.
- *
- * @param {Token[]} tokens Micromark tokens.
- * @param {number} lineNumber Line number to examine.
- * @param {number} [count] Number of times to repeat.
- * @returns {string} Blockquote prefix text.
- */
-function getBlockQuotePrefixText(tokens, lineNumber, count = 1) {
-  return filterByTypes(tokens, [ "blockQuotePrefix", "linePrefix" ])
-    .filter((prefix) => prefix.startLine === lineNumber)
-    .map((prefix) => prefix.text)
-    .join("")
-    .trimEnd()
-    .concat("\n")
-    .repeat(count);
-};
-
-/**
- * Gets a list of nested Micromark token descendants by type path.
- *
- * @param {Token|Token[]} parent Micromark token parent or parents.
- * @param {(TokenType|TokenType[])[]} typePath Micromark token type path.
- * @returns {Token[]} Micromark token descendants.
- */
-function getDescendantsByType(parent, typePath) {
-  let tokens = Array.isArray(parent) ? parent : [ parent ];
-  for (const type of typePath) {
-    const predicate = (/** @type {Token} */ token) => Array.isArray(type) ? type.includes(token.type) : (type === token.type);
-    tokens = tokens.flatMap((t) => t.children.filter(predicate));
-  }
-  return tokens;
-}
-
-/**
- * Gets the heading level of a Micromark heading tokan.
- *
- * @param {Token} heading Micromark heading token.
- * @returns {number} Heading level.
- */
-function getHeadingLevel(heading) {
-  let level = 1;
-  const headingSequence = heading.children.find(
-    (child) => [ "atxHeadingSequence", "setextHeadingLine" ].includes(child.type)
-  );
-  // @ts-ignore
-  const { text } = headingSequence;
-  if (text[0] === "#") {
-    level = Math.min(text.length, 6);
-  } else if (text[0] === "-") {
-    level = 2;
-  }
-  return level;
-}
-
-/**
- * Gets the heading style of a Micromark heading tokan.
- *
- * @param {Token} heading Micromark heading token.
- * @returns {"atx" | "atx_closed" | "setext"} Heading style.
- */
-function getHeadingStyle(heading) {
-  if (heading.type === "setextHeading") {
-    return "setext";
-  }
-  const atxHeadingSequenceLength = heading.children.filter(
-    (child) => child.type === "atxHeadingSequence"
-  ).length;
-  return (atxHeadingSequenceLength === 1) ? "atx" : "atx_closed";
-}
-
-/**
- * Gets the heading text of a Micromark heading token.
- *
- * @param {Token} heading Micromark heading token.
- * @returns {string} Heading text.
- */
-function getHeadingText(heading) {
-  return getDescendantsByType(heading, [ [ "atxHeadingText", "setextHeadingText" ] ])
-    .flatMap((descendant) => descendant.children.filter((child) => child.type !== "htmlText"))
-    .map((data) => data.text)
-    .join("")
-    .replace(newlineRe, " ")
-    .trim();
-}
-
-/**
- * HTML tag information.
- *
- * @typedef {Object} HtmlTagInfo
- * @property {boolean} close True iff close tag.
- * @property {string} name Tag name.
- */
-
-/**
- * Gets information about the tag in an HTML token.
- *
- * @param {Token} token Micromark token.
- * @returns {HtmlTagInfo | null} HTML tag information.
- */
-function getHtmlTagInfo(token) {
-  const htmlTagNameRe = /^<([^!>][^/\s>]*)/;
-  if (token.type === "htmlText") {
-    const match = htmlTagNameRe.exec(token.text);
-    if (match) {
-      const name = match[1];
-      const close = name.startsWith("/");
-      return {
-        close,
-        "name": close ? name.slice(1) : name
-      };
-    }
-  }
-  return null;
-}
-
-/**
- * Gets the nearest parent of the specified type for a Micromark token.
- *
- * @param {Token} token Micromark token.
- * @param {TokenType[]} types Types to allow.
- * @returns {Token | null} Parent token.
- */
-function getParentOfType(token, types) {
-  /** @type {Token | null} */
-  let current = token;
-  while ((current = current.parent) && !types.includes(current.type)) {
-    // Empty
-  }
-  return current;
-}
-
-const docfxTabSyntaxRe = /^#tab\//;
-
-/**
- * Returns whether the specified Micromark token looks like a Docfx tab.
- *
- * @param {Token | null} heading Micromark token.
- * @returns {boolean} True iff the token looks like a Docfx tab.
- */
-function isDocfxTab(heading) {
-  // See https://dotnet.github.io/docfx/docs/markdown.html?tabs=linux%2Cdotnet#tabs
-  if (heading?.type === "atxHeading") {
-    const headingTexts = getDescendantsByType(heading, [ "atxHeadingText" ]);
-    // eslint-disable-next-line unicorn/better-dom-traversing
-    if ((headingTexts.length === 1) && (headingTexts[0].children.length === 1) && (headingTexts[0].children[0].type === "link")) {
-      // eslint-disable-next-line unicorn/better-dom-traversing
-      const resourceDestinationStrings = filterByTypes(headingTexts[0].children[0].children, [ "resourceDestinationString" ]);
-      return (resourceDestinationStrings.length === 1) && docfxTabSyntaxRe.test(resourceDestinationStrings[0].text);
-    }
-  }
-  return false;
-}
-
-/**
- * Set containing token types that do not contain content.
- *
- * @type {Set<TokenType>}
- */
-const nonContentTokens = new Set([
-  "blockQuoteMarker",
-  "blockQuotePrefix",
-  "blockQuotePrefixWhitespace",
-  "gfmFootnoteDefinitionIndent",
-  "lineEnding",
-  "lineEndingBlank",
-  "linePrefix",
-  "listItemIndent",
-  "undefinedReference",
-  "undefinedReferenceCollapsed",
-  "undefinedReferenceFull",
-  "undefinedReferenceShortcut"
-]);
-
-module.exports = {
-  addRangeToSet,
-  filterByPredicate,
-  filterByTypes,
-  getBlockQuotePrefixText,
-  getDescendantsByType,
-  getHeadingLevel,
-  getHeadingStyle,
-  getHeadingText,
-  getHtmlTagInfo,
-  getParentOfType,
-  inHtmlFlow,
-  isDocfxTab,
-  isHtmlFlowComment,
-  nonContentTokens
-};

package/packages/config-markdownlint/node_modules/markdownlint/helpers/package.json

@@ -1,22 +0,0 @@
-{
-  "name": "markdownlint-rule-helpers",
-  "version": "0.31.0",
-  "description": "A collection of markdownlint helper functions for custom rules",
-  "main": "./helpers.cjs",
-  "exports": {
-    ".": "./helpers.cjs",
-    "./micromark": "./micromark-helpers.cjs"
-  },
-  "author": "David Anson (https://dlaa.me/)",
-  "license": "MIT",
-  "homepage": "https://github.com/DavidAnson/markdownlint",
-  "repository": "github:DavidAnson/markdownlint",
-  "funding": "https://github.com/sponsors/DavidAnson",
-  "engines": {
-    "node": ">=22"
-  },
-  "keywords": [
-    "markdownlint",
-    "markdownlint-rule"
-  ]
-}

package/packages/config-markdownlint/node_modules/markdownlint/helpers/shared.cjs

@@ -1,16 +0,0 @@
-// @ts-check
-
-"use strict";
-
-// Symbol for identifying the flat tokens array from micromark parse
-module.exports.flatTokensSymbol = Symbol("flat-tokens");
-
-// Symbol for identifying the htmlFlow token from micromark parse
-module.exports.htmlFlowSymbol = Symbol("html-flow");
-
-// Regular expression for matching common newline characters
-// See NEWLINES_RE in markdown-it/lib/rules_core/normalize.js
-module.exports.newlineRe = /\r\n?|\n/g;
-
-// Regular expression for matching next lines
-module.exports.nextLinesRe = /[\r\n][\s\S]*$/;

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

@@ -1,81 +0,0 @@
-// @ts-check
-
-import { getReferenceLinkImageData as helpersGetReferenceLinkImageData } from "../helpers/helpers.cjs";
-import { filterByTypes } from "../helpers/micromark-helpers.cjs";
-
-/** @typedef {import("markdownlint").RuleParams} RuleParams */
-/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
-/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
-/** @typedef {import("../helpers/helpers.cjs").GetReferenceLinkImageDataResult} GetReferenceLinkImageDataResult */
-
-/** @type {Map<string, object>} */
-const map = new Map();
-/** @type {RuleParams | undefined} */
-let params = undefined;
-
-/**
- * Initializes (resets) the cache.
- *
- * @param {RuleParams} [p] Rule parameters object.
- * @returns {void}
- */
-export function initialize(p) {
-  map.clear();
-  // eslint-disable-next-line unicorn/no-top-level-assignment-in-function
-  params = p;
-}
-
-/**
- * Gets the cached Micromark token array (for testing).
- *
- * @returns {MicromarkToken[]} Micromark tokens.
- */
-export function micromarkTokens() {
-  return params?.parsers.micromark.tokens || [];
-}
-
-/**
- * Gets a cached object value - computes it and caches it.
- *
- * @param {string} name Cache object name.
- * @param {() => Object} getValue Getter for object value.
- * @returns {Object} Object value.
- */
-function getCached(name, getValue) {
-  if (map.has(name)) {
-    // @ts-ignore
-    return map.get(name);
-  }
-  const value = getValue();
-  map.set(name, value);
-  return value;
-}
-
-/**
- * Filters a list of Micromark tokens by type and caches the result.
- *
- * @param {MicromarkTokenType[]} types Types to allow.
- * @param {boolean} [htmlFlow] Whether to include htmlFlow content.
- * @returns {MicromarkToken[]} Filtered tokens.
- */
-export function filterByTypesCached(types, htmlFlow) {
-  // @ts-ignore
-  return getCached(
-    // eslint-disable-next-line prefer-rest-params
-    JSON.stringify(arguments),
-    () => filterByTypes(micromarkTokens(), types, htmlFlow)
-  );
-}
-
-/**
- * Gets a reference link and image data object.
- *
- * @returns {GetReferenceLinkImageDataResult} Reference link and image data object.
- */
-export function getReferenceLinkImageData() {
-  // @ts-ignore
-  return getCached(
-    getReferenceLinkImageData.name,
-    () => helpersGetReferenceLinkImageData(micromarkTokens())
-  );
-}