@alexlit/lint-kit 107.2.2 → 108.0.0

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

@@ -1,49 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, escapeForRegExp, filterTokens } =
-  require("../helpers");
-
-module.exports = {
-  "names": [ "MD042", "no-empty-links" ],
-  "description": "No empty links",
-  "tags": [ "links" ],
-  "function": function MD042(params, onError) {
-    filterTokens(params, "inline", function forToken(token) {
-      let inLink = false;
-      let linkText = "";
-      let emptyLink = false;
-      for (const child of token.children) {
-        if (child.type === "link_open") {
-          inLink = true;
-          linkText = "";
-          for (const attr of child.attrs) {
-            if (attr[0] === "href" && (!attr[1] || (attr[1] === "#"))) {
-              emptyLink = true;
-            }
-          }
-        } else if (child.type === "link_close") {
-          inLink = false;
-          if (emptyLink) {
-            let context = `[${linkText}]`;
-            let range = null;
-            const match = child.line.match(
-              new RegExp(`${escapeForRegExp(context)}\\((?:|#|<>)\\)`)
-            );
-            if (match) {
-              context = match[0];
-              range = [ match.index + 1, match[0].length ];
-            }
-            addErrorContext(
-              onError, child.lineNumber, context, null, null, range
-            );
-            emptyLink = false;
-          }
-        } else if (inLink) {
-          linkText += child.content;
-        }
-      }
-    });
-  }
-};

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

@@ -1,64 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorContext, addErrorDetailIf, forEachHeading } =
-  require("../helpers");
-
-module.exports = {
-  "names": [ "MD043", "required-headings" ],
-  "description": "Required heading structure",
-  "tags": [ "headings" ],
-  "function": function MD043(params, onError) {
-    const requiredHeadings = params.config.headings;
-    if (!Array.isArray(requiredHeadings)) {
-      // Nothing to check; avoid doing any work
-      return;
-    }
-    const matchCase = params.config.match_case || false;
-    const levels = {};
-    for (const level of [ 1, 2, 3, 4, 5, 6 ]) {
-      levels["h" + level] = "######".substr(-level);
-    }
-    let i = 0;
-    let matchAny = false;
-    let hasError = false;
-    let anyHeadings = false;
-    const getExpected = () => requiredHeadings[i++] || "[None]";
-    const handleCase = (str) => (matchCase ? str : str.toLowerCase());
-    forEachHeading(params, (heading, content) => {
-      if (!hasError) {
-        anyHeadings = true;
-        const actual = levels[heading.tag] + " " + content;
-        const expected = getExpected();
-        if (expected === "*") {
-          const nextExpected = getExpected();
-          if (handleCase(nextExpected) !== handleCase(actual)) {
-            matchAny = true;
-            i--;
-          }
-        } else if (expected === "+") {
-          matchAny = true;
-        } else if (handleCase(expected) === handleCase(actual)) {
-          matchAny = false;
-        } else if (matchAny) {
-          i--;
-        } else {
-          addErrorDetailIf(onError, heading.lineNumber,
-            expected, actual);
-          hasError = true;
-        }
-      }
-    });
-    const extraHeadings = requiredHeadings.length - i;
-    if (
-      !hasError &&
-      ((extraHeadings > 1) ||
-        ((extraHeadings === 1) && (requiredHeadings[i] !== "*"))) &&
-      (anyHeadings || !requiredHeadings.every((heading) => heading === "*"))
-    ) {
-      addErrorContext(onError, params.lines.length,
-        requiredHeadings[i]);
-    }
-  }
-};

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

