@alexlit/lint-kit 110.1.0 → 110.2.0

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,99 @@
+// @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 ]);
+      }
+    });
+  }
+};