@alexlit/lint-kit 112.3.3 → 112.3.4

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

@@ -1,25 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, filterTokens } = require("../helpers");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD001", "heading-increment" ],
-  "description": "Heading levels should only increment by one level at a time",
-  "tags": [ "headings" ],
-  "parser": "markdownit",
-  "function": function MD001(params, onError) {
-    let prevLevel = 0;
-    filterTokens(params, "heading_open", function forToken(token) {
-      const level = Number.parseInt(token.tag.slice(1), 10);
-      if (prevLevel && (level > prevLevel)) {
-        addErrorDetailIf(onError, token.lineNumber,
-          "h" + (prevLevel + 1), "h" + level);
-      }
-      prevLevel = level;
-    });
-  }
-};

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

@@ -1,45 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, filterTokens, headingStyleFor } =
-  require("../helpers");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD003", "heading-style" ],
-  "description": "Heading style",
-  "tags": [ "headings" ],
-  "parser": "markdownit",
-  "function": function MD003(params, onError) {
-    let style = String(params.config.style || "consistent");
-    filterTokens(params, "heading_open", function forToken(token) {
-      const styleForToken = headingStyleFor(token);
-      if (style === "consistent") {
-        style = styleForToken;
-      }
-      if (styleForToken !== style) {
-        const h12 = /h[12]/.test(token.tag);
-        const setextWithAtx =
-          (style === "setext_with_atx") &&
-            ((h12 && (styleForToken === "setext")) ||
-            (!h12 && (styleForToken === "atx")));
-        const setextWithAtxClosed =
-          (style === "setext_with_atx_closed") &&
-            ((h12 && (styleForToken === "setext")) ||
-            (!h12 && (styleForToken === "atx_closed")));
-        if (!setextWithAtx && !setextWithAtxClosed) {
-          let expected = style;
-          if (style === "setext_with_atx") {
-            expected = h12 ? "setext" : "atx";
-          } else if (style === "setext_with_atx_closed") {
-            expected = h12 ? "setext" : "atx_closed";
-          }
-          addErrorDetailIf(onError, token.lineNumber,
-            expected, styleForToken);
-        }
-      }
-    });
-  }
-};

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

@@ -1,79 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, listItemMarkerRe, unorderedListStyleFor } =
-  require("../helpers");
-const { flattenedLists } = require("./cache");
-
-const expectedStyleToMarker = {
-  "dash": "-",
-  "plus": "+",
-  "asterisk": "*"
-};
-const differentItemStyle = {
-  "dash": "plus",
-  "plus": "asterisk",
-  "asterisk": "dash"
-};
-const validStyles = Object.keys(expectedStyleToMarker);
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD004", "ul-style" ],
-  "description": "Unordered list style",
-  "tags": [ "bullet", "ul" ],
-  "parser": "none",
-  "function": function MD004(params, onError) {
-    const style = String(params.config.style || "consistent");
-    let expectedStyle = style;
-    const nestingStyles = [];
-    for (const list of flattenedLists()) {
-      if (list.unordered) {
-        if (expectedStyle === "consistent") {
-          expectedStyle = unorderedListStyleFor(list.items[0]);
-        }
-        for (const item of list.items) {
-          const itemStyle = unorderedListStyleFor(item);
-          if (style === "sublist") {
-            const nesting = list.nesting;
-            if (!nestingStyles[nesting]) {
-              nestingStyles[nesting] =
-                (itemStyle === nestingStyles[nesting - 1]) ?
-                  differentItemStyle[itemStyle] :
-                  itemStyle;
-            }
-            expectedStyle = nestingStyles[nesting];
-          }
-          if (!validStyles.includes(expectedStyle)) {
-            expectedStyle = validStyles[0];
-          }
-          let range = null;
-          let fixInfo = null;
-          const match = item.line.match(listItemMarkerRe);
-          if (match) {
-            const column = match.index + 1;
-            const length = match[0].length;
-            range = [ column, length ];
-            fixInfo = {
-              "editColumn": match[1].length + 1,
-              "deleteCount": 1,
-              "insertText": expectedStyleToMarker[expectedStyle]
-            };
-          }
-          addErrorDetailIf(
-            onError,
-            item.lineNumber,
-            expectedStyle,
-            itemStyle,
-            null,
-            null,
-            range,
-            fixInfo
-          );
-        }
-      }
-    }
-  }
-};

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