@@ -1,107 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, escapeForRegExp, withinAnyRange } =
-  require("../helpers");
-const { filterByPredicate, filterByTypes, parse } =
-  require("../helpers/micromark.cjs");
-
-const ignoredChildTypes = new Set(
-  [ "codeFencedFence", "definition", "reference", "resource" ]
-);
-
-module.exports = {
-  "names": [ "MD044", "proper-names" ],
-  "description": "Proper names should have the correct capitalization",
-  "tags": [ "spelling" ],
-  "function": function MD044(params, onError) {
-    let names = params.config.names;
-    names = Array.isArray(names) ? names : [];
-    names.sort((a, b) => (b.length - a.length) || a.localeCompare(b));
-    if (names.length === 0) {
-      // Nothing to check; avoid doing any work
-      return;
-    }
-    const codeBlocks = params.config.code_blocks;
-    const includeCodeBlocks =
-      (codeBlocks === undefined) ? true : !!codeBlocks;
-    const htmlElements = params.config.html_elements;
-    const includeHtmlElements =
-      (htmlElements === undefined) ? true : !!htmlElements;
-    const scannedTypes = new Set([ "data" ]);
-    if (includeCodeBlocks) {
-      scannedTypes.add("codeFlowValue");
-      scannedTypes.add("codeTextData");
-    }
-    if (includeHtmlElements) {
-      scannedTypes.add("htmlFlowData");
-      scannedTypes.add("htmlTextData");
-    }
-    const contentTokens =
-      filterByPredicate(
-        params.parsers.micromark.tokens,
-        (token) => scannedTypes.has(token.type),
-        (token) => (
-          token.children.filter((t) => !ignoredChildTypes.has(t.type))
-        )
-      );
-    const exclusions = [];
-    const autoLinked = new Set();
-    for (const name of names) {
-      const escapedName = escapeForRegExp(name);
-      const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
-      const endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
-      const namePattern =
-        `(${startNamePattern})(${escapedName})${endNamePattern}`;
-      const nameRe = new RegExp(namePattern, "gi");
-      for (const token of contentTokens) {
-        let match = null;
-        while ((match = nameRe.exec(token.text)) !== null) {
-          const [ , leftMatch, nameMatch ] = match;
-          const index = token.startColumn - 1 + match.index + leftMatch.length;
-          const length = nameMatch.length;
-          const lineIndex = token.startLine - 1;
-          if (
-            !withinAnyRange(exclusions, lineIndex, index, length) &&
-            !names.includes(nameMatch)
-          ) {
-            let urlRanges = [];
-            if (!autoLinked.has(token)) {
-              urlRanges = filterByTypes(
-                parse(token.text),
-                [ "literalAutolink" ]
-              ).map(
-                (t) => [
-                  lineIndex,
-                  token.startColumn - 1 + t.startColumn - 1,
-                  t.endColumn - t.startColumn
-                ]
-              );
-              exclusions.push(...urlRanges);
-              autoLinked.add(token);
-            }
-            if (!withinAnyRange(urlRanges, lineIndex, index, length)) {
-              const column = index + 1;
-              addErrorDetailIf(
-                onError,
-                token.startLine,
-                name,
-                nameMatch,
-                null,
-                null,
-                [ column, length ],
-                {
-                  "editColumn": column,
-                  "deleteCount": length,
-                  "insertText": name
-                }
-              );
-            }
-          }
-          exclusions.push([ lineIndex, index, length ]);
-        }
-      }
-    }
-  }
-};

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

@@ -1,60 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, getHtmlAttributeRe, nextLinesRe } = require("../helpers");
-const { filterByTypes, getHtmlTagInfo } = require("../helpers/micromark.cjs");
-
-const altRe = getHtmlAttributeRe("alt");
-
-module.exports = {
-  "names": [ "MD045", "no-alt-text" ],
-  "description": "Images should have alternate text (alt text)",
-  "tags": [ "accessibility", "images" ],
-  "function": function MD045(params, onError) {
-    const { tokens } = params.parsers.micromark;
-
-    // Process Markdown images
-    const images = filterByTypes(tokens, [ "image" ]);
-    for (const image of images) {
-      const labelTexts = filterByTypes(image.children, [ "labelText" ]);
-      if (labelTexts.some((labelText) => labelText.text.length === 0)) {
-        const range = (image.startLine === image.endLine) ?
-          [ image.startColumn, image.endColumn - image.startColumn ] :
-          undefined;
-        addError(
-          onError,
-          image.startLine,
-          undefined,
-          undefined,
-          range
-        );
-      }
-    }
-
-    // Process HTML images
-    const htmlTexts = filterByTypes(tokens, [ "htmlText" ]);
-    for (const htmlText of htmlTexts) {
-      const { startColumn, startLine, text } = htmlText;
-      const htmlTagInfo = getHtmlTagInfo(htmlText);
-      if (
-        htmlTagInfo &&
-        !htmlTagInfo.close &&
-        (htmlTagInfo.name.toLowerCase() === "img") &&
-        !altRe.test(text)
-      ) {
-        const range = [
-          startColumn,
-          text.replace(nextLinesRe, "").length
-        ];
-        addError(
-          onError,
-          startLine,
-          undefined,
-          undefined,
-          range
-        );
-      }
-    }
-  }
-};

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

@@ -1,33 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf } = require("../helpers");
-
-const tokenTypeToStyle = {
-  "fence": "fenced",
-  "code_block": "indented"
-};
-
-module.exports = {
-  "names": [ "MD046", "code-block-style" ],
-  "description": "Code block style",
-  "tags": [ "code" ],
-  "function": function MD046(params, onError) {
-    let expectedStyle = String(params.config.style || "consistent");
-    const codeBlocksAndFences = params.parsers.markdownit.tokens.filter(
-      (token) => (token.type === "code_block") || (token.type === "fence")
-    );
-    for (const token of codeBlocksAndFences) {
-      const { lineNumber, type } = token;
-      if (expectedStyle === "consistent") {
-        expectedStyle = tokenTypeToStyle[type];
-      }
-      addErrorDetailIf(
-        onError,
-        lineNumber,
-        expectedStyle,
-        tokenTypeToStyle[type]);
-    }
-  }
-};

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

