@rse/ase 0.0.41 → 0.0.43

package/plugin/node_modules/markdownlint/lib/md014.mjs

@@ -1,47 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-const dollarCommandRe = /^(\s*)(\$\s+)/;
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD014", "commands-show-output" ],
-  "description": "Dollar signs used before commands without showing output",
-  "tags": [ "code" ],
-  "parser": "micromark",
-  "function": function MD014(params, onError) {
-    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
-      const codeFlowValues = codeBlock.children.filter((child) => child.type === "codeFlowValue");
-      const dollarMatches = codeFlowValues
-        .map((codeFlowValue) => ({
-          "result": codeFlowValue.text.match(dollarCommandRe),
-          "startColumn": codeFlowValue.startColumn,
-          "startLine": codeFlowValue.startLine,
-          "text": codeFlowValue.text
-        }))
-        .filter((dollarMatch) => dollarMatch.result);
-      if (dollarMatches.length === codeFlowValues.length) {
-        for (const dollarMatch of dollarMatches) {
-          // @ts-ignore
-          const column = dollarMatch.startColumn + dollarMatch.result[1].length;
-          // @ts-ignore
-          const length = dollarMatch.result[2].length;
-          addErrorContext(
-            onError,
-            dollarMatch.startLine,
-            dollarMatch.text,
-            undefined,
-            undefined,
-            [ column, length ],
-            {
-              "editColumn": column,
-              "deleteCount": length
-            }
-          );
-        }
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md018.mjs

@@ -1,43 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD018", "no-missing-space-atx" ],
-  "description": "No space after hash on atx style heading",
-  "tags": [ "headings", "atx", "spaces" ],
-  "parser": "micromark",
-  "function": function MD018(params, onError) {
-    const { lines } = params;
-    const ignoreBlockLineNumbers = new Set();
-    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow" ])) {
-      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
-    }
-    for (const [ lineIndex, line ] of lines.entries()) {
-      if (
-        !ignoreBlockLineNumbers.has(lineIndex + 1) &&
-        /^#+[^# \t]/.test(line) &&
-        !/#\s*$/.test(line) &&
-        !line.startsWith("#️⃣")
-      ) {
-        // @ts-ignore
-        const hashCount = /^#+/.exec(line)[0].length;
-        addErrorContext(
-          onError,
-          lineIndex + 1,
-          line.trim(),
-          undefined,
-          undefined,
-          [ 1, hashCount + 1 ],
-          {
-            "editColumn": hashCount + 1,
-            "insertText": " "
-          }
-        );
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md019-md021.mjs

@@ -1,77 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { getHeadingStyle } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/**
- * Validate heading sequence and whitespace length at start or end.
- *
- * @param {import("markdownlint").RuleOnError} onError Error-reporting callback.
- * @param {import("markdownlint").MicromarkToken} heading ATX heading token.
- * @param {number} delta Direction to scan.
- * @returns {void}
- */
-function validateHeadingSpaces(onError, heading, delta) {
-  const { children, startLine, text } = heading;
-  let index = (delta > 0) ? 0 : (children.length - 1);
-  while (
-    children[index] &&
-    (children[index].type !== "atxHeadingSequence")
-  ) {
-    index += delta;
-  }
-  const headingSequence = children[index];
-  const whitespace = children[index + delta];
-  if (
-    (headingSequence?.type === "atxHeadingSequence") &&
-    (whitespace?.type === "whitespace") &&
-    (whitespace.text.length > 1)
-  ) {
-    const column = whitespace.startColumn + 1;
-    const length = whitespace.endColumn - column;
-    addErrorContext(
-      onError,
-      startLine,
-      text.trim(),
-      delta > 0,
-      delta < 0,
-      [ column, length ],
-      {
-        "editColumn": column,
-        "deleteCount": length
-      }
-    );
-  }
-}
-
-/** @type {import("markdownlint").Rule[]} */
-export default [
-  {
-    "names": [ "MD019", "no-multiple-space-atx" ],
-    "description": "Multiple spaces after hash on atx style heading",
-    "tags": [ "headings", "atx", "spaces" ],
-    "parser": "micromark",
-    "function": function MD019(params, onError) {
-      const atxHeadings = filterByTypesCached([ "atxHeading" ])
-        .filter((heading) => getHeadingStyle(heading) === "atx");
-      for (const atxHeading of atxHeadings) {
-        validateHeadingSpaces(onError, atxHeading, 1);
-      }
-    }
-  },
-  {
-    "names": [ "MD021", "no-multiple-space-closed-atx" ],
-    "description": "Multiple spaces inside hashes on closed atx style heading",
-    "tags": [ "headings", "atx_closed", "spaces" ],
-    "parser": "micromark",
-    "function": function MD021(params, onError) {
-      const atxClosedHeadings = filterByTypesCached([ "atxHeading" ])
-        .filter((heading) => getHeadingStyle(heading) === "atx_closed");
-      for (const atxClosedHeading of atxClosedHeadings) {
-        validateHeadingSpaces(onError, atxClosedHeading, 1);
-        validateHeadingSpaces(onError, atxClosedHeading, -1);
-      }
-    }
-  }
-];

package/plugin/node_modules/markdownlint/lib/md020.mjs

@@ -1,68 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD020", "no-missing-space-closed-atx" ],
-  "description": "No space inside hashes on closed atx style heading",
-  "tags": [ "headings", "atx_closed", "spaces" ],
-  "parser": "micromark",
-  "function": function MD020(params, onError) {
-    const { lines } = params;
-    const ignoreBlockLineNumbers = new Set();
-    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow" ])) {
-      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
-    }
-    for (const [ lineIndex, line ] of lines.entries()) {
-      if (!ignoreBlockLineNumbers.has(lineIndex + 1)) {
-        const match =
-          /^(#+)([ \t]*)([^# \t\\]|[^# \t][^#]*?[^# \t\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
-        if (match) {
-          const [
-            ,
-            leftHash,
-            { "length": leftSpaceLength },
-            content,
-            { "length": rightSpaceLength },
-            rightEscape,
-            rightHash,
-            { "length": trailSpaceLength }
-          ] = match;
-          const leftHashLength = leftHash.length;
-          const rightHashLength = rightHash.length;
-          const left = !leftSpaceLength;
-          const right = !rightSpaceLength || !!rightEscape;
-          const rightEscapeReplacement = rightEscape ? `${rightEscape} ` : "";
-          if (left || right) {
-            const range = left ?
-              [
-                1,
-                leftHashLength + 1
-              ] :
-              [
-                line.length - trailSpaceLength - rightHashLength,
-                rightHashLength + 1
-              ];
-            addErrorContext(
-              onError,
-              lineIndex + 1,
-              line.trim(),
-              left,
-              right,
-              range,
-              {
-                "editColumn": 1,
-                "deleteCount": line.length,
-                "insertText":
-                  `${leftHash} ${content} ${rightEscapeReplacement}${rightHash}`
-              }
-            );
-          }
-        }
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md022.mjs

@@ -1,100 +0,0 @@
-// @ts-check
-
-import { addErrorDetailIf, isBlankLine } from "../helpers/helpers.cjs";
-import { getBlockQuotePrefixText, getHeadingLevel } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @typedef {import("markdownlint").MicromarkToken} MicromarkToken */
-
-const defaultLines = 1;
-
-// eslint-disable-next-line jsdoc/reject-any-type
-const getLinesFunction = (/** @type {any} */ linesParam) => {
-  if (Array.isArray(linesParam)) {
-    const linesArray = new Array(6).fill(defaultLines);
-    for (const [ index, value ] of [ ...linesParam.entries() ].slice(0, 6)) {
-      linesArray[index] = value;
-    }
-    return (/** @type {MicromarkToken} */ heading) => linesArray[getHeadingLevel(heading) - 1];
-  }
-  // Coerce linesParam to a number
-  const lines = (linesParam === undefined) ? defaultLines : Number(linesParam);
-  return () => lines;
-};
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD022", "blanks-around-headings" ],
-  "description": "Headings should be surrounded by blank lines",
-  "tags": [ "headings", "blank_lines" ],
-  "parser": "micromark",
-  "function": function MD022(params, onError) {
-    const getLinesAbove = getLinesFunction(params.config.lines_above);
-    const getLinesBelow = getLinesFunction(params.config.lines_below);
-    const { lines } = params;
-    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
-    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
-      const { startLine, endLine } = heading;
-      const line = lines[startLine - 1].trim();
-
-      // Check lines above
-      const linesAbove = getLinesAbove(heading);
-      if (linesAbove >= 0) {
-        let actualAbove = 0;
-        for (
-          let i = 0;
-          (i < linesAbove) && isBlankLine(lines[startLine - 2 - i]);
-          i++
-        ) {
-          actualAbove++;
-        }
-        addErrorDetailIf(
-          onError,
-          startLine,
-          linesAbove,
-          actualAbove,
-          "Above",
-          line,
-          undefined,
-          {
-            "insertText": getBlockQuotePrefixText(
-              blockQuotePrefixes,
-              startLine - 1,
-              linesAbove - actualAbove
-            )
-          }
-        );
-      }
-
-      // Check lines below
-      const linesBelow = getLinesBelow(heading);
-      if (linesBelow >= 0) {
-        let actualBelow = 0;
-        for (
-          let i = 0;
-          (i < linesBelow) && isBlankLine(lines[endLine + i]);
-          i++
-        ) {
-          actualBelow++;
-        }
-        addErrorDetailIf(
-          onError,
-          startLine,
-          linesBelow,
-          actualBelow,
-          "Below",
-          line,
-          undefined,
-          {
-            "lineNumber": endLine + 1,
-            "insertText": getBlockQuotePrefixText(
-              blockQuotePrefixes,
-              endLine + 1,
-              linesBelow - actualBelow
-            )
-          }
-        );
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md023.mjs

@@ -1,37 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD023", "heading-start-left" ],
-  "description": "Headings must start at the beginning of the line",
-  "tags": [ "headings", "spaces" ],
-  "parser": "micromark",
-  "function": function MD023(params, onError) {
-    const headings = filterByTypesCached([ "atxHeading", "linePrefix", "setextHeading" ]);
-    for (let i = 0; i < headings.length - 1; i++) {
-      if (
-        (headings[i].type === "linePrefix") &&
-        (headings[i + 1].type !== "linePrefix") &&
-        (headings[i].startLine === headings[i + 1].startLine)
-      ) {
-        const { endColumn, startColumn, startLine } = headings[i];
-        const length = endColumn - startColumn;
-        addErrorContext(
-          onError,
-          startLine,
-          params.lines[startLine - 1],
-          true,
-          false,
-          [ startColumn, length ],
-          {
-            "editColumn": startColumn,
-            "deleteCount": length
-          }
-        );
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md024.mjs

@@ -1,45 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { getHeadingLevel, getHeadingText } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD024", "no-duplicate-heading" ],
-  "description": "Multiple headings with the same content",
-  "tags": [ "headings" ],
-  "parser": "micromark",
-  "function": function MD024(params, onError) {
-    const siblingsOnly = !!params.config.siblings_only || false;
-    const knownContents = [ null, [] ];
-    let lastLevel = 1;
-    let knownContent = knownContents[lastLevel];
-    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
-      const headingText = getHeadingText(heading);
-      if (siblingsOnly) {
-        const newLevel = getHeadingLevel(heading);
-        while (lastLevel < newLevel) {
-          lastLevel++;
-          knownContents[lastLevel] = [];
-        }
-        while (lastLevel > newLevel) {
-          knownContents[lastLevel] = [];
-          lastLevel--;
-        }
-        knownContent = knownContents[newLevel];
-      }
-      // @ts-ignore
-      if (knownContent.includes(headingText)) {
-        addErrorContext(
-          onError,
-          heading.startLine,
-          headingText.trim()
-        );
-      } else {
-        // @ts-ignore
-        knownContent.push(headingText);
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md025.mjs

@@ -1,45 +0,0 @@
-// @ts-check
-
-import { addErrorContext, frontMatterHasTitle } from "../helpers/helpers.cjs";
-import { getHeadingLevel, getHeadingText, isDocfxTab, isHtmlFlowComment, nonContentTokens } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD025", "single-title", "single-h1" ],
-  "description": "Multiple top-level headings in the same document",
-  "tags": [ "headings" ],
-  "parser": "micromark",
-  "function": function MD025(params, onError) {
-    const level = Number(params.config.level || 1);
-    const { tokens } = params.parsers.micromark;
-    const matchingHeadings = filterByTypesCached([ "atxHeading", "setextHeading" ])
-      .filter((heading) => (level === getHeadingLevel(heading)) && !isDocfxTab(heading));
-    if (matchingHeadings.length > 0) {
-      const foundFrontMatterTitle =
-        frontMatterHasTitle(
-          params.frontMatterLines,
-          params.config.front_matter_title
-        );
-      // Front matter title counts as a top-level heading if present
-      let hasTopLevelHeading = foundFrontMatterTitle;
-      if (!hasTopLevelHeading) {
-        // Check if the first matching heading is a top-level heading
-        const previousTokens = tokens.slice(0, tokens.indexOf(matchingHeadings[0]));
-        hasTopLevelHeading = previousTokens.every(
-          (token) => nonContentTokens.has(token.type) || isHtmlFlowComment(token)
-        );
-      }
-      if (hasTopLevelHeading) {
-        // All other matching headings are violations
-        for (const heading of matchingHeadings.slice(foundFrontMatterTitle ? 0 : 1)) {
-          addErrorContext(
-            onError,
-            heading.startLine,
-            getHeadingText(heading)
-          );
-        }
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md026.mjs

@@ -1,46 +0,0 @@
-// @ts-check
-
-import { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe,
-  endOfLineHtmlEntityRe, escapeForRegExp } from "../helpers/helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD026", "no-trailing-punctuation" ],
-  "description": "Trailing punctuation in heading",
-  "tags": [ "headings" ],
-  "parser": "micromark",
-  "function": function MD026(params, onError) {
-    let punctuation = params.config.punctuation;
-    punctuation = String(
-      (punctuation === undefined) ? allPunctuationNoQuestion : punctuation
-    );
-    const trailingPunctuationRe =
-      new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$");
-    const headings = filterByTypesCached([ "atxHeadingText", "setextHeadingText" ]);
-    for (const heading of headings) {
-      const { endColumn, endLine, text } = heading;
-      const match = trailingPunctuationRe.exec(text);
-      if (
-        match &&
-        !endOfLineHtmlEntityRe.test(text) &&
-        !endOfLineGemojiCodeRe.test(text)
-      ) {
-        const fullMatch = match[0];
-        const length = fullMatch.length;
-        const column = endColumn - length;
-        addError(
-          onError,
-          endLine,
-          `Punctuation: '${fullMatch}'`,
-          undefined,
-          [ column, length ],
-          {
-            "editColumn": column,
-            "deleteCount": length
-          }
-        );
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md027.mjs

@@ -1,50 +0,0 @@
-// @ts-check
-
-import { addErrorContext } from "../helpers/helpers.cjs";
-import { getParentOfType } from "../helpers/micromark-helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-/** @type {import("../helpers/micromark-helpers.cjs").TokenType[]} */
-const listTypes = [ "listOrdered", "listUnordered" ];
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD027", "no-multiple-space-blockquote" ],
-  "description": "Multiple spaces after blockquote symbol",
-  "tags": [ "blockquote", "whitespace", "indentation" ],
-  "parser": "micromark",
-  "function": function MD027(params, onError) {
-    const listItems = params.config.list_items;
-    const includeListItems = (listItems === undefined) ? true : !!listItems;
-    const { tokens } = params.parsers.micromark;
-    for (const token of filterByTypesCached([ "linePrefix" ])) {
-      const parent = token.parent;
-      const codeIndented = parent?.type === "codeIndented";
-      const siblings = parent?.children || tokens;
-      if (
-        !codeIndented &&
-        (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix") &&
-        (includeListItems || (
-          !listTypes.includes(siblings[siblings.indexOf(token) + 1]?.type) &&
-          !getParentOfType(token, listTypes)
-        ))
-      ) {
-        const { startColumn, startLine, text } = token;
-        const { length } = text;
-        const line = params.lines[startLine - 1];
-        addErrorContext(
-          onError,
-          startLine,
-          line,
-          undefined,
-          undefined,
-          [ startColumn, length ],
-          {
-            "editColumn": startColumn,
-            "deleteCount": length
-          }
-        );
-      }
-    }
-  }
-};

package/plugin/node_modules/markdownlint/lib/md028.mjs

@@ -1,39 +0,0 @@
-// @ts-check
-
-import { addError } from "../helpers/helpers.cjs";
-import { filterByTypesCached } from "./cache.mjs";
-
-const ignoreTypes = new Set([ "lineEnding", "listItemIndent", "linePrefix" ]);
-
-/** @type {import("markdownlint").Rule} */
-export default {
-  "names": [ "MD028", "no-blanks-blockquote" ],
-  "description": "Blank line inside blockquote",
-  "tags": [ "blockquote", "whitespace" ],
-  "parser": "micromark",
-  "function": function MD028(params, onError) {
-    for (const token of filterByTypesCached([ "blockQuote" ])) {
-      const errorLineNumbers = [];
-      const siblings = token.parent?.children || params.parsers.micromark.tokens;
-      for (let i = siblings.indexOf(token) + 1; i < siblings.length; i++) {
-        const sibling = siblings[i];
-        const { startLine, type } = sibling;
-        if (type === "lineEndingBlank") {
-          // Possible blank between blockquotes
-          errorLineNumbers.push(startLine);
-        } else if (ignoreTypes.has(type)) {
-          // Ignore invisible formatting
-        } else if (type === "blockQuote") {
-          // Blockquote followed by blockquote
-          for (const lineNumber of errorLineNumbers) {
-            addError(onError, lineNumber);
-          }
-          break;
-        } else {
-          // Blockquote not followed by blockquote
-          break;
-        }
-      }
-    }
-  }
-};