@@ -1,81 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, addErrorDetailIf } = require("../helpers");
-const { filterByTypes, inHtmlFlow } = require("../helpers/micromark.cjs");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD005", "list-indent" ],
-  "description": "Inconsistent indentation for list items at the same level",
-  "tags": [ "bullet", "ul", "indentation" ],
-  "parser": "micromark",
-  "function": function MD005(params, onError) {
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const lists = filterByTypes(
-      micromarkTokens,
-      [ "listOrdered", "listUnordered" ]
-    ).filter((list) => !inHtmlFlow(list));
-    for (const list of lists) {
-      const expectedIndent = list.startColumn - 1;
-      let expectedEnd = 0;
-      let endMatching = false;
-      const listItemPrefixes =
-        list.children.filter((token) => (token.type === "listItemPrefix"));
-      for (const listItemPrefix of listItemPrefixes) {
-        const lineNumber = listItemPrefix.startLine;
-        const actualIndent = listItemPrefix.startColumn - 1;
-        const range = [ 1, listItemPrefix.endColumn - 1 ];
-        if (list.type === "listUnordered") {
-          addErrorDetailIf(
-            onError,
-            lineNumber,
-            expectedIndent,
-            actualIndent,
-            null,
-            null,
-            range
-            // No fixInfo; MD007 handles this scenario better
-          );
-        } else {
-          const markerLength = listItemPrefix.text.trim().length;
-          const actualEnd = listItemPrefix.startColumn + markerLength - 1;
-          expectedEnd = expectedEnd || actualEnd;
-          if ((expectedIndent !== actualIndent) || endMatching) {
-            if (expectedEnd === actualEnd) {
-              endMatching = true;
-            } else {
-              const detail = endMatching ?
-                `Expected: (${expectedEnd}); Actual: (${actualEnd})` :
-                `Expected: ${expectedIndent}; Actual: ${actualIndent}`;
-              const expected = endMatching ?
-                expectedEnd - markerLength :
-                expectedIndent;
-              const actual = endMatching ?
-                actualEnd - markerLength :
-                actualIndent;
-              addError(
-                onError,
-                lineNumber,
-                detail,
-                undefined,
-                range,
-                {
-                  "editColumn": Math.min(actual, expected) + 1,
-                  "deleteCount": Math.max(actual - expected, 0),
-                  "insertText": "".padEnd(Math.max(expected - actual, 0))
-                }
-              );
-            }
-          }
-        }
-      }
-    }
-  }
-};

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