@@ -1,28 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, isBlankLine } = require("../helpers");
-
-module.exports = {
-  "names": [ "MD047", "single-trailing-newline" ],
-  "description": "Files should end with a single newline character",
-  "tags": [ "blank_lines" ],
-  "function": function MD047(params, onError) {
-    const lastLineNumber = params.lines.length;
-    const lastLine = params.lines[lastLineNumber - 1];
-    if (!isBlankLine(lastLine)) {
-      addError(
-        onError,
-        lastLineNumber,
-        null,
-        null,
-        [ lastLine.length, 1 ],
-        {
-          "insertText": "\n",
-          "editColumn": lastLine.length + 1
-        }
-      );
-    }
-  }
-};

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

@@ -1,30 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, fencedCodeBlockStyleFor } = require("../helpers");
-
-module.exports = {
-  "names": [ "MD048", "code-fence-style" ],
-  "description": "Code fence style",
-  "tags": [ "code" ],
-  "function": function MD048(params, onError) {
-    const style = String(params.config.style || "consistent");
-    let expectedStyle = style;
-    const fenceTokens = params.parsers.markdownit.tokens.filter(
-      (token) => token.type === "fence"
-    );
-    for (const fenceToken of fenceTokens) {
-      const { lineNumber, markup } = fenceToken;
-      if (expectedStyle === "consistent") {
-        expectedStyle = fencedCodeBlockStyleFor(markup);
-      }
-      addErrorDetailIf(
-        onError,
-        lineNumber,
-        expectedStyle,
-        fencedCodeBlockStyleFor(markup)
-      );
-    }
-  }
-};

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

@@ -1,89 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, emphasisOrStrongStyleFor } = require("../helpers");
-const { filterByPredicate, tokenIfType } = require("../helpers/micromark.cjs");
-
-const intrawordRe = /\w/;
-
-const impl =
-  (params, onError, type, 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 { children } = token;
-      const childType = `${type}Sequence`;
-      const startSequence = tokenIfType(children[0], childType);
-      const endSequence = tokenIfType(children[children.length - 1], childType);
-      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
-                }
-              );
-            }
-          }
-        }
-      }
-    }
-  };
-
-module.exports = [
-  {
-    "names": [ "MD049", "emphasis-style" ],
-    "description": "Emphasis style",
-    "tags": [ "emphasis" ],
-    "function": function MD049(params, onError) {
-      return impl(
-        params,
-        onError,
-        "emphasis",
-        "*",
-        "_",
-        params.config.style || undefined
-      );
-    }
-  },
-  {
-    "names": [ "MD050", "strong-style" ],
-    "description": "Strong style",
-    "tags": [ "emphasis" ],
-    "function": function MD050(params, onError) {
-      return impl(
-        params,
-        onError,
-        "strong",
-        "**",
-        "__",
-        params.config.style || undefined
-      );
-    }
-  }
-];

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

@@ -1,172 +0,0 @@
-// @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;
-
-// Sets for filtering heading tokens during conversion
-const childrenExclude = new Set([ "image", "reference", "resource" ]);
-const tokensInclude = new Set(
-  [ "characterEscapeValue", "codeTextData", "data" ]
-);
-
-/**
- * @typedef {import("../helpers/micromark.cjs").Token} Token
- */
-
-/**
- * Converts a Markdown heading into an HTML fragment according to the rules
- * used by GitHub.
- *
- * @param {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 {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("");
-}
-
-module.exports = {
-  "names": [ "MD051", "link-fragments" ],
-  "description": "Link fragments should be valid",
-  "tags": [ "links" ],
-  "function": function MD051(params, onError) {
-    const { tokens } = params.parsers.micromark;
-    const fragments = new Map();
-
-    // Process headings
-    const headingTexts = filterByTypes(
-      tokens,
-      [ "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(tokens, [ "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
-    const parentChilds = [
-      [ "link", "resourceDestinationString" ],
-      [ "definition", "definitionDestinationString" ]
-    ];
-    for (const [ parentType, definitionType ] of parentChilds) {
-      const links = filterByTypes(tokens, [ 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);
-          if (
-            (text.length > 1) &&
-            text.startsWith("#") &&
-            !fragments.has(text) &&
-            !fragments.has(`#${encodeURIComponent(text.slice(1))}`)
-          ) {
-            // 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

@@ -1,39 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError } = require("../helpers");
-const { referenceLinkImageData } = require("./cache");
-
-module.exports = {
-  "names": [ "MD052", "reference-links-images" ],
-  "description":
-    "Reference links and images should use a label that is defined",
-  "tags": [ "images", "links" ],
-  "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 ]
-          );
-        }
-      }
-    }
-  }
-};