@alexlit/lint-kit 189.1.0 → 190.0.1

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

@@ -0,0 +1,84 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const listStyleExamples = {
+  "one": "1/1/1",
+  "ordered": "1/2/3",
+  "zero": "0/0/0"
+};
+const listStyles = Object.keys(listStyleExamples);
+
+/**
+ * Gets the column and text of an ordered list item prefix token.
+ *
+ * @param {import("markdownlint").MicromarkToken} listItemPrefix List item prefix token.
+ * @returns {{column: number, value: number}} List item value column and text.
+ */
+function getOrderedListItemValue(listItemPrefix) {
+  const listItemValue = getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0];
+  return {
+    "column": listItemValue.startColumn,
+    "value": Number(listItemValue.text)
+  };
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD029", "ol-prefix" ],
+  "description": "Ordered list item prefix",
+  "tags": [ "ol" ],
+  "parser": "micromark",
+  "function": function MD029(params, onError) {
+    const style = String(params.config.style);
+    for (const listOrdered of filterByTypesCached([ "listOrdered" ])) {
+      const listItemPrefixes = getDescendantsByType(listOrdered, [ "listItemPrefix" ]);
+      let expected = 1;
+      let incrementing = false;
+      // Check for incrementing number pattern 1/2/3 or 0/1/2
+      if (listItemPrefixes.length >= 2) {
+        const first = getOrderedListItemValue(listItemPrefixes[0]);
+        const second = getOrderedListItemValue(listItemPrefixes[1]);
+        if ((second.value !== 1) || (first.value === 0)) {
+          incrementing = true;
+          if (first.value === 0) {
+            expected = 0;
+          }
+        }
+      }
+      // Determine effective style
+      const listStyle = listStyles.includes(style) ? style : (incrementing ? "ordered" : "one");
+      if (listStyle === "zero") {
+        expected = 0;
+      } else if (listStyle === "one") {
+        expected = 1;
+      }
+      // Validate each list item marker
+      for (const listItemPrefix of listItemPrefixes) {
+        const orderedListItemValue = getOrderedListItemValue(listItemPrefix);
+        const actual = orderedListItemValue.value;
+        const fixInfo = {
+          "editColumn": orderedListItemValue.column,
+          "deleteCount": orderedListItemValue.value.toString().length,
+          "insertText": expected.toString()
+        };
+        addErrorDetailIf(
+          onError,
+          listItemPrefix.startLine,
+          expected,
+          actual,
+          // @ts-ignore
+          "Style: " + listStyleExamples[listStyle],
+          undefined,
+          [ listItemPrefix.startColumn, listItemPrefix.endColumn - listItemPrefix.startColumn ],
+          fixInfo
+        );
+        if (listStyle === "ordered") {
+          expected++;
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,57 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD030", "list-marker-space" ],
+  "description": "Spaces after list markers",
+  "tags": [ "ol", "ul", "whitespace" ],
+  "parser": "micromark",
+  "function": function MD030(params, onError) {
+    const ulSingle = Number(params.config.ul_single || 1);
+    const olSingle = Number(params.config.ol_single || 1);
+    const ulMulti = Number(params.config.ul_multi || 1);
+    const olMulti = Number(params.config.ol_multi || 1);
+    for (const list of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
+      const ordered = (list.type === "listOrdered");
+      const listItemPrefixes =
+        list.children.filter((token) => (token.type === "listItemPrefix"));
+      const allSingleLine =
+        (list.endLine - list.startLine + 1) === listItemPrefixes.length;
+      const expectedSpaces = ordered ?
+        (allSingleLine ? olSingle : olMulti) :
+        (allSingleLine ? ulSingle : ulMulti);
+      for (const listItemPrefix of listItemPrefixes) {
+        const range = [
+          listItemPrefix.startColumn,
+          listItemPrefix.endColumn - listItemPrefix.startColumn
+        ];
+        const listItemPrefixWhitespaces = listItemPrefix.children.filter(
+          (token) => (token.type === "listItemPrefixWhitespace")
+        );
+        for (const listItemPrefixWhitespace of listItemPrefixWhitespaces) {
+          const { endColumn, startColumn, startLine } =
+            listItemPrefixWhitespace;
+          const actualSpaces = endColumn - startColumn;
+          const fixInfo = {
+            "editColumn": startColumn,
+            "deleteCount": actualSpaces,
+            "insertText": "".padEnd(expectedSpaces)
+          };
+          addErrorDetailIf(
+            onError,
+            startLine,
+            expectedSpaces,
+            actualSpaces,
+            undefined,
+            undefined,
+            range,
+            fixInfo
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,61 @@
+// @ts-check
+
+import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const codeFencePrefixRe = /^(.*?)[`~]/;
+
+/** @typedef {readonly string[]} ReadonlyStringArray */
+
+/**
+ * Adds an error for the top or bottom of a code fence.
+ *
+ * @param {import("markdownlint").RuleOnError} onError Error-reporting callback.
+ * @param {ReadonlyStringArray} lines Lines of Markdown content.
+ * @param {number} lineNumber Line number.
+ * @param {boolean} top True iff top fence.
+ * @returns {void}
+ */
+function addError(onError, lines, lineNumber, top) {
+  const line = lines[lineNumber - 1];
+  const [ , prefix ] = line.match(codeFencePrefixRe) || [];
+  const fixInfo = (prefix === undefined) ?
+    undefined :
+    {
+      "lineNumber": lineNumber + (top ? 0 : 1),
+      "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
+    };
+  addErrorContext(
+    onError,
+    lineNumber,
+    line.trim(),
+    undefined,
+    undefined,
+    undefined,
+    fixInfo
+  );
+}
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD031", "blanks-around-fences" ],
+  "description": "Fenced code blocks should be surrounded by blank lines",
+  "tags": [ "code", "blank_lines" ],
+  "parser": "micromark",
+  "function": function MD031(params, onError) {
+    const listItems = params.config.list_items;
+    const includeListItems = (listItems === undefined) ? true : !!listItems;
+    const { lines } = params;
+    for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
+      if (includeListItems || !(getParentOfType(codeBlock, [ "listOrdered", "listUnordered" ]))) {
+        if (!isBlankLine(lines[codeBlock.startLine - 2])) {
+          addError(onError, lines, codeBlock.startLine, true);
+        }
+        if (!isBlankLine(lines[codeBlock.endLine]) && !isBlankLine(lines[codeBlock.endLine - 1])) {
+          addError(onError, lines, codeBlock.endLine, false);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,78 @@
+// @ts-check
+
+import { addErrorContext, isBlankLine } from "../helpers/helpers.cjs";
+import { filterByPredicate, getBlockQuotePrefixText, nonContentTokens } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+
+const isList = (/** @type {MicromarkToken} */ token) => (
+  (token.type === "listOrdered") || (token.type === "listUnordered")
+);
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD032", "blanks-around-lists" ],
+  "description": "Lists should be surrounded by blank lines",
+  "tags": [ "bullet", "ul", "ol", "blank_lines" ],
+  "parser": "micromark",
+  "function": function MD032(params, onError) {
+    const { lines, parsers } = params;
+    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
+
+    // For every top-level list...
+    const topLevelLists = filterByPredicate(
+      parsers.micromark.tokens,
+      isList,
+      (token) => (
+        (isList(token) || (token.type === "htmlFlow")) ? [] : token.children
+      )
+    );
+    for (const list of topLevelLists) {
+
+      // Look for a blank line above the list
+      const firstLineNumber = list.startLine;
+      if (!isBlankLine(lines[firstLineNumber - 2])) {
+        addErrorContext(
+          onError,
+          firstLineNumber,
+          lines[firstLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, firstLineNumber)
+          }
+        );
+      }
+
+      // Find the "visual" end of the list
+      const flattenedChildren = filterByPredicate(
+        list.children,
+        (token) => !nonContentTokens.has(token.type),
+        (token) => nonContentTokens.has(token.type) ? [] : token.children
+      );
+      let endLine = list.endLine;
+      if (flattenedChildren.length > 0) {
+        endLine = flattenedChildren[flattenedChildren.length - 1].endLine;
+      }
+
+      // Look for a blank line below the list
+      const lastLineNumber = 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/md033.mjs

@@ -0,0 +1,46 @@
+// @ts-check
+
+import { addError, nextLinesRe } from "../helpers/helpers.cjs";
+import { getHtmlTagInfo, getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("micromark-extension-gfm-table")} */
+
+// eslint-disable-next-line jsdoc/reject-any-type
+const toLowerCaseStringArray = (/** @type {any} */ arr) => Array.isArray(arr) ? arr.map((elm) => String(elm).toLowerCase()) : [];
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD033", "no-inline-html" ],
+  "description": "Inline HTML",
+  "tags": [ "html" ],
+  "parser": "micromark",
+  "function": function MD033(params, onError) {
+    const allowedElements = toLowerCaseStringArray(params.config.allowed_elements);
+    // If not defined, use allowedElements for backward compatibility
+    const tableAllowedElements = toLowerCaseStringArray(params.config.table_allowed_elements || params.config.allowed_elements);
+    for (const token of filterByTypesCached([ "htmlText" ], true)) {
+      const htmlTagInfo = getHtmlTagInfo(token);
+      if (htmlTagInfo && !htmlTagInfo.close) {
+        const elementName = htmlTagInfo?.name.toLowerCase();
+        const inTable = !!getParentOfType(token, [ "table" ]);
+        if (
+          (inTable || !allowedElements.includes(elementName)) &&
+          (!inTable || !tableAllowedElements.includes(elementName))
+        ) {
+          const range = [
+            token.startColumn,
+            token.text.replace(nextLinesRe, "").length
+          ];
+          addError(
+            onError,
+            token.startLine,
+            "Element: " + htmlTagInfo.name,
+            undefined,
+            range
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,92 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { filterByPredicate, getHtmlTagInfo, inHtmlFlow } from "../helpers/micromark-helpers.cjs";
+
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {import("micromark-extension-gfm-autolink-literal")} */
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD034", "no-bare-urls" ],
+  "description": "Bare URL used",
+  "tags": [ "links", "url" ],
+  "parser": "micromark",
+  "function": function MD034(params, onError) {
+    const literalAutolinks = (/** @type {MicromarkToken[]} */ tokens) => (
+      filterByPredicate(
+        tokens,
+        (token) => {
+          if ((token.type === "literalAutolink") && !inHtmlFlow(token)) {
+            // Detect and ignore https://github.com/micromark/micromark/issues/164
+            const siblings = token.parent?.children;
+            const index = siblings?.indexOf(token);
+            // @ts-ignore
+            const prev = siblings?.at(index - 1);
+            // @ts-ignore
+            const next = siblings?.at(index + 1);
+            return !(
+              prev &&
+              next &&
+              (prev.type === "data") &&
+              (next.type === "data") &&
+              prev.text.endsWith("<") &&
+              next.text.startsWith(">")
+            );
+          }
+          return false;
+        },
+        (token) => {
+          // Ignore content of inline HTML tags
+          const { children } = token;
+          const result = [];
+          for (let i = 0; i < children.length; i++) {
+            const current = children[i];
+            const openTagInfo = getHtmlTagInfo(current);
+            if (openTagInfo && !openTagInfo.close) {
+              let count = 1;
+              for (let j = i + 1; j < children.length; j++) {
+                const candidate = children[j];
+                const closeTagInfo = getHtmlTagInfo(candidate);
+                if (closeTagInfo && (openTagInfo.name === closeTagInfo.name)) {
+                  if (closeTagInfo.close) {
+                    count--;
+                    if (count === 0) {
+                      i = j;
+                      break;
+                    }
+                  } else {
+                    count++;
+                  }
+                }
+              }
+            } else {
+              result.push(current);
+            }
+          }
+          return result;
+        }
+      )
+    );
+    for (const token of literalAutolinks(params.parsers.micromark.tokens)) {
+      const range = [
+        token.startColumn,
+        token.endColumn - token.startColumn
+      ];
+      const fixInfo = {
+        "editColumn": range[0],
+        "deleteCount": range[1],
+        "insertText": `<${token.text}>`
+      };
+      addErrorContext(
+        onError,
+        token.startLine,
+        token.text,
+        undefined,
+        undefined,
+        range,
+        fixInfo
+      );
+    }
+  }
+};

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

@@ -0,0 +1,23 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD035", "hr-style" ],
+  "description": "Horizontal rule style",
+  "tags": [ "hr" ],
+  "parser": "micromark",
+  "function": function MD035(params, onError) {
+    let style = String(params.config.style || "consistent").trim();
+    const thematicBreaks = filterByTypesCached([ "thematicBreak" ]);
+    for (const token of thematicBreaks) {
+      const { startLine, text } = token;
+      if (style === "consistent") {
+        style = text;
+      }
+      addErrorDetailIf(onError, startLine, style, text);
+    }
+  }
+};

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

@@ -0,0 +1,55 @@
+// @ts-check
+
+import { addErrorContext, allPunctuation } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
+/** @typedef {import("markdownlint").MicromarkTokenType} MicromarkTokenType */
+
+/** @type {MicromarkTokenType[][]} */
+const emphasisTypes = [
+  [ "emphasis", "emphasisText" ],
+  [ "strong", "strongText" ]
+];
+
+const isParagraphChildMeaningful = (/** @type {MicromarkToken} */ token) => !(
+  (token.type === "htmlText") ||
+  ((token.type === "data") && (token.text.trim().length === 0))
+);
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD036", "no-emphasis-as-heading" ],
+  "description": "Emphasis used instead of a heading",
+  "tags": [ "headings", "emphasis" ],
+  "parser": "micromark",
+  "function": function MD036(params, onError) {
+    let punctuation = params.config.punctuation;
+    punctuation = String((punctuation === undefined) ? allPunctuation : punctuation);
+    const punctuationRe = new RegExp("[" + punctuation + "]$");
+    const paragraphTokens =
+      filterByTypesCached([ "paragraph" ], true)
+        .filter((token) =>
+          (token.parent?.type === "content") &&
+          (
+            !token.parent?.parent ||
+            ((token.parent?.parent?.type === "htmlFlow") && !token.parent?.parent?.parent)
+          ) &&
+          (token.children.filter(isParagraphChildMeaningful).length === 1)
+        );
+    for (const emphasisType of emphasisTypes) {
+      const textTokens = getDescendantsByType(paragraphTokens, emphasisType);
+      for (const textToken of textTokens) {
+        if (
+          (textToken.children.length === 1) &&
+          // eslint-disable-next-line unicorn/better-dom-traversing
+          (textToken.children[0].type === "data") &&
+          !punctuationRe.test(textToken.text)
+        ) {
+          addErrorContext(onError, textToken.startLine, textToken.text);
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,94 @@
+// @ts-check
+
+import { addError } from "../helpers/helpers.cjs";
+import { filterByPredicate, inHtmlFlow } from "../helpers/micromark-helpers.cjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD037", "no-space-in-emphasis" ],
+  "description": "Spaces inside emphasis markers",
+  "tags": [ "whitespace", "emphasis" ],
+  "parser": "micromark",
+  "function": function MD037(params, onError) {
+
+    // Initialize variables
+    const { lines, parsers } = params;
+    const emphasisTokensByMarker = new Map();
+    for (const marker of [ "_", "__", "___", "*", "**", "***" ]) {
+      emphasisTokensByMarker.set(marker, []);
+    }
+    const tokens = filterByPredicate(
+      parsers.micromark.tokens,
+      (token) => token.children.some((child) => child.type === "data")
+    );
+    for (const token of tokens) {
+
+      // Build lists of bare tokens for each emphasis marker type
+      for (const emphasisTokens of emphasisTokensByMarker.values()) {
+        emphasisTokens.length = 0;
+      }
+      for (const child of token.children) {
+        const { text, type } = child;
+        if ((type === "data") && (text.length <= 3)) {
+          const emphasisTokens = emphasisTokensByMarker.get(text);
+          if (emphasisTokens && !inHtmlFlow(child)) {
+            emphasisTokens.push(child);
+          }
+        }
+      }
+
+      // Process bare tokens for each emphasis marker type
+      for (const entry of emphasisTokensByMarker.entries()) {
+        const [ marker, emphasisTokens ] = entry;
+        for (let i = 0; i + 1 < emphasisTokens.length; i += 2) {
+
+          // Process start token of start/end pair
+          const startToken = emphasisTokens[i];
+          const startLine = lines[startToken.startLine - 1];
+          const startSlice = startLine.slice(startToken.endColumn - 1);
+          const startMatch = startSlice.match(/^\s+\S/);
+          if (startMatch) {
+            const [ startSpaceCharacter ] = startMatch;
+            const startContext = `${marker}${startSpaceCharacter}`;
+            const column = startToken.endColumn;
+            const count = startSpaceCharacter.length - 1;
+            addError(
+              onError,
+              startToken.startLine,
+              undefined,
+              startContext,
+              [ column, count ],
+              {
+                "editColumn": column,
+                "deleteCount": count
+              }
+            );
+          }
+
+          // Process end token of start/end pair
+          const endToken = emphasisTokens[i + 1];
+          const endLine = lines[endToken.startLine - 1];
+          const endSlice = endLine.slice(0, endToken.startColumn - 1);
+          const endMatch = endSlice.match(/\S\s+$/);
+          if (endMatch) {
+            const [ endSpaceCharacter ] = endMatch;
+            const endContext = `${endSpaceCharacter}${marker}`;
+            const column = endToken.startColumn - (endSpaceCharacter.length - 1);
+            const count = endSpaceCharacter.length - 1;
+            addError(
+              onError,
+              endToken.startLine,
+              undefined,
+              endContext,
+              [ column, count ],
+              {
+                "editColumn": column,
+                "deleteCount": count
+              }
+            );
+          }
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,73 @@
+// @ts-check
+
+import { addErrorContext } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD038", "no-space-in-code" ],
+  "description": "Spaces inside code span elements",
+  "tags": [ "whitespace", "code" ],
+  "parser": "micromark",
+  "function": function MD038(params, onError) {
+    const codeTexts = filterByTypesCached([ "codeText" ]);
+    for (const codeText of codeTexts) {
+      const datas = getDescendantsByType(codeText, [ "codeTextData" ]);
+      if (datas.length > 0) {
+        const paddings = getDescendantsByType(codeText, [ "codeTextPadding" ]);
+        // Check for extra space at start of code
+        const startPadding = paddings[0];
+        const startData = datas[0];
+        const startMatch = /^(\s+)(\S)/.exec(startData.text) || [ null, "", "" ];
+        const startBacktick = (startMatch[2] === "`");
+        const startCount = startMatch[1].length - ((startBacktick && !startPadding) ? 1 : 0);
+        const startSpaces = startCount > 0;
+        // Check for extra space at end of code
+        const endPadding = paddings[paddings.length - 1];
+        const endData = datas[datas.length - 1];
+        const endMatch = /(\S)(\s+)$/.exec(endData.text) || [ null, "", "" ];
+        const endBacktick = (endMatch[1] === "`");
+        const endCount = endMatch[2].length - ((endBacktick && !endPadding) ? 1 : 0);
+        const endSpaces = endCount > 0;
+        // Check if safe to remove 1-space padding
+        const removePadding = startSpaces && endSpaces && startPadding && endPadding && !startBacktick && !endBacktick;
+        const context = codeText.text;
+        // If extra space at start, report violation
+        if (startSpaces) {
+          const startColumn = (removePadding ? startPadding : startData).startColumn;
+          const length = startCount + (removePadding ? startPadding.text.length : 0);
+          addErrorContext(
+            onError,
+            startData.startLine,
+            context,
+            true,
+            false,
+            [ startColumn, length ],
+            {
+              "editColumn": startColumn,
+              "deleteCount": length
+            }
+          );
+        }
+        // If extra space at end, report violation
+        if (endSpaces) {
+          const endColumn = (removePadding ? endPadding : endData).endColumn;
+          const length = endCount + (removePadding ? endPadding.text.length : 0);
+          addErrorContext(
+            onError,
+            endData.endLine,
+            context,
+            false,
+            true,
+            [ endColumn - length, length ],
+            {
+              "editColumn": endColumn - length,
+              "deleteCount": length
+            }
+          );
+        }
+      }
+    }
+  }
+};