@@ -1,92 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf } = require("../helpers");
-const { filterByTypes, getTokenParentOfType, inHtmlFlow } =
-  require("../helpers/micromark.cjs");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("markdownlint-micromark").TokenType[] */
-const unorderedListTypes =
-  [ "blockQuotePrefix", "listItemPrefix", "listUnordered" ];
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("markdownlint-micromark").TokenType[] */
-const unorderedParentTypes =
-  [ "blockQuote", "listOrdered", "listUnordered" ];
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD007", "ul-indent" ],
-  "description": "Unordered list indentation",
-  "tags": [ "bullet", "ul", "indentation" ],
-  "parser": "micromark",
-  "function": function MD007(params, onError) {
-    const indent = Number(params.config.indent || 2);
-    const startIndented = !!params.config.start_indented;
-    const startIndent = Number(params.config.start_indent || indent);
-    // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").Token[] */
-    const micromarkTokens =
-      // @ts-ignore
-      params.parsers.micromark.tokens;
-    const unorderedListNesting = new Map();
-    let lastBlockQuotePrefix = null;
-    const tokens = filterByTypes(micromarkTokens, unorderedListTypes);
-    for (const token of tokens) {
-      const { endColumn, parent, startColumn, startLine, type } = token;
-      if (type === "blockQuotePrefix") {
-        lastBlockQuotePrefix = token;
-      } else if (type === "listUnordered") {
-        let nesting = 0;
-        /** @type {import("../helpers/micromark.cjs").Token | null} */
-        let current = token;
-        while (
-          (current = getTokenParentOfType(current, unorderedParentTypes))
-        ) {
-          if (current.type === "listUnordered") {
-            nesting++;
-            // eslint-disable-next-line no-continue
-            continue;
-          } else if (current.type === "listOrdered") {
-            nesting = -1;
-          }
-          break;
-        }
-        if (nesting >= 0) {
-          unorderedListNesting.set(token, nesting);
-        }
-      } else if (!inHtmlFlow(token)) {
-        // listItemPrefix
-        const nesting = unorderedListNesting.get(parent);
-        if (nesting !== undefined) {
-          // listItemPrefix for listUnordered
-          const expectedIndent =
-            (startIndented ? startIndent : 0) + (nesting * indent);
-          const blockQuoteAdjustment =
-            (lastBlockQuotePrefix?.endLine === startLine) ?
-              (lastBlockQuotePrefix.endColumn - 1) :
-              0;
-          const actualIndent = startColumn - 1 - blockQuoteAdjustment;
-          const range = [ 1, endColumn - 1 ];
-          const fixInfo = {
-            "editColumn": startColumn - actualIndent,
-            "deleteCount": Math.max(actualIndent - expectedIndent, 0),
-            "insertText": "".padEnd(Math.max(expectedIndent - actualIndent, 0))
-          };
-          addErrorDetailIf(
-            onError,
-            startLine,
-            expectedIndent,
-            actualIndent,
-            undefined,
-            undefined,
-            range,
-            fixInfo
-          );
-        }
-      }
-    }
-  }
-};

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

@@ -1,89 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, filterTokens, forEachLine, includesSorted,
-  numericSortAscending } = require("../helpers");
-const { lineMetadata } = require("./cache");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD009", "no-trailing-spaces" ],
-  "description": "Trailing spaces",
-  "tags": [ "whitespace" ],
-  "parser": "markdownit",
-  "function": function MD009(params, onError) {
-    let brSpaces = params.config.br_spaces;
-    brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces);
-    const listItemEmptyLines = !!params.config.list_item_empty_lines;
-    const strict = !!params.config.strict;
-    const listItemLineNumbers = [];
-    if (listItemEmptyLines) {
-      filterTokens(params, "list_item_open", (token) => {
-        for (let i = token.map[0]; i < token.map[1]; i++) {
-          listItemLineNumbers.push(i + 1);
-        }
-      });
-      listItemLineNumbers.sort(numericSortAscending);
-    }
-    const paragraphLineNumbers = [];
-    const codeInlineLineNumbers = [];
-    if (strict) {
-      filterTokens(params, "paragraph_open", (token) => {
-        for (let i = token.map[0]; i < token.map[1] - 1; i++) {
-          paragraphLineNumbers.push(i + 1);
-        }
-      });
-      const addLineNumberRange = (start, end) => {
-        for (let i = start; i < end; i++) {
-          codeInlineLineNumbers.push(i);
-        }
-      };
-      filterTokens(params, "inline", (token) => {
-        let start = 0;
-        for (const child of token.children) {
-          if (start > 0) {
-            addLineNumberRange(start, child.lineNumber);
-            start = 0;
-          }
-          if (child.type === "code_inline") {
-            start = child.lineNumber;
-          }
-        }
-        if (start > 0) {
-          addLineNumberRange(start, token.map[1]);
-        }
-      });
-    }
-    const expected = (brSpaces < 2) ? 0 : brSpaces;
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      const lineNumber = lineIndex + 1;
-      const trailingSpaces = line.length - line.trimEnd().length;
-      if (
-        trailingSpaces &&
-        !inCode &&
-        !includesSorted(listItemLineNumbers, lineNumber) &&
-        (
-          (expected !== trailingSpaces) ||
-          (strict &&
-            (!includesSorted(paragraphLineNumbers, lineNumber) ||
-             includesSorted(codeInlineLineNumbers, lineNumber)))
-        )
-      ) {
-        const column = line.length - trailingSpaces + 1;
-        addError(
-          onError,
-          lineNumber,
-          "Expected: " + (expected === 0 ? "" : "0 or ") +
-            expected + "; Actual: " + trailingSpaces,
-          undefined,
-          [ column, trailingSpaces ],
-          {
-            "editColumn": column,
-            "deleteCount": trailingSpaces
-          });
-      }
-    });
-  }
-};

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

