@alexlit/lint-kit 214.0.0 → 214.1.0

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

@@ -0,0 +1,32 @@
+// @ts-check
+
+import { addErrorDetailIf, frontMatterHasTitle } from "../helpers/helpers.cjs";
+import { getHeadingLevel } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD001", "heading-increment" ],
+  "description": "Heading levels should only increment by one level at a time",
+  "tags": [ "headings" ],
+  "parser": "micromark",
+  "function": function MD001(params, onError) {
+    const hasTitle = frontMatterHasTitle(
+      params.frontMatterLines,
+      params.config.front_matter_title
+    );
+    let prevLevel = hasTitle ? 1 : Number.MAX_SAFE_INTEGER;
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const level = getHeadingLevel(heading);
+      if (level > prevLevel) {
+        addErrorDetailIf(
+          onError,
+          heading.startLine,
+          `h${prevLevel + 1}`,
+          `h${level}`
+        );
+      }
+      prevLevel = level;
+    }
+  }
+};

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

@@ -0,0 +1,47 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getHeadingLevel, getHeadingStyle } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD003", "heading-style" ],
+  "description": "Heading style",
+  "tags": [ "headings" ],
+  "parser": "micromark",
+  "function": function MD003(params, onError) {
+    let style = String(params.config.style || "consistent");
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      const styleForToken = getHeadingStyle(heading);
+      if (style === "consistent") {
+        style = styleForToken;
+      }
+      if (styleForToken !== style) {
+        const h12 = getHeadingLevel(heading) <= 2;
+        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,
+            heading.startLine,
+            expected,
+            styleForToken
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,73 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getDescendantsByType, getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const markerToStyle = (/** @type {string} */ marker) => (marker === "-") ? "dash" : ((marker === "+") ? "plus" : "asterisk");
+const styleToMarker = (/** @type {string} */ style) => (style === "dash") ? "-" : ((style === "plus") ? "+" : "*");
+const differentItemStyle = (/** @type {string} */ style) => (style === "dash") ? "plus" : ((style === "plus") ? "asterisk" : "dash");
+const validStyles = new Set([
+  "asterisk",
+  "consistent",
+  "dash",
+  "plus",
+  "sublist"
+]);
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD004", "ul-style" ],
+  "description": "Unordered list style",
+  "tags": [ "bullet", "ul" ],
+  "parser": "micromark",
+  "function": function MD004(params, onError) {
+    const style = String(params.config.style || "consistent");
+    let expectedStyle = validStyles.has(style) ? style : "dash";
+    /** @type {("asterisk"|"dash"|"plus")[]} */
+    const nestingStyles = [];
+    for (const listUnordered of filterByTypesCached([ "listUnordered" ])) {
+      let nesting = 0;
+      if (style === "sublist") {
+        /** @type {import("markdownlint").MicromarkToken | null} */
+        let parent = listUnordered;
+        // @ts-ignore
+        while ((parent = getParentOfType(parent, [ "listOrdered", "listUnordered" ]))) {
+          nesting++;
+        }
+      }
+      const listItemMarkers = getDescendantsByType(listUnordered, [ "listItemPrefix", "listItemMarker" ]);
+      for (const listItemMarker of listItemMarkers) {
+        const itemStyle = markerToStyle(listItemMarker.text);
+        if (style === "sublist") {
+          // eslint-disable-next-line unicorn/no-computed-property-existence-check
+          if (!nestingStyles[nesting]) {
+            nestingStyles[nesting] =
+              (itemStyle === nestingStyles[nesting - 1]) ?
+                differentItemStyle(itemStyle) :
+                itemStyle;
+          }
+          expectedStyle = nestingStyles[nesting];
+        } else if (expectedStyle === "consistent") {
+          expectedStyle = itemStyle;
+        }
+        const column = listItemMarker.startColumn;
+        const length = listItemMarker.endColumn - listItemMarker.startColumn;
+        addErrorDetailIf(
+          onError,
+          listItemMarker.startLine,
+          expectedStyle,
+          itemStyle,
+          undefined,
+          undefined,
+          [ column, length ],
+          {
+            "editColumn": column,
+            "deleteCount": length,
+            "insertText": styleToMarker(expectedStyle)
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,69 @@
+// @ts-check
+
+import { addError, addErrorDetailIf } from "../helpers/helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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) {
+    for (const list of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
+      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,
+            undefined,
+            undefined,
+            range
+            // No fixInfo; MD007 handles this scenario better
+          );
+        } else {
+          const markerLength = listItemPrefix.text.trim().length;
+          const actualEnd = listItemPrefix.startColumn + markerLength - 1;
+          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.mjs

@@ -0,0 +1,84 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { getParentOfType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("micromark-util-types").TokenType[]} */
+const unorderedListTypes =
+  [ "blockQuotePrefix", "listItemPrefix", "listUnordered" ];
+/** @type {import("micromark-util-types").TokenType[]} */
+const unorderedParentTypes =
+  [ "blockQuote", "listOrdered", "listUnordered" ];
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "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);
+    const unorderedListNesting = new Map();
+    let lastBlockQuotePrefix = null;
+    const tokens = filterByTypesCached(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("markdownlint").MicromarkToken | null} */
+        let current = token;
+        while (
+          // @ts-ignore
+          (current = getParentOfType(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 {
+        // listItemPrefix
+        const nesting = unorderedListNesting.get(parent);
+        if (nesting !== undefined) {
+          // listItemPrefix for listUnordered
+          const baseIndent = (getParentOfType(token, [ "gfmFootnoteDefinition" ])) ? 4 : 0;
+          const expectedIndent =
+            baseIndent + (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.mjs

@@ -0,0 +1,95 @@
+// @ts-check
+
+import { addError } from "../helpers/helpers.cjs";
+import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD009", "no-trailing-spaces" ],
+  "description": "Trailing spaces",
+  "tags": [ "whitespace" ],
+  "parser": "micromark",
+  "function": function MD009(params, onError) {
+    const brSpaces = Number(params.config.br_spaces ?? 2);
+    const codeBlocks = params.config.code_blocks;
+    const includeCode = (codeBlocks !== undefined) && !!codeBlocks;
+    const listItemEmptyLines = !!params.config.list_item_empty_lines;
+    const strict = !!params.config.strict;
+    const codeBlockLineNumbers = new Set();
+    if (!includeCode) {
+      for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
+        addRangeToSet(codeBlockLineNumbers, codeBlock.startLine + 1, codeBlock.endLine - 1);
+      }
+      for (const codeBlock of filterByTypesCached([ "codeIndented" ])) {
+        addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+      }
+    }
+    const listItemLineNumbers = new Set();
+    if (listItemEmptyLines) {
+      for (const listBlock of filterByTypesCached([ "listOrdered", "listUnordered" ])) {
+        addRangeToSet(listItemLineNumbers, listBlock.startLine, listBlock.endLine);
+        let trailingIndent = true;
+        for (let i = listBlock.children.length - 1; i >= 0; i--) {
+          const child = listBlock.children[i];
+          switch (child.type) {
+            case "content":
+              trailingIndent = false;
+              break;
+            case "listItemIndent":
+              if (trailingIndent) {
+                listItemLineNumbers.delete(child.startLine);
+              }
+              break;
+            case "listItemPrefix":
+              trailingIndent = true;
+              break;
+            default:
+              break;
+          }
+        }
+      }
+    }
+    const paragraphLineNumbers = new Set();
+    const codeInlineLineNumbers = new Set();
+    if (strict) {
+      for (const paragraph of filterByTypesCached([ "paragraph" ])) {
+        addRangeToSet(paragraphLineNumbers, paragraph.startLine, paragraph.endLine - 1);
+      }
+      for (const codeText of filterByTypesCached([ "codeText" ])) {
+        addRangeToSet(codeInlineLineNumbers, codeText.startLine, codeText.endLine - 1);
+      }
+    }
+    const expected = (brSpaces < 2) ? 0 : brSpaces;
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
+      const lineNumber = lineIndex + 1;
+      const trailingSpaces = line.length - line.trimEnd().length;
+      if (
+        trailingSpaces &&
+        !codeBlockLineNumbers.has(lineNumber) &&
+        !listItemLineNumbers.has(lineNumber) &&
+        (
+          (expected !== trailingSpaces) ||
+          (strict &&
+            (!paragraphLineNumbers.has(lineNumber) ||
+             codeInlineLineNumbers.has(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.mjs

@@ -0,0 +1,78 @@
+// @ts-check
+
+import { addError, hasOverlap } from "../helpers/helpers.cjs";
+import { getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+const tabRe = /\t+/g;
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD010", "no-hard-tabs" ],
+  "description": "Hard tabs",
+  "tags": [ "whitespace", "hard_tab" ],
+  "parser": "micromark",
+  "function": function MD010(params, onError) {
+    const codeBlocks = params.config.code_blocks;
+    const includeCode = (codeBlocks === undefined) || !!codeBlocks;
+    const ignoreCodeLanguages = new Set(
+      (params.config.ignore_code_languages || [])
+        .map((/** @type {void} */ language) => String(language).toLowerCase())
+    );
+    const spacesPerTab = params.config.spaces_per_tab;
+    const spaceMultiplier = (spacesPerTab === undefined) ?
+      1 :
+      Math.max(0, Number(spacesPerTab));
+    /** @type {import("markdownlint").MicromarkTokenType[]} */
+    const exclusionTypes = [];
+    if (includeCode) {
+      if (ignoreCodeLanguages.size > 0) {
+        exclusionTypes.push("codeFenced");
+      }
+    } else {
+      exclusionTypes.push("codeFenced", "codeIndented", "codeText");
+    }
+    const codeTokens = filterByTypesCached(exclusionTypes).filter((token) => {
+      if ((token.type === "codeFenced") && (ignoreCodeLanguages.size > 0)) {
+        const fenceInfos = getDescendantsByType(token, [ "codeFencedFence", "codeFencedFenceInfo" ]);
+        return fenceInfos.every((fenceInfo) => ignoreCodeLanguages.has(fenceInfo.text.toLowerCase()));
+      }
+      return true;
+    });
+    const codeRanges = codeTokens.map((token) => {
+      const { type, startLine, startColumn, endLine, endColumn } = token;
+      const codeFenced = (type === "codeFenced");
+      return {
+        "startLine": startLine + (codeFenced ? 1 : 0),
+        "startColumn": codeFenced ? 0 : startColumn,
+        "endLine": endLine - (codeFenced ? 1 : 0),
+        "endColumn": codeFenced ? Number.MAX_SAFE_INTEGER : endColumn
+      };
+    });
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
+      let match = null;
+      while ((match = tabRe.exec(line)) !== null) {
+        const lineNumber = lineIndex + 1;
+        const column = match.index + 1;
+        const length = match[0].length;
+        /** @type {import("../helpers/helpers.cjs").FileRange} */
+        const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
+        if (!codeRanges.some((codeRange) => hasOverlap(codeRange, range))) {
+          addError(
+            onError,
+            lineNumber,
+            "Column: " + column,
+            undefined,
+            [ column, length ],
+            {
+              "editColumn": column,
+              "deleteCount": length,
+              "insertText": "".padEnd(length * spaceMultiplier)
+            }
+          );
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,59 @@
+// @ts-check
+
+import { re } from "re2js";
+import { addError, hasOverlap } from "../helpers/helpers.cjs";
+import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @typedef {typeof import("micromark-extension-math")} _ambient_ */
+
+const reversedLinkRe = re`(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\]`;
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD011", "no-reversed-links" ],
+  "description": "Reversed link syntax",
+  "tags": [ "links" ],
+  "parser": "micromark",
+  "function": function MD011(params, onError) {
+    const ignoreBlockLineNumbers = new Set();
+    for (const ignoreBlock of filterByTypesCached([ "codeFenced", "codeIndented", "htmlFlow", "mathFlow" ])) {
+      addRangeToSet(ignoreBlockLineNumbers, ignoreBlock.startLine, ignoreBlock.endLine);
+    }
+    const ignoreTexts = filterByTypesCached([ "codeText", "mathText" ]);
+    for (const [ lineIndex, line ] of params.lines.entries()) {
+      const lineNumber = lineIndex + 1;
+      if (!ignoreBlockLineNumbers.has(lineNumber)) {
+        for (const match of reversedLinkRe.matchAll(line)) {
+          const [ reversedLink, preChar, linkText, linkDestination ] = match;
+          const matchIndex = match.index ?? 0;
+          const matchLength = match[0].length;
+          if (
+            (line[matchIndex + matchLength] !== "(") &&
+            !linkText.endsWith("\\") &&
+            !linkDestination.endsWith("\\")
+          ) {
+            const column = matchIndex + preChar.length + 1;
+            const length = matchLength - preChar.length;
+            /** @type {import("../helpers/helpers.cjs").FileRange} */
+            const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
+            if (!ignoreTexts.some((ignoreText) => hasOverlap(ignoreText, range))) {
+              addError(
+                onError,
+                lineNumber,
+                reversedLink.slice(preChar.length),
+                undefined,
+                [ column, length ],
+                {
+                  "editColumn": column,
+                  "deleteCount": length,
+                  "insertText": `[${linkText}](${linkDestination})`
+                }
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+};

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

@@ -0,0 +1,40 @@
+// @ts-check
+
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { addRangeToSet } from "../helpers/micromark-helpers.cjs";
+import { filterByTypesCached } from "./cache.mjs";
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD012", "no-multiple-blanks" ],
+  "description": "Multiple consecutive blank lines",
+  "tags": [ "whitespace", "blank_lines" ],
+  "parser": "micromark",
+  "function": function MD012(params, onError) {
+    const maximum = Number(params.config.maximum ?? 1);
+    const { lines } = params;
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
+    let count = 0;
+    for (const [ lineIndex, line ] of lines.entries()) {
+      const inCode = codeBlockLineNumbers.has(lineIndex + 1);
+      count = (inCode || (line.trim().length > 0)) ? 0 : count + 1;
+      if (maximum < count) {
+        addErrorDetailIf(
+          onError,
+          lineIndex + 1,
+          maximum,
+          count,
+          undefined,
+          undefined,
+          undefined,
+          {
+            "deleteCount": -1
+          }
+        );
+      }
+    }
+  }
+};

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

@@ -0,0 +1,95 @@
+// @ts-check
+
+import { re } from "re2js";
+import { addErrorDetailIf } from "../helpers/helpers.cjs";
+import { filterByTypesCached, getReferenceLinkImageData } from "./cache.mjs";
+import { addRangeToSet, getDescendantsByType } from "../helpers/micromark-helpers.cjs";
+
+/** @typedef {typeof import("micromark-extension-gfm-autolink-literal")} _ambient_ */
+/** @typedef {typeof import("micromark-extension-gfm-table")} _ambient_2_ */
+
+// Regular expression for a line that is not wrappable
+const notWrappableRe = /^(?:[#>\s]*\s)?\S*$/;
+
+// Regular expression for the last run of non-whitespace
+const lastRunRe = re`\S*$`;
+
+/** @type {import("markdownlint").Rule} */
+export default {
+  "names": [ "MD013", "line-length" ],
+  "description": "Line length",
+  "tags": [ "line_length" ],
+  "parser": "micromark",
+  "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 codeBlocks = params.config.code_blocks;
+    const includeCodeBlocks = (codeBlocks === undefined) || !!codeBlocks;
+    const tables = params.config.tables;
+    const includeTables = (tables === undefined) || !!tables;
+    const headings = params.config.headings;
+    const includeHeadings = (headings === undefined) || !!headings;
+    const headingLineNumbers = new Set();
+    for (const heading of filterByTypesCached([ "atxHeading", "setextHeading" ])) {
+      addRangeToSet(headingLineNumbers, heading.startLine, heading.endLine);
+    }
+    const codeBlockLineNumbers = new Set();
+    for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
+      addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
+    }
+    const tableLineNumbers = new Set();
+    for (const table of filterByTypesCached([ "table" ])) {
+      addRangeToSet(tableLineNumbers, table.startLine, table.endLine);
+    }
+    const linkLineNumbers = new Set();
+    for (const link of filterByTypesCached([ "autolink", "image", "link", "literalAutolink" ])) {
+      addRangeToSet(linkLineNumbers, link.startLine, link.endLine);
+    }
+    const paragraphDataLineNumbers = new Set();
+    for (const paragraph of filterByTypesCached([ "paragraph" ])) {
+      for (const data of getDescendantsByType(paragraph, [ "data" ])) {
+        addRangeToSet(paragraphDataLineNumbers, data.startLine, data.endLine);
+      }
+    }
+    const linkOnlyLineNumbers = new Set();
+    for (const lineNumber of linkLineNumbers) {
+      if (!paragraphDataLineNumbers.has(lineNumber)) {
+        linkOnlyLineNumbers.add(lineNumber);
+      }
+    }
+    const definitionLineIndices = new Set(getReferenceLinkImageData().definitionLineIndices);
+    for (let lineIndex = 0; lineIndex < params.lines.length; lineIndex++) {
+      const line = params.lines[lineIndex];
+      const lineNumber = lineIndex + 1;
+      const isHeading = headingLineNumbers.has(lineNumber);
+      const inCode = codeBlockLineNumbers.has(lineNumber);
+      const inTable = tableLineNumbers.has(lineNumber);
+      const maxLength = inCode ? codeLineLength : (isHeading ? headingLineLength : lineLength);
+      // If not strict/stern, the last run of non-whitespace is allowed to go
+      // beyond the limit as long as it begins within the limit
+      const text = (strict || stern) ? line : lastRunRe.matcher(line).replaceFirst("#");
+      if ((maxLength > 0) &&
+          (includeCodeBlocks || !inCode) &&
+          (includeTables || !inTable) &&
+          (includeHeadings || !isHeading) &&
+          !definitionLineIndices.has(lineIndex) &&
+          (strict ||
+           (!(stern && notWrappableRe.test(line)) &&
+            !linkOnlyLineNumbers.has(lineNumber))) &&
+          (text.length > maxLength)) {
+        addErrorDetailIf(
+          onError,
+          lineNumber,
+          maxLength,
+          line.length,
+          undefined,
+          undefined,
+          [ maxLength + 1, line.length - maxLength ]
+        );
+      }
+    }
+  }
+};