@@ -1,63 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, filterTokens, forEachLine, withinAnyRange } =
-  require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
-
-const tabRe = /\t+/g;
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD010", "no-hard-tabs" ],
-  "description": "Hard tabs",
-  "tags": [ "whitespace", "hard_tab" ],
-  "parser": "markdownit",
-  "function": function MD010(params, onError) {
-    const codeBlocks = params.config.code_blocks;
-    const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks;
-    const ignoreCodeLanguages = new Set(
-      (params.config.ignore_code_languages || [])
-        .map((language) => language.toLowerCase())
-    );
-    const spacesPerTab = params.config.spaces_per_tab;
-    const spaceMultiplier = (spacesPerTab === undefined) ?
-      1 :
-      Math.max(0, Number(spacesPerTab));
-    const exclusions = includeCode ? [] : codeBlockAndSpanRanges();
-    filterTokens(params, "fence", (token) => {
-      const language = token.info.trim().toLowerCase();
-      if (ignoreCodeLanguages.has(language)) {
-        for (let i = token.map[0] + 1; i < token.map[1] - 1; i++) {
-          exclusions.push([ i, 0, params.lines[i].length ]);
-        }
-      }
-    });
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      if (includeCode || !inCode) {
-        let match = null;
-        while ((match = tabRe.exec(line)) !== null) {
-          const { index } = match;
-          const column = index + 1;
-          const length = match[0].length;
-          if (!withinAnyRange(exclusions, lineIndex, index, length)) {
-            addError(
-              onError,
-              lineIndex + 1,
-              "Column: " + column,
-              undefined,
-              [ column, length ],
-              {
-                "editColumn": column,
-                "deleteCount": length,
-                "insertText": "".padEnd(length * spaceMultiplier)
-              }
-            );
-          }
-        }
-      }
-    });
-  }
-};

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

@@ -1,49 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addError, forEachLine, withinAnyRange } = require("../helpers");
-const { codeBlockAndSpanRanges, lineMetadata } = require("./cache");
-
-const reversedLinkRe =
-  /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g;
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD011", "no-reversed-links" ],
-  "description": "Reversed link syntax",
-  "tags": [ "links" ],
-  "parser": "none",
-  "function": function MD011(params, onError) {
-    const exclusions = codeBlockAndSpanRanges();
-    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => {
-      if (!inCode && !onFence) {
-        let match = null;
-        while ((match = reversedLinkRe.exec(line)) !== null) {
-          const [ reversedLink, preChar, linkText, linkDestination ] = match;
-          const index = match.index + preChar.length;
-          const length = match[0].length - preChar.length;
-          if (
-            !linkText.endsWith("\\") &&
-            !linkDestination.endsWith("\\") &&
-            !withinAnyRange(exclusions, lineIndex, index, length)
-          ) {
-            addError(
-              onError,
-              lineIndex + 1,
-              reversedLink.slice(preChar.length),
-              undefined,
-              [ index + 1, length ],
-              {
-                "editColumn": index + 1,
-                "deleteCount": length,
-                "insertText": `[${linkText}](${linkDestination})`
-              }
-            );
-          }
-        }
-      }
-    });
-  }
-};

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

@@ -1,35 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, forEachLine } = require("../helpers");
-const { lineMetadata } = require("./cache");
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD012", "no-multiple-blanks" ],
-  "description": "Multiple consecutive blank lines",
-  "tags": [ "whitespace", "blank_lines" ],
-  "parser": "none",
-  "function": function MD012(params, onError) {
-    const maximum = Number(params.config.maximum || 1);
-    let count = 0;
-    forEachLine(lineMetadata(), (line, lineIndex, inCode) => {
-      count = (inCode || (line.trim().length > 0)) ? 0 : count + 1;
-      if (maximum < count) {
-        addErrorDetailIf(
-          onError,
-          lineIndex + 1,
-          maximum,
-          count,
-          null,
-          null,
-          null,
-          {
-            "deleteCount": -1
-          });
-      }
-    });
-  }
-};

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

@@ -1,99 +0,0 @@
-// @ts-check
-
-"use strict";
-
-const { addErrorDetailIf, filterTokens, forEachHeading, forEachLine,
-  includesSorted } = require("../helpers");
-const { lineMetadata, referenceLinkImageData } = require("./cache");
-
-const longLineRePrefix = "^.{";
-const longLineRePostfixRelaxed = "}.*\\s.*$";
-const longLineRePostfixStrict = "}.+$";
-const linkOrImageOnlyLineRe = /^[es]*(?:lT?L|I)[ES]*$/;
-const sternModeRe = /^(?:[#>\s]*\s)?\S*$/;
-const tokenTypeMap = {
-  "em_open": "e",
-  "em_close": "E",
-  "image": "I",
-  "link_open": "l",
-  "link_close": "L",
-  "strong_open": "s",
-  "strong_close": "S",
-  "text": "T"
-};
-
-// eslint-disable-next-line jsdoc/valid-types
-/** @type import("./markdownlint").Rule */
-module.exports = {
-  "names": [ "MD013", "line-length" ],
-  "description": "Line length",
-  "tags": [ "line_length" ],
-  "parser": "markdownit",
-  "function": function MD013(params, onError) {
-    const lineLength = Number(params.config.line_length || 80);
-    const headingLineLength =
-      Number(params.config.heading_line_length || lineLength);
-    const codeLineLength =
-      Number(params.config.code_block_line_length || lineLength);
-    const strict = !!params.config.strict;
-    const stern = !!params.config.stern;
-    const longLineRePostfix =
-      (strict || stern) ? longLineRePostfixStrict : longLineRePostfixRelaxed;
-    const longLineRe =
-      new RegExp(longLineRePrefix + lineLength + longLineRePostfix);
-    const longHeadingLineRe =
-      new RegExp(longLineRePrefix + headingLineLength + longLineRePostfix);
-    const longCodeLineRe =
-      new RegExp(longLineRePrefix + codeLineLength + longLineRePostfix);
-    const codeBlocks = params.config.code_blocks;
-    const includeCodeBlocks = (codeBlocks === undefined) ? true : !!codeBlocks;
-    const tables = params.config.tables;
-    const includeTables = (tables === undefined) ? true : !!tables;
-    const headings = params.config.headings;
-    const includeHeadings = (headings === undefined) ? true : !!headings;
-    const headingLineNumbers = [];
-    forEachHeading(params, (heading) => {
-      headingLineNumbers.push(heading.lineNumber);
-    });
-    const linkOnlyLineNumbers = [];
-    filterTokens(params, "inline", (token) => {
-      let childTokenTypes = "";
-      for (const child of token.children) {
-        if (child.type !== "text" || child.content !== "") {
-          childTokenTypes += tokenTypeMap[child.type] || "x";
-        }
-      }
-      if (linkOrImageOnlyLineRe.test(childTokenTypes)) {
-        linkOnlyLineNumbers.push(token.lineNumber);
-      }
-    });
-    const { definitionLineIndices } = referenceLinkImageData();
-    forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence, inTable) => {
-      const lineNumber = lineIndex + 1;
-      const isHeading = includesSorted(headingLineNumbers, lineNumber);
-      const length = inCode ?
-        codeLineLength :
-        (isHeading ? headingLineLength : lineLength);
-      const lengthRe = inCode ?
-        longCodeLineRe :
-        (isHeading ? longHeadingLineRe : longLineRe);
-      if ((includeCodeBlocks || !inCode) &&
-          (includeTables || !inTable) &&
-          (includeHeadings || !isHeading) &&
-          !includesSorted(definitionLineIndices, lineIndex) &&
-          (strict ||
-           (!(stern && sternModeRe.test(line)) &&
-            !includesSorted(linkOnlyLineNumbers, lineNumber))) &&
-          lengthRe.test(line)) {
-        addErrorDetailIf(
-          onError,
-          lineNumber,
-          length,
-          line.length,
-          null,
-          null,
-          [ length + 1, line.length - length ]);
-      }
-    });
-  }
-};