markdownlint 0.35.0 → 0.36.0

package/demo/markdownlint-browser.js

@@ -1,4 +1,4 @@
-/*! markdownlint 0.35.0 https://github.com/DavidAnson/markdownlint @license MIT */
+/*! markdownlint 0.36.0 https://github.com/DavidAnson/markdownlint @license MIT */
 var markdownlint;
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
@@ -14,30 +14,25 @@ var markdownlint;
 
 
 
-const micromark = __webpack_require__(/*! ./micromark.cjs */ "../helpers/micromark.cjs");
+const micromark = __webpack_require__(/*! ./micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 
 const { newLineRe, nextLinesRe } = __webpack_require__(/*! ./shared.js */ "../helpers/shared.js");
 
 module.exports.newLineRe = newLineRe;
 module.exports.nextLinesRe = nextLinesRe;
 
+/** @typedef {import("../lib/markdownlint.js").RuleOnError} RuleOnError */
+/** @typedef {import("../lib/markdownlint.js").RuleOnErrorFixInfo} RuleOnErrorFixInfo */
+
 // Regular expression for matching common front matter (YAML and TOML)
 module.exports.frontMatterRe =
-  /((^---\s*$[\s\S]+?^---\s*)|(^\+\+\+\s*$[\s\S]+?^(\+\+\+|\.\.\.)\s*)|(^\{\s*$[\s\S]+?^\}\s*))(\r\n|\r|\n|$)/m;
+  /((^---[^\S\r\n\u2028\u2029]*$[\s\S]+?^---\s*)|(^\+\+\+[^\S\r\n\u2028\u2029]*$[\s\S]+?^(\+\+\+|\.\.\.)\s*)|(^\{[^\S\r\n\u2028\u2029]*$[\s\S]+?^\}\s*))(\r\n|\r|\n|$)/m;
 
 // Regular expression for matching the start of inline disable/enable comments
 const inlineCommentStartRe =
   /(<!--\s*markdownlint-(disable|enable|capture|restore|disable-file|enable-file|disable-line|disable-next-line|configure-file))(?:\s|-->)/gi;
 module.exports.inlineCommentStartRe = inlineCommentStartRe;
 
-// Regular expression for blockquote prefixes
-const blockquotePrefixRe = /^[>\s]*/;
-module.exports.blockquotePrefixRe = blockquotePrefixRe;
-
-// Regular expression for link reference definitions
-const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])\]:/;
-module.exports.linkReferenceDefinitionRe = linkReferenceDefinitionRe;
-
 // Regular expression for identifying an HTML entity at the end of a line
 module.exports.endOfLineHtmlEntityRe =
   /&(?:#\d+|#[xX][\da-fA-F]+|[a-zA-Z]{2,31}|blk\d{2}|emsp1[34]|frac\d{2}|sup\d|there4);$/;
@@ -235,99 +230,6 @@ module.exports.escapeForRegExp = function escapeForRegExp(str) {
   return str.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 };
 
-/**
- * Return the string representation of a fence markup character.
- *
- * @param {string} markup Fence string.
- * @returns {string} String representation.
- */
-module.exports.fencedCodeBlockStyleFor =
-  function fencedCodeBlockStyleFor(markup) {
-    switch (markup[0]) {
-      case "~":
-        return "tilde";
-      default:
-        return "backtick";
-    }
-  };
-
-/**
- * Return the string representation of a emphasis or strong markup character.
- *
- * @param {string} markup Emphasis or strong string.
- * @returns {"asterisk" | "underscore"} String representation.
- */
-module.exports.emphasisOrStrongStyleFor =
-  function emphasisOrStrongStyleFor(markup) {
-    switch (markup[0]) {
-      case "*":
-        return "asterisk";
-      default:
-        return "underscore";
-    }
-  };
-
-/**
- * @callback InlineCodeSpanCallback
- * @param {string} code Code content.
- * @param {number} lineIndex Line index (0-based).
- * @param {number} columnIndex Column index (0-based).
- * @param {number} ticks Count of backticks.
- * @returns {void}
- */
-
-/**
- * Calls the provided function for each inline code span's content.
- *
- * @param {string} input Markdown content.
- * @param {InlineCodeSpanCallback} handler Callback function taking (code,
- * lineIndex, columnIndex, ticks).
- * @returns {void}
- */
-function forEachInlineCodeSpan(input, handler) {
-  const backtickRe = /`+/g;
-  let match = null;
-  const backticksLengthAndIndex = [];
-  while ((match = backtickRe.exec(input)) !== null) {
-    backticksLengthAndIndex.push([ match[0].length, match.index ]);
-  }
-  const newLinesIndex = [];
-  while ((match = newLineRe.exec(input)) !== null) {
-    newLinesIndex.push(match.index);
-  }
-  let lineIndex = 0;
-  let lineStartIndex = 0;
-  let k = 0;
-  for (let i = 0; i < backticksLengthAndIndex.length - 1; i++) {
-    const [ startLength, startIndex ] = backticksLengthAndIndex[i];
-    if ((startIndex === 0) || (input[startIndex - 1] !== "\\")) {
-      for (let j = i + 1; j < backticksLengthAndIndex.length; j++) {
-        const [ endLength, endIndex ] = backticksLengthAndIndex[j];
-        if (startLength === endLength) {
-          for (; k < newLinesIndex.length; k++) {
-            const newLineIndex = newLinesIndex[k];
-            if (startIndex < newLineIndex) {
-              break;
-            }
-            lineIndex++;
-            lineStartIndex = newLineIndex + 1;
-          }
-          const columnIndex = startIndex - lineStartIndex + startLength;
-          handler(
-            input.slice(startIndex + startLength, endIndex),
-            lineIndex,
-            columnIndex,
-            startLength
-          );
-          i = j;
-          break;
-        }
-      }
-    }
-  }
-}
-module.exports.forEachInlineCodeSpan = forEachInlineCodeSpan;
-
 /**
  * Adds ellipsis to the left/right/middle of the specified text.
  *
@@ -353,12 +255,12 @@ module.exports.ellipsify = ellipsify;
 /**
  * Adds a generic error object via the onError callback.
  *
- * @param {Object} onError RuleOnError instance.
+ * @param {RuleOnError} onError RuleOnError instance.
  * @param {number} lineNumber Line number.
  * @param {string} [detail] Error details.
  * @param {string} [context] Error context.
  * @param {number[]} [range] Column and length of error.
- * @param {Object} [fixInfo] RuleOnErrorFixInfo instance.
+ * @param {RuleOnErrorFixInfo} [fixInfo] RuleOnErrorFixInfo instance.
  * @returns {void}
  */
 function addError(onError, lineNumber, detail, context, range, fixInfo) {
@@ -375,14 +277,14 @@ module.exports.addError = addError;
 /**
  * Adds an error object with details conditionally via the onError callback.
  *
- * @param {Object} onError RuleOnError instance.
+ * @param {RuleOnError} onError RuleOnError instance.
  * @param {number} lineNumber Line number.
  * @param {Object} expected Expected value.
  * @param {Object} actual Actual value.
  * @param {string} [detail] Error details.
  * @param {string} [context] Error context.
  * @param {number[]} [range] Column and length of error.
- * @param {Object} [fixInfo] RuleOnErrorFixInfo instance.
+ * @param {RuleOnErrorFixInfo} [fixInfo] RuleOnErrorFixInfo instance.
  * @returns {void}
  */
 function addErrorDetailIf(
@@ -403,13 +305,13 @@ module.exports.addErrorDetailIf = addErrorDetailIf;
 /**
  * Adds an error object with context via the onError callback.
  *
- * @param {Object} onError RuleOnError instance.
+ * @param {RuleOnError} onError RuleOnError instance.
  * @param {number} lineNumber Line number.
  * @param {string} context Error context.
  * @param {boolean} [start] True iff the start of the text is important.
  * @param {boolean} [end] True iff the end of the text is important.
  * @param {number[]} [range] Column and length of error.
- * @param {Object} [fixInfo] RuleOnErrorFixInfo instance.
+ * @param {RuleOnErrorFixInfo} [fixInfo] RuleOnErrorFixInfo instance.
  * @returns {void}
  */
 function addErrorContext(
@@ -420,50 +322,42 @@ function addErrorContext(
 module.exports.addErrorContext = addErrorContext;
 
 /**
- * Adds an error object with context for a construct missing a blank line.
+ * Defines a range within a file (start line/column to end line/column, subset of MicromarkToken).
  *
- * @param {Object} onError RuleOnError instance.
- * @param {string[]} lines Lines of Markdown content.
- * @param {number} lineIndex Line index of line.
- * @param {number} [lineNumber] Line number for override.
- * @returns {void}
+ * @typedef {Object} FileRange
+ * @property {number} startLine Start line (1-based).
+ * @property {number} startColumn Start column (1-based).
+ * @property {number} endLine End line (1-based).
+ * @property {number} endColumn End column (1-based).
  */
-function addErrorContextForLine(onError, lines, lineIndex, lineNumber) {
-  const line = lines[lineIndex];
-  // @ts-ignore
-  const quotePrefix = line.match(blockquotePrefixRe)[0].trimEnd();
-  addErrorContext(
-    onError,
-    lineIndex + 1,
-    line.trim(),
-    undefined,
-    undefined,
-    undefined,
-    {
-      lineNumber,
-      "insertText": `${quotePrefix}\n`
-    }
-  );
-}
-module.exports.addErrorContextForLine = addErrorContextForLine;
 
 /**
- * Determines whether the specified range is within another range.
+ * Returns whether line/column A is less than or equal to line/column B.
  *
- * @param {number[][]} ranges Array of ranges (line, index, length).
- * @param {number} lineIndex Line index to check.
- * @param {number} index Index to check.
- * @param {number} length Length to check.
- * @returns {boolean} True iff the specified range is within.
+ * @param {number} lineA Line A.
+ * @param {number} columnA Column A.
+ * @param {number} lineB Line B.
+ * @param {number} columnB Column B.
+ * @returns {boolean} True iff A is less than or equal to B.
  */
-const withinAnyRange = (ranges, lineIndex, index, length) => (
-  !ranges.every((span) => (
-    (lineIndex !== span[0]) ||
-    (index < span[1]) ||
-    (index + length > span[1] + span[2])
-  ))
+const positionLessThanOrEqual = (lineA, columnA, lineB, columnB) => (
+  (lineA < lineB) ||
+  ((lineA === lineB) && (columnA <= columnB))
 );
-module.exports.withinAnyRange = withinAnyRange;
+
+/**
+ * Returns whether two ranges (or MicromarkTokens) overlap anywhere.
+ *
+ * @param {FileRange|import("../lib/markdownlint.js").MicromarkToken} rangeA Range A.
+ * @param {FileRange|import("../lib/markdownlint.js").MicromarkToken} rangeB Range B.
+ * @returns {boolean} True iff the two ranges overlap.
+ */
+module.exports.hasOverlap = function hasOverlap(rangeA, rangeB) {
+  const lte = positionLessThanOrEqual(rangeA.startLine, rangeA.startColumn, rangeB.startLine, rangeB.startColumn);
+  const first = lte ? rangeA : rangeB;
+  const second = lte ? rangeB : rangeA;
+  return positionLessThanOrEqual(second.startLine, second.startColumn, first.endLine, first.endColumn);
+};
 
 // Determines if the front matter includes a title
 module.exports.frontMatterHasTitle =
@@ -482,16 +376,28 @@ module.exports.frontMatterHasTitle =
 /**
  * Returns an object with information about reference links and images.
  *
- * @param {import("../helpers/micromark.cjs").Token[]} tokens Micromark tokens.
+ * @param {import("../helpers/micromark-helpers.cjs").Token[]} tokens Micromark tokens.
  * @returns {Object} Reference link/image data.
  */
 function getReferenceLinkImageData(tokens) {
   const normalizeReference = (s) => s.toLowerCase().trim().replace(/\s+/g, " ");
+  const references = new Map();
+  const shortcuts = new Map();
+  const addReferenceToDictionary = (token, label, isShortcut) => {
+    const referenceDatum = [
+      token.startLine - 1,
+      token.startColumn - 1,
+      token.text.length
+    ];
+    const reference = normalizeReference(label);
+    const dictionary = isShortcut ? shortcuts : references;
+    const referenceData = dictionary.get(reference) || [];
+    referenceData.push(referenceDatum);
+    dictionary.set(reference, referenceData);
+  };
   const definitions = new Map();
   const definitionLineIndices = [];
   const duplicateDefinitions = [];
-  const references = new Map();
-  const shortcuts = new Map();
   const filteredTokens =
     micromark.filterByTypes(
       tokens,
@@ -501,7 +407,9 @@ function getReferenceLinkImageData(tokens) {
         // definitions and definitionLineIndices
         "definitionLabelString", "gfmFootnoteDefinitionLabelString",
         // references and shortcuts
-        "gfmFootnoteCall", "image", "link"
+        "gfmFootnoteCall", "image", "link",
+        // undefined link labels
+        "undefinedReferenceCollapsed", "undefinedReferenceFull", "undefinedReferenceShortcut"
       ]
     );
   for (const token of filteredTokens) {
@@ -524,15 +432,10 @@ function getReferenceLinkImageData(tokens) {
           if (definitions.has(reference)) {
             duplicateDefinitions.push([ reference, token.startLine - 1 ]);
           } else {
-            let destinationString = null;
             const parent =
-              micromark.getTokenParentOfType(token, [ "definition" ]);
-            if (parent) {
-              destinationString = micromark.getTokenTextByType(
-                micromark.filterByPredicate(parent.children),
-                "definitionDestinationString"
-              );
-            }
+              micromark.getParentOfType(token, [ "definition" ]);
+            const destinationString = parent &&
+              micromark.getDescendantsByType(parent, [ "definitionDestination", "definitionDestinationRaw", "definitionDestinationString" ])[0]?.text;
             definitions.set(
               reference,
               [ token.startLine - 1, destinationString ]
@@ -544,67 +447,38 @@ function getReferenceLinkImageData(tokens) {
       case "image":
       case "link":
         {
-          let isShortcut = false;
-          let isFullOrCollapsed = false;
-          let labelText = null;
-          let referenceStringText = null;
-          const shortcutCandidate =
-            micromark.matchAndGetTokensByType(token.children, [ "label" ]);
-          if (shortcutCandidate) {
-            labelText =
-              micromark.getTokenTextByType(
-                shortcutCandidate[0].children, "labelText"
-              );
-            isShortcut = (labelText !== null);
-          }
-          const fullAndCollapsedCandidate =
-            micromark.matchAndGetTokensByType(
-              token.children, [ "label", "reference" ]
+          // Identify if shortcut or full/collapsed
+          let isShortcut = (token.children.length === 1);
+          const isFullOrCollapsed = (token.children.length === 2) && !token.children.some((t) => t.type === "resource");
+          const [ labelText ] = micromark.getDescendantsByType(token, [ "label", "labelText" ]);
+          const [ referenceString ] = micromark.getDescendantsByType(token, [ "reference", "referenceString" ]);
+          let label = labelText?.text;
+          // Identify if footnote
+          if (!isShortcut && !isFullOrCollapsed) {
+            const [ footnoteCallMarker, footnoteCallString ] = token.children.filter(
+              (t) => [ "gfmFootnoteCallMarker", "gfmFootnoteCallString" ].includes(t.type)
             );
-          if (fullAndCollapsedCandidate) {
-            labelText =
-              micromark.getTokenTextByType(
-                fullAndCollapsedCandidate[0].children, "labelText"
-              );
-            referenceStringText =
-              micromark.getTokenTextByType(
-                fullAndCollapsedCandidate[1].children, "referenceString"
-              );
-            isFullOrCollapsed = (labelText !== null);
-          }
-          const footnote = micromark.matchAndGetTokensByType(
-            token.children,
-            [
-              "gfmFootnoteCallLabelMarker", "gfmFootnoteCallMarker",
-              "gfmFootnoteCallString", "gfmFootnoteCallLabelMarker"
-            ],
-            [ "gfmFootnoteCallMarker", "gfmFootnoteCallString" ]
-          );
-          if (footnote) {
-            const callMarkerText = footnote[0].text;
-            const callString = footnote[1].text;
-            labelText = `${callMarkerText}${callString}`;
-            isShortcut = true;
+            if (footnoteCallMarker && footnoteCallString) {
+              label = `${footnoteCallMarker.text}${footnoteCallString.text}`;
+              isShortcut = true;
+            }
           }
-          // Track shortcuts separately due to ambiguity in "text [text] text"
+          // Track link (handle shortcuts separately due to ambiguity in "text [text] text")
           if (isShortcut || isFullOrCollapsed) {
-            const referenceDatum = [
-              token.startLine - 1,
-              token.startColumn - 1,
-              token.text.length,
-              // @ts-ignore
-              labelText.length,
-              (referenceStringText || "").length
-            ];
-            const reference =
-              normalizeReference(referenceStringText || labelText);
-            const dictionary = isShortcut ? shortcuts : references;
-            const referenceData = dictionary.get(reference) || [];
-            referenceData.push(referenceDatum);
-            dictionary.set(reference, referenceData);
+            addReferenceToDictionary(token, referenceString?.text || label, isShortcut);
           }
         }
         break;
+      case "undefinedReferenceCollapsed":
+      case "undefinedReferenceFull":
+      case "undefinedReferenceShortcut":
+        {
+          const undefinedReference = micromark.getDescendantsByType(token, [ "undefinedReference" ])[0];
+          const label = undefinedReference.children.map((t) => t.text).join("");
+          const isShortcut = (token.type === "undefinedReferenceShortcut");
+          addReferenceToDictionary(token, label, isShortcut);
+        }
+        break;
     }
   }
   return {
@@ -657,120 +531,6 @@ function getPreferredLineEnding(input, os) {
 }
 module.exports.getPreferredLineEnding = getPreferredLineEnding;
 
-/**
- * Normalizes the fields of a RuleOnErrorFixInfo instance.
- *
- * @param {Object} fixInfo RuleOnErrorFixInfo instance.
- * @param {number} [lineNumber] Line number.
- * @returns {Object} Normalized RuleOnErrorFixInfo instance.
- */
-function normalizeFixInfo(fixInfo, lineNumber) {
-  return {
-    "lineNumber": fixInfo.lineNumber || lineNumber,
-    "editColumn": fixInfo.editColumn || 1,
-    "deleteCount": fixInfo.deleteCount || 0,
-    "insertText": fixInfo.insertText || ""
-  };
-}
-
-/**
- * Fixes the specified error on a line of Markdown content.
- *
- * @param {string} line Line of Markdown content.
- * @param {Object} fixInfo RuleOnErrorFixInfo instance.
- * @param {string} [lineEnding] Line ending to use.
- * @returns {string | null} Fixed content.
- */
-function applyFix(line, fixInfo, lineEnding) {
-  const { editColumn, deleteCount, insertText } = normalizeFixInfo(fixInfo);
-  const editIndex = editColumn - 1;
-  return (deleteCount === -1) ?
-    null :
-    line.slice(0, editIndex) +
-    insertText.replace(/\n/g, lineEnding || "\n") +
-    line.slice(editIndex + deleteCount);
-}
-module.exports.applyFix = applyFix;
-
-/**
- * Applies as many fixes as possible to Markdown content.
- *
- * @param {string} input Lines of Markdown content.
- * @param {Object[]} errors RuleOnErrorInfo instances.
- * @returns {string} Corrected content.
- */
-function applyFixes(input, errors) {
-  const lineEnding = getPreferredLineEnding(input, __webpack_require__(/*! node:os */ "?0176"));
-  const lines = input.split(newLineRe);
-  // Normalize fixInfo objects
-  let fixInfos = errors
-    .filter((error) => error.fixInfo)
-    .map((error) => normalizeFixInfo(error.fixInfo, error.lineNumber));
-  // Sort bottom-to-top, line-deletes last, right-to-left, long-to-short
-  fixInfos.sort((a, b) => {
-    const aDeletingLine = (a.deleteCount === -1);
-    const bDeletingLine = (b.deleteCount === -1);
-    return (
-      (b.lineNumber - a.lineNumber) ||
-      (aDeletingLine ? 1 : (bDeletingLine ? -1 : 0)) ||
-      (b.editColumn - a.editColumn) ||
-      (b.insertText.length - a.insertText.length)
-    );
-  });
-  // Remove duplicate entries (needed for following collapse step)
-  let lastFixInfo = {};
-  fixInfos = fixInfos.filter((fixInfo) => {
-    const unique = (
-      (fixInfo.lineNumber !== lastFixInfo.lineNumber) ||
-      (fixInfo.editColumn !== lastFixInfo.editColumn) ||
-      (fixInfo.deleteCount !== lastFixInfo.deleteCount) ||
-      (fixInfo.insertText !== lastFixInfo.insertText)
-    );
-    lastFixInfo = fixInfo;
-    return unique;
-  });
-  // Collapse insert/no-delete and no-insert/delete for same line/column
-  lastFixInfo = {
-    "lineNumber": -1
-  };
-  for (const fixInfo of fixInfos) {
-    if (
-      (fixInfo.lineNumber === lastFixInfo.lineNumber) &&
-      (fixInfo.editColumn === lastFixInfo.editColumn) &&
-      !fixInfo.insertText &&
-      (fixInfo.deleteCount > 0) &&
-      lastFixInfo.insertText &&
-      !lastFixInfo.deleteCount) {
-      fixInfo.insertText = lastFixInfo.insertText;
-      lastFixInfo.lineNumber = 0;
-    }
-    lastFixInfo = fixInfo;
-  }
-  fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
-  // Apply all (remaining/updated) fixes
-  let lastLineIndex = -1;
-  let lastEditIndex = -1;
-  for (const fixInfo of fixInfos) {
-    const { lineNumber, editColumn, deleteCount } = fixInfo;
-    const lineIndex = lineNumber - 1;
-    const editIndex = editColumn - 1;
-    if (
-      (lineIndex !== lastLineIndex) ||
-      (deleteCount === -1) ||
-      ((editIndex + deleteCount) <=
-        (lastEditIndex - ((deleteCount > 0) ? 0 : 1)))
-    ) {
-      // @ts-ignore
-      lines[lineIndex] = applyFix(lines[lineIndex], fixInfo, lineEnding);
-    }
-    lastLineIndex = lineIndex;
-    lastEditIndex = editIndex;
-  }
-  // Return corrected input
-  return lines.filter((line) => line !== null).join(lineEnding);
-}
-module.exports.applyFixes = applyFixes;
-
 /**
  * Expands a path with a tilde to an absolute path.
  *
@@ -784,26 +544,6 @@ function expandTildePath(file, os) {
 }
 module.exports.expandTildePath = expandTildePath;
 
-// Copied from markdownlint.js to avoid TypeScript compiler import() issue.
-/**
- * @typedef {Object} MarkdownItToken
- * @property {string[][]} attrs HTML attributes.
- * @property {boolean} block Block-level token.
- * @property {MarkdownItToken[]} children Child nodes.
- * @property {string} content Tag contents.
- * @property {boolean} hidden Ignore element.
- * @property {string} info Fence info.
- * @property {number} level Nesting level.
- * @property {number[]} map Beginning/ending line numbers.
- * @property {string} markup Markup text.
- * @property {Object} meta Arbitrary data.
- * @property {number} nesting Level change.
- * @property {string} tag HTML tag name.
- * @property {string} type Token type.
- * @property {number} lineNumber Line number (1-based).
- * @property {string} line Line content.
- */
-
 
 /***/ }),
 
@@ -818,6 +558,12 @@ module.exports.expandTildePath = expandTildePath;
 
 
 
+// Symbol for identifing the flat tokens array from micromark parse
+module.exports.flatTokensSymbol = Symbol("flat-tokens");
+
+// Symbol for identifying the htmlFlow token from micromark parse
+module.exports.htmlFlowSymbol = Symbol("html-flow");
+
 // Regular expression for matching common newline characters
 // See NEWLINES_RE in markdown-it/lib/rules_core/normalize.js
 module.exports.newLineRe = /\r\n?|\n/g;
@@ -868,16 +614,6 @@ module.exports = micromarkBrowser;
 
 /***/ }),
 
-/***/ "?0176":
-/*!*************************!*\
-  !*** node:os (ignored) ***!
-  \*************************/
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ }),
-
 /***/ "?d0ee":
 /*!*************************!*\
   !*** node:fs (ignored) ***!
@@ -937,10 +673,10 @@ module.exports = {
 
 /***/ }),
 
-/***/ "../helpers/micromark.cjs":
-/*!********************************!*\
-  !*** ../helpers/micromark.cjs ***!
-  \********************************/
+/***/ "../helpers/micromark-helpers.cjs":
+/*!****************************************!*\
+  !*** ../helpers/micromark-helpers.cjs ***!
+  \****************************************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -948,30 +684,19 @@ module.exports = {
 
 
 
-// @ts-ignore
-const {
-  directive, gfmAutolinkLiteral, gfmFootnote, gfmTable, math,
-  parse, postprocess, preprocess
-  // @ts-ignore
-} = __webpack_require__(/*! markdownlint-micromark */ "markdownlint-micromark");
-const { newLineRe } = __webpack_require__(/*! ./shared.js */ "../helpers/shared.js");
-
-const flatTokensSymbol = Symbol("flat-tokens");
-const reparseSymbol = Symbol("reparse");
+const { flatTokensSymbol, htmlFlowSymbol } = __webpack_require__(/*! ./shared.js */ "../helpers/shared.js");
 
-/** @typedef {import("markdownlint-micromark").Event} Event */
-/** @typedef {import("markdownlint-micromark").ParseOptions} ParseOptions */
 /** @typedef {import("markdownlint-micromark").TokenType} TokenType */
 /** @typedef {import("../lib/markdownlint.js").MicromarkToken} Token */
 
 /**
- * Determines if a Micromark token is within an htmlFlow.
+ * Determines if a Micromark token is within an htmlFlow type.
  *
  * @param {Token} token Micromark token.
- * @returns {boolean} True iff the token is within an htmlFlow.
+ * @returns {boolean} True iff the token is within an htmlFlow type.
  */
 function inHtmlFlow(token) {
-  return token[reparseSymbol];
+  return Boolean(token[htmlFlowSymbol]);
 }
 
 /**
@@ -1003,180 +728,6 @@ function isHtmlFlowComment(token) {
   return false;
 }
 
-/**
- * Parses a Markdown document and returns Micromark events.
- *
- * @param {string} markdown Markdown document.
- * @param {ParseOptions} [micromarkOptions] Options for micromark.
- * @param {boolean} [referencesDefined] Treat references as defined.
- * @returns {Event[]} Micromark events.
- */
-function getMicromarkEvents(
-  markdown,
-  micromarkOptions = {},
-  referencesDefined = true
-) {
-
-  // Customize options object to add useful extensions
-  micromarkOptions.extensions = micromarkOptions.extensions || [];
-  micromarkOptions.extensions.push(
-    directive(),
-    gfmAutolinkLiteral(),
-    gfmFootnote(),
-    gfmTable(),
-    math()
-  );
-
-  // Use micromark to parse document into Events
-  const encoding = undefined;
-  const eol = true;
-  const parseContext = parse(micromarkOptions);
-  if (referencesDefined) {
-    // Customize ParseContext to treat all references as defined
-    parseContext.defined.includes = (searchElement) => searchElement.length > 0;
-  }
-  const chunks = preprocess()(markdown, encoding, eol);
-  const events = postprocess(parseContext.document().write(chunks));
-  return events;
-}
-
-/**
- * Parses a Markdown document and returns (frozen) tokens.
- *
- * @param {string} markdown Markdown document.
- * @param {ParseOptions} micromarkOptions Options for micromark.
- * @param {boolean} referencesDefined Treat references as defined.
- * @param {number} lineDelta Offset to apply to start/end line.
- * @param {Token} [ancestor] Parent of top-most tokens.
- * @returns {Token[]} Micromark tokens (frozen).
- */
-function micromarkParseWithOffset(
-  markdown,
-  micromarkOptions,
-  referencesDefined,
-  lineDelta,
-  ancestor
-) {
-  // Use micromark to parse document into Events
-  const events = getMicromarkEvents(
-    markdown, micromarkOptions, referencesDefined
-  );
-
-  // Create Token objects
-  const document = [];
-  let flatTokens = [];
-  /** @type {Token} */
-  const root = {
-    "type": "data",
-    "startLine": -1,
-    "startColumn": -1,
-    "endLine": -1,
-    "endColumn": -1,
-    "text": "ROOT",
-    "children": document,
-    "parent": null
-  };
-  const history = [ root ];
-  let current = root;
-  // eslint-disable-next-line jsdoc/valid-types
-  /** @type ParseOptions | null */
-  let reparseOptions = null;
-  let lines = null;
-  let skipHtmlFlowChildren = false;
-  for (const event of events) {
-    const [ kind, token, context ] = event;
-    const { type, start, end } = token;
-    const { "column": startColumn, "line": startLine } = start;
-    const { "column": endColumn, "line": endLine } = end;
-    const text = context.sliceSerialize(token);
-    if ((kind === "enter") && !skipHtmlFlowChildren) {
-      const previous = current;
-      history.push(previous);
-      current = {
-        type,
-        "startLine": startLine + lineDelta,
-        startColumn,
-        "endLine": endLine + lineDelta,
-        endColumn,
-        text,
-        "children": [],
-        "parent": ((previous === root) ? (ancestor || null) : previous)
-      };
-      if (ancestor) {
-        Object.defineProperty(current, reparseSymbol, { "value": true });
-      }
-      previous.children.push(current);
-      flatTokens.push(current);
-      if ((current.type === "htmlFlow") && !isHtmlFlowComment(current)) {
-        skipHtmlFlowChildren = true;
-        if (!reparseOptions || !lines) {
-          reparseOptions = {
-            ...micromarkOptions,
-            "extensions": [
-              {
-                "disable": {
-                  "null": [ "codeIndented", "htmlFlow" ]
-                }
-              }
-            ]
-          };
-          lines = markdown.split(newLineRe);
-        }
-        const reparseMarkdown = lines
-          .slice(current.startLine - 1, current.endLine)
-          .join("\n");
-        const tokens = micromarkParseWithOffset(
-          reparseMarkdown,
-          reparseOptions,
-          referencesDefined,
-          current.startLine - 1,
-          current
-        );
-        current.children = tokens;
-        // Avoid stack overflow of Array.push(...spread)
-        // eslint-disable-next-line unicorn/prefer-spread
-        flatTokens = flatTokens.concat(tokens[flatTokensSymbol]);
-      }
-    } else if (kind === "exit") {
-      if (type === "htmlFlow") {
-        skipHtmlFlowChildren = false;
-      }
-      if (!skipHtmlFlowChildren) {
-        Object.freeze(current.children);
-        Object.freeze(current);
-        // @ts-ignore
-        current = history.pop();
-      }
-    }
-  }
-
-  // Return document
-  Object.defineProperty(document, flatTokensSymbol, { "value": flatTokens });
-  Object.freeze(document);
-  return document;
-}
-
-/**
- * Parses a Markdown document and returns (frozen) tokens.
- *
- * @param {string} markdown Markdown document.
- * @param {ParseOptions} [micromarkOptions] Options for micromark.
- * @param {boolean} [referencesDefined] Treat references as defined.
- * @returns {Token[]} Micromark tokens (frozen).
- */
-function micromarkParse(
-  markdown,
-  micromarkOptions = {},
-  referencesDefined = true
-) {
-  return micromarkParseWithOffset(
-    markdown,
-    micromarkOptions,
-    referencesDefined,
-    0
-  );
-}
-
 /**
  * Adds a range of numbers to a set.
  *
@@ -1255,8 +806,7 @@ function filterByPredicate(tokens, allowed, transformChildren) {
  * @returns {Token[]} Filtered tokens.
  */
 function filterByTypes(tokens, types, htmlFlow) {
-  const predicate = (token) =>
-    (htmlFlow || !inHtmlFlow(token)) && types.includes(token.type);
+  const predicate = (token) => types.includes(token.type) && (htmlFlow || !inHtmlFlow(token));
   const flatTokens = tokens[flatTokensSymbol];
   if (flatTokens) {
     return flatTokens.filter(predicate);
@@ -1264,46 +814,41 @@ function filterByTypes(tokens, types, htmlFlow) {
   return filterByPredicate(tokens, predicate);
 }
 
+/**
+ * Gets the blockquote prefix text (if any) for the specified line number.
+ *
+ * @param {Token[]} tokens Micromark tokens.
+ * @param {number} lineNumber Line number to examine.
+ * @param {number} [count] Number of times to repeat.
+ * @returns {string} Blockquote prefix text.
+ */
+function getBlockQuotePrefixText(tokens, lineNumber, count = 1) {
+  return filterByTypes(tokens, [ "blockQuotePrefix", "linePrefix" ])
+    .filter((prefix) => prefix.startLine === lineNumber)
+    .map((prefix) => prefix.text)
+    .join("")
+    .trimEnd()
+    // eslint-disable-next-line unicorn/prefer-spread
+    .concat("\n")
+    .repeat(count);
+};
+
 /**
  * Gets a list of nested Micromark token descendants by type path.
  *
  * @param {Token|Token[]} parent Micromark token parent or parents.
- * @param {TokenType[]} typePath Micromark token type path.
+ * @param {(TokenType|TokenType[])[]} typePath Micromark token type path.
  * @returns {Token[]} Micromark token descendants.
  */
 function getDescendantsByType(parent, typePath) {
   let tokens = Array.isArray(parent) ? parent : [ parent ];
   for (const type of typePath) {
-    tokens = tokens.flatMap((t) => t.children).filter((t) => t.type === type);
+    const predicate = (token) => Array.isArray(type) ? type.includes(token.type) : (type === token.type);
+    tokens = tokens.flatMap((t) => t.children.filter(predicate));
   }
   return tokens;
 }
 
-// eslint-disable-next-line jsdoc/valid-types
-/** @typedef {readonly string[]} ReadonlyStringArray */
-
-/**
- * Gets the line/column/length exclusions for a Micromark token.
- *
- * @param {ReadonlyStringArray} lines File/string lines.
- * @param {Token} token Micromark token.
- * @returns {number[][]} Exclusions (line number, start column, length).
- */
-function getExclusionsForToken(lines, token) {
-  const exclusions = [];
-  const { endColumn, endLine, startColumn, startLine } = token;
-  for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++) {
-    const start = (lineNumber === startLine) ? startColumn : 1;
-    const end = (lineNumber === endLine) ? endColumn : lines[lineNumber - 1].length;
-    exclusions.push([
-      lineNumber,
-      start,
-      end - start + 1
-    ]);
-  }
-  return exclusions;
-}
-
 /**
  * Gets the heading level of a Micromark heading tokan.
  *
@@ -1311,12 +856,12 @@ function getExclusionsForToken(lines, token) {
  * @returns {number} Heading level.
  */
 function getHeadingLevel(heading) {
-  const headingSequence = filterByTypes(
-    heading.children,
-    [ "atxHeadingSequence", "setextHeadingLineSequence" ]
-  );
   let level = 1;
-  const { text } = headingSequence[0];
+  const headingSequence = heading.children.find(
+    (child) => [ "atxHeadingSequence", "setextHeadingLine" ].includes(child.type)
+  );
+  // @ts-ignore
+  const { text } = headingSequence;
   if (text[0] === "#") {
     level = Math.min(text.length, 6);
   } else if (text[0] === "-") {
@@ -1335,9 +880,8 @@ function getHeadingStyle(heading) {
   if (heading.type === "setextHeading") {
     return "setext";
   }
-  const atxHeadingSequenceLength = filterByTypes(
-    heading.children,
-    [ "atxHeadingSequence" ]
+  const atxHeadingSequenceLength = heading.children.filter(
+    (child) => child.type === "atxHeadingSequence"
   ).length;
   if (atxHeadingSequenceLength === 1) {
     return "atx";
@@ -1352,10 +896,7 @@ function getHeadingStyle(heading) {
  * @returns {string} Heading text.
  */
 function getHeadingText(heading) {
-  const headingTexts = filterByTypes(
-    heading.children,
-    [ "atxHeadingText", "setextHeadingText" ]
-  );
+  const headingTexts = getDescendantsByType(heading, [ [ "atxHeadingText", "setextHeadingText" ] ]);
   return headingTexts[0]?.text.replace(/[\r\n]+/g, " ") || "";
 }
 
@@ -1396,7 +937,7 @@ function getHtmlTagInfo(token) {
  * @param {TokenType[]} types Types to allow.
  * @returns {Token | null} Parent token.
  */
-function getTokenParentOfType(token, types) {
+function getParentOfType(token, types) {
   /** @type {Token | null} */
   let current = token;
   while ((current = current.parent) && !types.includes(current.type)) {
@@ -1405,54 +946,6 @@ function getTokenParentOfType(token, types) {
   return current;
 }
 
-/**
- * Get the text of the first match from a list of Micromark tokens by type.
- *
- * @param {Token[]} tokens Micromark tokens.
- * @param {TokenType} type Type to match.
- * @returns {string | null} Text of token.
- */
-function getTokenTextByType(tokens, type) {
-  const filtered = tokens.filter((token) => token.type === type);
-  return (filtered.length > 0) ? filtered[0].text : null;
-}
-
-/**
- * Determines a list of Micromark tokens matches and returns a subset.
- *
- * @param {Token[]} tokens Micromark tokens.
- * @param {TokenType[]} matchTypes Types to match.
- * @param {TokenType[]} [resultTypes] Types to return.
- * @returns {Token[] | null} Matching tokens.
- */
-function matchAndGetTokensByType(tokens, matchTypes, resultTypes) {
-  if (tokens.length !== matchTypes.length) {
-    return null;
-  }
-  resultTypes = resultTypes || matchTypes;
-  const result = [];
-  // eslint-disable-next-line unicorn/no-for-loop
-  for (let i = 0; i < matchTypes.length; i++) {
-    if (tokens[i].type !== matchTypes[i]) {
-      return null;
-    } else if (resultTypes.includes(matchTypes[i])) {
-      result.push(tokens[i]);
-    }
-  }
-  return result;
-}
-
-/**
- * Returns the specified token iff it is of the desired type.
- *
- * @param {Token} token Micromark token candidate.
- * @param {TokenType} type Desired type.
- * @returns {Token | null} Token instance.
- */
-function tokenIfType(token, type) {
-  return (token && (token.type === type)) ? token : null;
-}
-
 /**
  * Set containing token types that do not contain content.
  *
@@ -1469,24 +962,343 @@ const nonContentTokens = new Set([
 ]);
 
 module.exports = {
-  "parse": micromarkParse,
   addRangeToSet,
   filterByPredicate,
   filterByTypes,
+  getBlockQuotePrefixText,
   getDescendantsByType,
-  getExclusionsForToken,
   getHeadingLevel,
   getHeadingStyle,
   getHeadingText,
   getHtmlTagInfo,
-  getMicromarkEvents,
-  getTokenParentOfType,
-  getTokenTextByType,
+  getParentOfType,
   inHtmlFlow,
   isHtmlFlowComment,
-  matchAndGetTokensByType,
-  nonContentTokens,
-  tokenIfType
+  nonContentTokens
+};
+
+
+/***/ }),
+
+/***/ "../helpers/micromark-parse.cjs":
+/*!**************************************!*\
+  !*** ../helpers/micromark-parse.cjs ***!
+  \**************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// @ts-check
+
+
+
+const micromark = __webpack_require__(/*! markdownlint-micromark */ "markdownlint-micromark");
+const { isHtmlFlowComment } = __webpack_require__(/*! ./micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
+const { flatTokensSymbol, htmlFlowSymbol, newLineRe } = __webpack_require__(/*! ./shared.js */ "../helpers/shared.js");
+
+/** @typedef {import("markdownlint-micromark").Construct} Construct */
+/** @typedef {import("markdownlint-micromark").Event} Event */
+/** @typedef {import("markdownlint-micromark").ParseOptions} MicromarkParseOptions */
+/** @typedef {import("markdownlint-micromark").State} State */
+/** @typedef {import("markdownlint-micromark").Token} Token */
+/** @typedef {import("markdownlint-micromark").Tokenizer} Tokenizer */
+/** @typedef {import("../lib/markdownlint.js").MicromarkToken} MicromarkToken */
+
+/**
+ * Parse options.
+ *
+ * @typedef {Object} ParseOptions
+ * @property {boolean} [freezeTokens] Whether to freeze output Tokens.
+ */
+
+/**
+ * Parses a Markdown document and returns Micromark events.
+ *
+ * @param {string} markdown Markdown document.
+ * @param {MicromarkParseOptions} [micromarkParseOptions] Options for micromark.
+ * @returns {Event[]} Micromark events.
+ */
+function getEvents(
+  markdown,
+  micromarkParseOptions = {}
+) {
+  // Customize extensions list to add useful extensions
+  const extensions = [
+    micromark.directive(),
+    micromark.gfmAutolinkLiteral(),
+    micromark.gfmFootnote(),
+    micromark.gfmTable(),
+    micromark.math(),
+    ...(micromarkParseOptions.extensions || [])
+  ];
+
+  // // Shim labelEnd to identify undefined link labels
+  /** @type {Event[][]} */
+  const artificialEventLists = [];
+  /** @type {Construct} */
+  const labelEnd =
+    // @ts-ignore
+    micromark.labelEnd;
+  const tokenizeOriginal = labelEnd.tokenize;
+
+  /** @type {Tokenizer} */
+  function tokenizeShim(effects, okOriginal, nokOriginal) {
+    // eslint-disable-next-line consistent-this, unicorn/no-this-assignment, no-invalid-this
+    const tokenizeContext = this;
+    const events = tokenizeContext.events;
+
+    /** @type {State} */
+    const nokShim = (code) => {
+      // Find start of label (image or link)
+      let indexStart = events.length;
+      while (--indexStart >= 0) {
+        const event = events[indexStart];
+        const [ kind, token ] = event;
+        if (kind === "enter") {
+          const { type } = token;
+          if ((type === "labelImage") || (type === "labelLink")) {
+            // Found it
+            break;
+          }
+        }
+      }
+
+      // If found...
+      if (indexStart >= 0) {
+        // Create artificial enter/exit events and replicate all data/lineEnding events within
+        const eventStart = events[indexStart];
+        const [ , eventStartToken ] = eventStart;
+        const eventEnd = events[events.length - 1];
+        const [ , eventEndToken ] = eventEnd;
+        /** @type {Token} */
+        const undefinedReferenceType = {
+          "type": "undefinedReferenceShortcut",
+          "start": eventStartToken.start,
+          "end": eventEndToken.end
+        };
+        /** @type {Token} */
+        const undefinedReference = {
+          "type": "undefinedReference",
+          "start": eventStartToken.start,
+          "end": eventEndToken.end
+        };
+        const eventsToReplicate = events
+          .slice(indexStart)
+          .filter((event) => {
+            const [ , eventToken ] = event;
+            const { type } = eventToken;
+            return (type === "data") || (type === "lineEnding");
+          });
+
+        // Determine the type of the undefined reference
+        const previousUndefinedEvent = (artificialEventLists.length > 0) && artificialEventLists[artificialEventLists.length - 1][0];
+        const previousUndefinedToken = previousUndefinedEvent && previousUndefinedEvent[1];
+        if (
+          previousUndefinedToken &&
+          (previousUndefinedToken.end.line === undefinedReferenceType.start.line) &&
+          (previousUndefinedToken.end.column === undefinedReferenceType.start.column)
+        ) {
+          // Previous undefined reference event is immediately before this one
+          if (eventsToReplicate.length === 0) {
+            // The pair represent a collapsed reference (ex: [...][])
+            previousUndefinedToken.type = "undefinedReferenceCollapsed";
+            previousUndefinedToken.end = eventEndToken.end;
+          } else {
+            // The pair represent a full reference (ex: [...][...])
+            undefinedReferenceType.type = "undefinedReferenceFull";
+            undefinedReferenceType.start = previousUndefinedToken.start;
+            artificialEventLists.pop();
+          }
+        }
+
+        // Create artificial event list and replicate content
+        const text = eventsToReplicate
+          .filter((event) => event[0] === "enter")
+          .map((event) => tokenizeContext.sliceSerialize(event[1]))
+          .join("")
+          .trim();
+        if ((text.length > 0) && !text.includes("]")) {
+          /** @type {Event[]} */
+          const artificialEvents = [];
+          artificialEvents.push(
+            [ "enter", undefinedReferenceType, tokenizeContext ],
+            [ "enter", undefinedReference, tokenizeContext ]
+          );
+          for (const event of eventsToReplicate) {
+            const [ kind, token ] = event;
+            // Copy token because the current object will get modified by the parser
+            artificialEvents.push([ kind, { ...token }, tokenizeContext ]);
+          }
+          artificialEvents.push(
+            [ "exit", undefinedReference, tokenizeContext ],
+            [ "exit", undefinedReferenceType, tokenizeContext ]
+          );
+          artificialEventLists.push(artificialEvents);
+        }
+      }
+
+      // Continue with original behavior
+      return nokOriginal(code);
+    };
+
+    // Shim nok handler of labelEnd's tokenize
+    return tokenizeOriginal.call(tokenizeContext, effects, okOriginal, nokShim);
+  }
+
+  try {
+    // Shim labelEnd behavior to detect undefined references
+    labelEnd.tokenize = tokenizeShim;
+
+    // Use micromark to parse document into Events
+    const encoding = undefined;
+    const eol = true;
+    const parseContext = micromark.parse({ ...micromarkParseOptions, extensions });
+    const chunks = micromark.preprocess()(markdown, encoding, eol);
+    const events = micromark.postprocess(parseContext.document().write(chunks));
+
+    // Append artificial events and return all events
+    // eslint-disable-next-line unicorn/prefer-spread
+    return events.concat(...artificialEventLists);
+  } finally {
+    // Restore shimmed labelEnd behavior
+    labelEnd.tokenize = tokenizeOriginal;
+  }
+}
+
+/**
+ * Parses a Markdown document and returns micromark tokens (internal).
+ *
+ * @param {string} markdown Markdown document.
+ * @param {ParseOptions} [parseOptions] Options.
+ * @param {MicromarkParseOptions} [micromarkParseOptions] Options for micromark.
+ * @param {number} [lineDelta] Offset for start/end line.
+ * @param {MicromarkToken} [ancestor] Parent of top-most tokens.
+ * @returns {MicromarkToken[]} Micromark tokens.
+ */
+function parseInternal(
+  markdown,
+  parseOptions = {},
+  micromarkParseOptions = {},
+  lineDelta = 0,
+  ancestor = undefined
+) {
+  // Get options
+  const freezeTokens = Boolean(parseOptions.freezeTokens);
+
+  // Use micromark to parse document into Events
+  const events = getEvents(markdown, micromarkParseOptions);
+
+  // Create Token objects
+  const document = [];
+  let flatTokens = [];
+  /** @type {MicromarkToken} */
+  const root = {
+    "type": "data",
+    "startLine": -1,
+    "startColumn": -1,
+    "endLine": -1,
+    "endColumn": -1,
+    "text": "ROOT",
+    "children": document,
+    "parent": null
+  };
+  const history = [ root ];
+  let current = root;
+  // eslint-disable-next-line jsdoc/valid-types
+  /** @type MicromarkParseOptions | null */
+  let reparseOptions = null;
+  let lines = null;
+  let skipHtmlFlowChildren = false;
+  for (const event of events) {
+    const [ kind, token, context ] = event;
+    const { type, start, end } = token;
+    const { "column": startColumn, "line": startLine } = start;
+    const { "column": endColumn, "line": endLine } = end;
+    const text = context.sliceSerialize(token);
+    if ((kind === "enter") && !skipHtmlFlowChildren) {
+      const previous = current;
+      history.push(previous);
+      current = {
+        type,
+        "startLine": startLine + lineDelta,
+        startColumn,
+        "endLine": endLine + lineDelta,
+        endColumn,
+        text,
+        "children": [],
+        "parent": ((previous === root) ? (ancestor || null) : previous)
+      };
+      if (ancestor) {
+        Object.defineProperty(current, htmlFlowSymbol, { "value": true });
+      }
+      previous.children.push(current);
+      flatTokens.push(current);
+      if ((current.type === "htmlFlow") && !isHtmlFlowComment(current)) {
+        skipHtmlFlowChildren = true;
+        if (!reparseOptions || !lines) {
+          reparseOptions = {
+            ...micromarkParseOptions,
+            "extensions": [
+              {
+                "disable": {
+                  "null": [ "codeIndented", "htmlFlow" ]
+                }
+              }
+            ]
+          };
+          lines = markdown.split(newLineRe);
+        }
+        const reparseMarkdown = lines
+          .slice(current.startLine - 1, current.endLine)
+          .join("\n");
+        const tokens = parseInternal(
+          reparseMarkdown,
+          parseOptions,
+          reparseOptions,
+          current.startLine - 1,
+          current
+        );
+        current.children = tokens;
+        // Avoid stack overflow of Array.push(...spread)
+        // eslint-disable-next-line unicorn/prefer-spread
+        flatTokens = flatTokens.concat(tokens[flatTokensSymbol]);
+      }
+    } else if (kind === "exit") {
+      if (type === "htmlFlow") {
+        skipHtmlFlowChildren = false;
+      }
+      if (!skipHtmlFlowChildren) {
+        if (freezeTokens) {
+          Object.freeze(current.children);
+          Object.freeze(current);
+        }
+        // @ts-ignore
+        current = history.pop();
+      }
+    }
+  }
+
+  // Return document
+  Object.defineProperty(document, flatTokensSymbol, { "value": flatTokens });
+  if (freezeTokens) {
+    Object.freeze(document);
+  }
+  return document;
+}
+
+/**
+ * Parses a Markdown document and returns micromark tokens.
+ *
+ * @param {string} markdown Markdown document.
+ * @param {ParseOptions} [parseOptions] Options.
+ * @returns {MicromarkToken[]} Micromark tokens.
+ */
+function parse(markdown, parseOptions) {
+  return parseInternal(markdown, parseOptions);
+}
+
+module.exports = {
+  getEvents,
+  parse
 };
 
 
@@ -1504,11 +1316,10 @@ module.exports = {
 
 
 const helpers = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByTypes } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { filterByTypes } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 
 /** @type {Map<string, object>} */
 const map = new Map();
-// eslint-disable-next-line no-undef-init
 let params = undefined;
 
 /**
@@ -1533,70 +1344,254 @@ function getCached(name, getValue) {
   if (map.has(name)) {
     return map.get(name);
   }
-  const value = getValue();
-  map.set(name, value);
-  return value;
+  const value = getValue();
+  map.set(name, value);
+  return value;
+}
+
+/**
+ * Filters a list of Micromark tokens by type and caches the result.
+ *
+ * @param {import("./markdownlint").MicromarkTokenType[]} types Types to allow.
+ * @param {boolean} [htmlFlow] Whether to include htmlFlow content.
+ * @returns {import("./markdownlint").MicromarkToken[]} Filtered tokens.
+ */
+function filterByTypesCached(types, htmlFlow) {
+  return getCached(
+    // eslint-disable-next-line prefer-rest-params
+    JSON.stringify(arguments),
+    () => filterByTypes(params.parsers.micromark.tokens, types, htmlFlow)
+  );
+}
+
+/**
+ * Gets a reference link and image data object.
+ *
+ * @returns {Object} Reference link and image data object.
+ */
+function getReferenceLinkImageData() {
+  return getCached(
+    getReferenceLinkImageData.name,
+    () => helpers.getReferenceLinkImageData(params.parsers.micromark.tokens)
+  );
+}
+
+module.exports = {
+  initialize,
+  filterByTypesCached,
+  getReferenceLinkImageData
+};
+
+
+/***/ }),
+
+/***/ "../lib/constants.js":
+/*!***************************!*\
+  !*** ../lib/constants.js ***!
+  \***************************/
+/***/ ((module) => {
+
+"use strict";
+// @ts-check
+
+
+
+module.exports.deprecatedRuleNames = [];
+module.exports.fixableRuleNames = [
+  "MD004", "MD005", "MD007", "MD009", "MD010", "MD011",
+  "MD012", "MD014", "MD018", "MD019", "MD020", "MD021",
+  "MD022", "MD023", "MD026", "MD027", "MD030", "MD031",
+  "MD032", "MD034", "MD037", "MD038", "MD039", "MD044",
+  "MD047", "MD049", "MD050", "MD051", "MD053", "MD054",
+  "MD058"
+];
+module.exports.homepage = "https://github.com/DavidAnson/markdownlint";
+module.exports.version = "0.36.0";
+
+
+/***/ }),
+
+/***/ "../lib/markdownit.cjs":
+/*!*****************************!*\
+  !*** ../lib/markdownit.cjs ***!
+  \*****************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+// @ts-check
+
+
+
+const { newLineRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+
+/**
+ * @callback InlineCodeSpanCallback
+ * @param {string} code Code content.
+ * @param {number} lineIndex Line index (0-based).
+ * @param {number} columnIndex Column index (0-based).
+ * @param {number} ticks Count of backticks.
+ * @returns {void}
+ */
+
+/**
+ * Calls the provided function for each inline code span's content.
+ *
+ * @param {string} input Markdown content.
+ * @param {InlineCodeSpanCallback} handler Callback function taking (code,
+ * lineIndex, columnIndex, ticks).
+ * @returns {void}
+ */
+function forEachInlineCodeSpan(input, handler) {
+  const backtickRe = /`+/g;
+  let match = null;
+  const backticksLengthAndIndex = [];
+  while ((match = backtickRe.exec(input)) !== null) {
+    backticksLengthAndIndex.push([ match[0].length, match.index ]);
+  }
+  const newLinesIndex = [];
+  while ((match = newLineRe.exec(input)) !== null) {
+    newLinesIndex.push(match.index);
+  }
+  let lineIndex = 0;
+  let lineStartIndex = 0;
+  let k = 0;
+  for (let i = 0; i < backticksLengthAndIndex.length - 1; i++) {
+    const [ startLength, startIndex ] = backticksLengthAndIndex[i];
+    if ((startIndex === 0) || (input[startIndex - 1] !== "\\")) {
+      for (let j = i + 1; j < backticksLengthAndIndex.length; j++) {
+        const [ endLength, endIndex ] = backticksLengthAndIndex[j];
+        if (startLength === endLength) {
+          for (; k < newLinesIndex.length; k++) {
+            const newLineIndex = newLinesIndex[k];
+            if (startIndex < newLineIndex) {
+              break;
+            }
+            lineIndex++;
+            lineStartIndex = newLineIndex + 1;
+          }
+          const columnIndex = startIndex - lineStartIndex + startLength;
+          handler(
+            input.slice(startIndex + startLength, endIndex),
+            lineIndex,
+            columnIndex,
+            startLength
+          );
+          i = j;
+          break;
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Freeze all freeze-able members of a token and its children.
+ *
+ * @param {import("./markdownlint").MarkdownItToken} token A markdown-it token.
+ * @returns {void}
+ */
+function freezeToken(token) {
+  if (token.attrs) {
+    for (const attr of token.attrs) {
+      Object.freeze(attr);
+    }
+    Object.freeze(token.attrs);
+  }
+  if (token.children) {
+    for (const child of token.children) {
+      freezeToken(child);
+    }
+    Object.freeze(token.children);
+  }
+  if (token.map) {
+    Object.freeze(token.map);
+  }
+  Object.freeze(token);
 }
 
 /**
- * Filters a list of Micromark tokens by type and caches the result.
+ * Annotate tokens with line/lineNumber and freeze them.
  *
- * @param {import("./markdownlint").MicromarkTokenType[]} types Types to allow.
- * @param {boolean} [htmlFlow] Whether to include htmlFlow content.
- * @returns {import("./markdownlint").MicromarkToken[]} Filtered tokens.
+ * @param {Object[]} tokens Array of markdown-it tokens.
+ * @param {string[]} lines Lines of Markdown content.
+ * @returns {void}
  */
-function filterByTypesCached(types, htmlFlow) {
-  return getCached(
-    types.join("|"),
-    () => filterByTypes(params.parsers.micromark.tokens, types, htmlFlow)
-  );
+function annotateAndFreezeTokens(tokens, lines) {
+  let trMap = null;
+  // eslint-disable-next-line jsdoc/valid-types
+  /** @type import("./markdownlint").MarkdownItToken[] */
+  // @ts-ignore
+  const markdownItTokens = tokens;
+  for (const token of markdownItTokens) {
+    // Provide missing maps for table content
+    if (token.type === "tr_open") {
+      trMap = token.map;
+    } else if (token.type === "tr_close") {
+      trMap = null;
+    }
+    if (!token.map && trMap) {
+      token.map = [ ...trMap ];
+    }
+    // Update token metadata
+    if (token.map) {
+      token.line = lines[token.map[0]];
+      token.lineNumber = token.map[0] + 1;
+      // Trim bottom of token to exclude whitespace lines
+      while (token.map[1] && !((lines[token.map[1] - 1] || "").trim())) {
+        token.map[1]--;
+      }
+    }
+    // Annotate children with lineNumber
+    if (token.children) {
+      const codeSpanExtraLines = [];
+      if (token.children.some((child) => child.type === "code_inline")) {
+        forEachInlineCodeSpan(token.content, (code) => {
+          codeSpanExtraLines.push(code.split(newLineRe).length - 1);
+        });
+      }
+      let lineNumber = token.lineNumber;
+      for (const child of token.children) {
+        child.lineNumber = lineNumber;
+        child.line = lines[lineNumber - 1];
+        if ((child.type === "softbreak") || (child.type === "hardbreak")) {
+          lineNumber++;
+        } else if (child.type === "code_inline") {
+          lineNumber += codeSpanExtraLines.shift();
+        }
+      }
+    }
+    freezeToken(token);
+  }
+  Object.freeze(tokens);
 }
 
 /**
- * Gets a reference link and image data object.
+ * Gets an array of markdown-it tokens for the input.
  *
- * @returns {Object} Reference link and image data object.
+ * @param {import("./markdownlint").Plugin[]} markdownItPlugins Additional plugins.
+ * @param {string} content Markdown content.
+ * @param {string[]} lines Lines of Markdown content.
+ * @returns {import("../lib/markdownlint").MarkdownItToken} Array of markdown-it tokens.
  */
-function getReferenceLinkImageData() {
-  return getCached(
-    getReferenceLinkImageData.name,
-    () => helpers.getReferenceLinkImageData(params.parsers.micromark.tokens)
-  );
-}
+function getMarkdownItTokens(markdownItPlugins, content, lines) {
+  const markdownit = __webpack_require__(/*! markdown-it */ "markdown-it");
+  const md = markdownit({ "html": true });
+  for (const plugin of markdownItPlugins) {
+    // @ts-ignore
+    md.use(...plugin);
+  }
+  const tokens = md.parse(content, {});
+  annotateAndFreezeTokens(tokens, lines);
+  // @ts-ignore
+  return tokens;
+};
 
 module.exports = {
-  initialize,
-  filterByTypesCached,
-  getReferenceLinkImageData
+  forEachInlineCodeSpan,
+  getMarkdownItTokens
 };
 
 
-/***/ }),
-
-/***/ "../lib/constants.js":
-/*!***************************!*\
-  !*** ../lib/constants.js ***!
-  \***************************/
-/***/ ((module) => {
-
-"use strict";
-// @ts-check
-
-
-
-module.exports.deprecatedRuleNames = [];
-module.exports.fixableRuleNames = [
-  "MD004", "MD005", "MD007", "MD009", "MD010", "MD011",
-  "MD012", "MD014", "MD018", "MD019", "MD020", "MD021",
-  "MD022", "MD023", "MD026", "MD027", "MD030", "MD031",
-  "MD032", "MD034", "MD037", "MD038", "MD039", "MD044",
-  "MD047", "MD049", "MD050", "MD051", "MD053", "MD054",
-  "MD058"
-];
-module.exports.homepage = "https://github.com/DavidAnson/markdownlint";
-module.exports.version = "0.35.0";
-
-
 /***/ }),
 
 /***/ "../lib/markdownlint.js":
@@ -1612,8 +1607,8 @@ module.exports.version = "0.35.0";
 
 const path = __webpack_require__(/*! node:path */ "?9a52");
 const { promisify } = __webpack_require__(/*! node:util */ "?39e5");
-const micromark = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
-// const { deprecatedRuleNames } = require("./constants");
+const micromark = __webpack_require__(/*! ../helpers/micromark-parse.cjs */ "../helpers/micromark-parse.cjs");
+const { version } = __webpack_require__(/*! ./constants */ "../lib/constants.js");
 const rules = __webpack_require__(/*! ./rules */ "../lib/rules.js");
 const helpers = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 const cache = __webpack_require__(/*! ./cache */ "../lib/cache.js");
@@ -1666,7 +1661,7 @@ function validateRuleList(ruleList, synchronous) {
       !result &&
       (rule.parser !== undefined) &&
       (rule.parser !== "markdownit") &&
-      !((customIndex < 0) && (rule.parser === "micromark")) &&
+      (rule.parser !== "micromark") &&
       (rule.parser !== "none")
     ) {
       result = newError("parser", rule.parser);
@@ -1805,87 +1800,6 @@ function removeFrontMatter(content, frontMatter) {
   };
 }
 
-/**
- * Freeze all freeze-able members of a token and its children.
- *
- * @param {MarkdownItToken} token A markdown-it token.
- * @returns {void}
- */
-function freezeToken(token) {
-  if (token.attrs) {
-    for (const attr of token.attrs) {
-      Object.freeze(attr);
-    }
-    Object.freeze(token.attrs);
-  }
-  if (token.children) {
-    for (const child of token.children) {
-      freezeToken(child);
-    }
-    Object.freeze(token.children);
-  }
-  if (token.map) {
-    Object.freeze(token.map);
-  }
-  Object.freeze(token);
-}
-
-/**
- * Annotate tokens with line/lineNumber and freeze them.
- *
- * @param {import("markdown-it").Token[]} tokens Array of markdown-it tokens.
- * @param {string[]} lines Lines of Markdown content.
- * @returns {void}
- */
-function annotateAndFreezeTokens(tokens, lines) {
-  let trMap = null;
-  // eslint-disable-next-line jsdoc/valid-types
-  /** @type MarkdownItToken[] */
-  // @ts-ignore
-  const markdownItTokens = tokens;
-  for (const token of markdownItTokens) {
-    // Provide missing maps for table content
-    if (token.type === "tr_open") {
-      trMap = token.map;
-    } else if (token.type === "tr_close") {
-      trMap = null;
-    }
-    if (!token.map && trMap) {
-      token.map = [ ...trMap ];
-    }
-    // Update token metadata
-    if (token.map) {
-      token.line = lines[token.map[0]];
-      token.lineNumber = token.map[0] + 1;
-      // Trim bottom of token to exclude whitespace lines
-      while (token.map[1] && !((lines[token.map[1] - 1] || "").trim())) {
-        token.map[1]--;
-      }
-    }
-    // Annotate children with lineNumber
-    if (token.children) {
-      const codeSpanExtraLines = [];
-      if (token.children.some((child) => child.type === "code_inline")) {
-        helpers.forEachInlineCodeSpan(token.content, (code) => {
-          codeSpanExtraLines.push(code.split(helpers.newLineRe).length - 1);
-        });
-      }
-      let lineNumber = token.lineNumber;
-      for (const child of token.children) {
-        child.lineNumber = lineNumber;
-        child.line = lines[lineNumber - 1];
-        if ((child.type === "softbreak") || (child.type === "hardbreak")) {
-          lineNumber++;
-        } else if (child.type === "code_inline") {
-          lineNumber += codeSpanExtraLines.shift();
-        }
-      }
-    }
-    freezeToken(token);
-  }
-  Object.freeze(tokens);
-}
-
 /**
  * Map rule names/tags to canonical rule name.
  *
@@ -2141,7 +2055,7 @@ function getEnabledRulesPerLineNumber(
  * names.
  * @param {string} name Identifier for the content.
  * @param {string} content Markdown content.
- * @param {GetMarkdownIt} getMarkdownIt Getter for instance of markdown-it.
+ * @param {Plugin[]} markdownItPlugins Additional plugins.
  * @param {Configuration} config Configuration object.
  * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {RegExp | null} frontMatter Regular expression for front matter.
@@ -2156,7 +2070,7 @@ function lintContent(
   aliasToRuleNames,
   name,
   content,
-  getMarkdownIt,
+  markdownItPlugins,
   config,
   configParsers,
   frontMatter,
@@ -2184,14 +2098,20 @@ function lintContent(
   const needMarkdownItTokens = enabledRuleList.some(
     (rule) => (rule.parser === "markdownit") || (rule.parser === undefined)
   );
+  const customRulesPresent = (ruleList.length !== rules.length);
   // Parse content into parser tokens
-  const markdownitTokens = needMarkdownItTokens ? getMarkdownIt().parse(content, {}) : [];
-  const micromarkTokens = micromark.parse(content);
+  const micromarkTokens = micromark.parse(
+    content,
+    { "freezeTokens": customRulesPresent }
+  );
   // Hide the content of HTML comments from rules
+  const preClearedContent = content;
   content = helpers.clearHtmlCommentText(content);
-  // Parse content into lines and update markdown-it tokens
+  // Parse content into lines and get markdown-it tokens
   const lines = content.split(helpers.newLineRe);
-  annotateAndFreezeTokens(markdownitTokens, lines);
+  const markdownitTokens = needMarkdownItTokens ?
+    (__webpack_require__(/*! ./markdownit.cjs */ "../lib/markdownit.cjs").getMarkdownItTokens)(markdownItPlugins, preClearedContent, lines) :
+    [];
   // Create (frozen) parameters for rules
   /** @type {MarkdownParsers} */
   // @ts-ignore
@@ -2212,6 +2132,7 @@ function lintContent(
   const parsersNone = Object.freeze({});
   const paramsBase = {
     name,
+    version,
     "lines": Object.freeze(lines),
     "frontMatterLines": Object.freeze(frontMatterLines)
   };
@@ -2444,7 +2365,7 @@ function lintContent(
  * @param {Object.<string, string[]>} aliasToRuleNames Map of alias to rule
  * names.
  * @param {string} file Path of file to lint.
- * @param {GetMarkdownIt} getMarkdownIt Getter for instance of markdown-it.
+ * @param {Plugin[]} markdownItPlugins Additional plugins.
  * @param {Configuration} config Configuration object.
  * @param {ConfigurationParser[] | null} configParsers Configuration parsers.
  * @param {RegExp | null} frontMatter Regular expression for front matter.
@@ -2460,7 +2381,7 @@ function lintFile(
   ruleList,
   aliasToRuleNames,
   file,
-  getMarkdownIt,
+  markdownItPlugins,
   config,
   configParsers,
   frontMatter,
@@ -2480,7 +2401,7 @@ function lintFile(
       aliasToRuleNames,
       file,
       content,
-      getMarkdownIt,
+      markdownItPlugins,
       config,
       configParsers,
       frontMatter,
@@ -2540,21 +2461,14 @@ function lintInput(options, synchronous, callback) {
   const config = options.config || { "default": true };
   const configParsers = options.configParsers || null;
   const frontMatter = (options.frontMatter === undefined) ?
-    helpers.frontMatterRe : options.frontMatter;
+    helpers.frontMatterRe :
+    options.frontMatter;
   const handleRuleFailures = !!options.handleRuleFailures;
   const noInlineConfig = !!options.noInlineConfig;
   const resultVersion = (options.resultVersion === undefined) ?
-    3 : options.resultVersion;
-  const getMarkdownIt = () => {
-    const markdownit = __webpack_require__(/*! markdown-it */ "markdown-it");
-    const md = markdownit({ "html": true });
-    const markdownItPlugins = options.markdownItPlugins || [];
-    for (const plugin of markdownItPlugins) {
-      // @ts-ignore
-      md.use(...plugin);
-    }
-    return md;
-  };
+    3 :
+    options.resultVersion;
+  const markdownItPlugins = options.markdownItPlugins || [];
   const fs = options.fs || __webpack_require__(/*! node:fs */ "?d0ee");
   const aliasToRuleNames = mapAliasToRuleNames(ruleList);
   const results = newResults(ruleList);
@@ -2586,7 +2500,7 @@ function lintInput(options, synchronous, callback) {
         ruleList,
         aliasToRuleNames,
         currentItem,
-        getMarkdownIt,
+        markdownItPlugins,
         config,
         configParsers,
         frontMatter,
@@ -2605,7 +2519,7 @@ function lintInput(options, synchronous, callback) {
         aliasToRuleNames,
         currentItem,
         strings[currentItem] || "",
-        getMarkdownIt,
+        markdownItPlugins,
         config,
         configParsers,
         frontMatter,
@@ -2889,12 +2803,125 @@ function readConfigSync(file, parsers, fs) {
       helpers.expandTildePath(configExtends, os),
       fs
     );
-    return {
-      ...readConfigSync(resolvedExtends, parsers, fs),
-      ...config
-    };
+    return {
+      ...readConfigSync(resolvedExtends, parsers, fs),
+      ...config
+    };
+  }
+  return config;
+}
+
+/**
+ * Normalizes the fields of a RuleOnErrorFixInfo instance.
+ *
+ * @param {RuleOnErrorFixInfo} fixInfo RuleOnErrorFixInfo instance.
+ * @param {number} [lineNumber] Line number.
+ * @returns {RuleOnErrorFixInfoNormalized} Normalized RuleOnErrorFixInfo instance.
+ */
+function normalizeFixInfo(fixInfo, lineNumber = 0) {
+  return {
+    "lineNumber": fixInfo.lineNumber || lineNumber,
+    "editColumn": fixInfo.editColumn || 1,
+    "deleteCount": fixInfo.deleteCount || 0,
+    "insertText": fixInfo.insertText || ""
+  };
+}
+
+/**
+ * Applies the specified fix to a Markdown content line.
+ *
+ * @param {string} line Line of Markdown content.
+ * @param {RuleOnErrorFixInfo} fixInfo RuleOnErrorFixInfo instance.
+ * @param {string} [lineEnding] Line ending to use.
+ * @returns {string | null} Fixed content or null if deleted.
+ */
+function applyFix(line, fixInfo, lineEnding = "\n") {
+  const { editColumn, deleteCount, insertText } = normalizeFixInfo(fixInfo);
+  const editIndex = editColumn - 1;
+  return (deleteCount === -1) ?
+    null :
+    line.slice(0, editIndex) + insertText.replace(/\n/g, lineEnding) + line.slice(editIndex + deleteCount);
+}
+
+/**
+ * Applies as many of the specified fixes as possible to Markdown content.
+ *
+ * @param {string} input Lines of Markdown content.
+ * @param {RuleOnErrorInfo[]} errors RuleOnErrorInfo instances.
+ * @returns {string} Fixed content.
+ */
+function applyFixes(input, errors) {
+  const lineEnding = helpers.getPreferredLineEnding(input, __webpack_require__(/*! node:os */ "?e6c4"));
+  const lines = input.split(helpers.newLineRe);
+  // Normalize fixInfo objects
+  let fixInfos = errors
+    .filter((error) => error.fixInfo)
+    // @ts-ignore
+    .map((error) => normalizeFixInfo(error.fixInfo, error.lineNumber));
+  // Sort bottom-to-top, line-deletes last, right-to-left, long-to-short
+  fixInfos.sort((a, b) => {
+    const aDeletingLine = (a.deleteCount === -1);
+    const bDeletingLine = (b.deleteCount === -1);
+    return (
+      (b.lineNumber - a.lineNumber) ||
+      (aDeletingLine ? 1 : (bDeletingLine ? -1 : 0)) ||
+      (b.editColumn - a.editColumn) ||
+      (b.insertText.length - a.insertText.length)
+    );
+  });
+  // Remove duplicate entries (needed for following collapse step)
+  // eslint-disable-next-line jsdoc/valid-types
+  /** @type RuleOnErrorFixInfo */
+  let lastFixInfo = {};
+  fixInfos = fixInfos.filter((fixInfo) => {
+    const unique = (
+      (fixInfo.lineNumber !== lastFixInfo.lineNumber) ||
+      (fixInfo.editColumn !== lastFixInfo.editColumn) ||
+      (fixInfo.deleteCount !== lastFixInfo.deleteCount) ||
+      (fixInfo.insertText !== lastFixInfo.insertText)
+    );
+    lastFixInfo = fixInfo;
+    return unique;
+  });
+  // Collapse insert/no-delete and no-insert/delete for same line/column
+  lastFixInfo = {
+    "lineNumber": -1
+  };
+  for (const fixInfo of fixInfos) {
+    if (
+      (fixInfo.lineNumber === lastFixInfo.lineNumber) &&
+      (fixInfo.editColumn === lastFixInfo.editColumn) &&
+      !fixInfo.insertText &&
+      (fixInfo.deleteCount > 0) &&
+      lastFixInfo.insertText &&
+      !lastFixInfo.deleteCount) {
+      fixInfo.insertText = lastFixInfo.insertText;
+      lastFixInfo.lineNumber = 0;
+    }
+    lastFixInfo = fixInfo;
   }
-  return config;
+  fixInfos = fixInfos.filter((fixInfo) => fixInfo.lineNumber);
+  // Apply all (remaining/updated) fixes
+  let lastLineIndex = -1;
+  let lastEditIndex = -1;
+  for (const fixInfo of fixInfos) {
+    const { lineNumber, editColumn, deleteCount } = fixInfo;
+    const lineIndex = lineNumber - 1;
+    const editIndex = editColumn - 1;
+    if (
+      (lineIndex !== lastLineIndex) ||
+      (deleteCount === -1) ||
+      ((editIndex + deleteCount) <=
+        (lastEditIndex - ((deleteCount > 0) ? 0 : 1)))
+    ) {
+      // @ts-ignore
+      lines[lineIndex] = applyFix(lines[lineIndex], fixInfo, lineEnding);
+    }
+    lastLineIndex = lineIndex;
+    lastEditIndex = editIndex;
+  }
+  // Return corrected input
+  return lines.filter((line) => line !== null).join(lineEnding);
 }
 
 /**
@@ -2903,7 +2930,7 @@ function readConfigSync(file, parsers, fs) {
  * @returns {string} SemVer string.
  */
 function getVersion() {
-  return (__webpack_require__(/*! ./constants */ "../lib/constants.js").version);
+  return version;
 }
 
 // Export a/synchronous/Promise APIs
@@ -2916,17 +2943,12 @@ markdownlint.promises = {
   "extendConfig": extendConfigPromise,
   "readConfig": readConfigPromise
 };
+markdownlint.applyFix = applyFix;
+markdownlint.applyFixes = applyFixes;
 module.exports = markdownlint;
 
 // Type declarations
 
-/**
- * Function to get an instance of the markdown-it parser.
- *
- * @callback GetMarkdownIt
- * @returns {import("markdown-it")}
- */
-
 /**
  * Function to implement rule logic.
  *
@@ -2947,6 +2969,7 @@ module.exports = markdownlint;
  * @property {readonly string[]} lines File/string lines.
  * @property {readonly string[]} frontMatterLines Front matter lines.
  * @property {RuleConfiguration} config Rule configuration.
+ * @property {string} version Version of the markdownlint library.
  */
 
 /* eslint-enable jsdoc/valid-types */
@@ -3040,6 +3063,16 @@ module.exports = markdownlint;
  * @property {string} [insertText] Text to insert (after deleting).
  */
 
+/**
+ * RuleOnErrorInfo with all optional properties present.
+ *
+ * @typedef {Object} RuleOnErrorFixInfoNormalized
+ * @property {number} lineNumber Line number (1-based).
+ * @property {number} editColumn Column of the fix (1-based).
+ * @property {number} deleteCount Count of characters to delete.
+ * @property {string} insertText Text to insert (after deleting).
+ */
+
 /**
  * Rule definition.
  *
@@ -3194,7 +3227,7 @@ module.exports = markdownlint;
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHeadingLevel } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHeadingLevel } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -3236,7 +3269,7 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHeadingLevel, getHeadingStyle } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHeadingLevel, getHeadingStyle } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -3297,7 +3330,7 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getDescendantsByType, getTokenParentOfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType, getParentOfType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const markerToStyle = {
@@ -3337,10 +3370,10 @@ module.exports = {
     for (const listUnordered of filterByTypesCached([ "listUnordered" ])) {
       let nesting = 0;
       if (style === "sublist") {
-        /** @type {import("../helpers/micromark.cjs").Token | null} */
+        /** @type {import("../helpers/micromark-helpers.cjs").Token | null} */
         let parent = listUnordered;
         // @ts-ignore
-        while ((parent = getTokenParentOfType(parent, [ "listOrdered", "listUnordered" ]))) {
+        while ((parent = getParentOfType(parent, [ "listOrdered", "listUnordered" ]))) {
           nesting++;
         }
       }
@@ -3477,7 +3510,7 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getTokenParentOfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getParentOfType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -3509,11 +3542,11 @@ module.exports = {
         lastBlockQuotePrefix = token;
       } else if (type === "listUnordered") {
         let nesting = 0;
-        /** @type {import("../helpers/micromark.cjs").Token | null} */
+        /** @type {import("../helpers/micromark-helpers.cjs").Token | null} */
         let current = token;
         while (
           // @ts-ignore
-          (current = getTokenParentOfType(current, unorderedParentTypes))
+          (current = getParentOfType(current, unorderedParentTypes))
         ) {
           if (current.type === "listUnordered") {
             nesting++;
@@ -3576,7 +3609,7 @@ module.exports = {
 
 
 const { addError } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -3681,8 +3714,8 @@ module.exports = {
 
 
 
-const { addError, withinAnyRange } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getDescendantsByType, getExclusionsForToken } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addError, hasOverlap } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const tabRe = /\t+/g;
@@ -3705,9 +3738,8 @@ module.exports = {
     const spaceMultiplier = (spacesPerTab === undefined) ?
       1 :
       Math.max(0, Number(spacesPerTab));
-    const exclusions = [];
     // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").TokenType[] */
+    /** @type import("../helpers/micromark-helpers.cjs").TokenType[] */
     const exclusionTypes = [];
     if (includeCode) {
       if (ignoreCodeLanguages.size > 0) {
@@ -3723,24 +3755,29 @@ module.exports = {
       }
       return true;
     });
-    for (const codeToken of codeTokens) {
-      const exclusionsForToken = getExclusionsForToken(params.lines, codeToken);
-      if (codeToken.type === "codeFenced") {
-        exclusionsForToken.pop();
-        exclusionsForToken.shift();
-      }
-      exclusions.push(...exclusionsForToken);
-    }
+    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;
-        if (!withinAnyRange(exclusions, lineIndex + 1, column, length)) {
+        /** @type {import("../helpers").FileRange} */
+        const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
+        if (!codeRanges.some((codeRange) => hasOverlap(codeRange, range))) {
           addError(
             onError,
-            lineIndex + 1,
+            lineNumber,
             "Column: " + column,
             undefined,
             [ column, length ],
@@ -3770,8 +3807,8 @@ module.exports = {
 
 
 
-const { addError, withinAnyRange } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { addRangeToSet, getExclusionsForToken } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addError, hasOverlap } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const reversedLinkRe =
@@ -3789,34 +3826,35 @@ module.exports = {
     for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
       addRangeToSet(codeBlockLineNumbers, codeBlock.startLine, codeBlock.endLine);
     }
-    const exclusions = [];
-    for (const codeText of filterByTypesCached([ "codeText" ])) {
-      exclusions.push(...getExclusionsForToken(params.lines, codeText));
-    }
+    const codeTexts = filterByTypesCached([ "codeText" ]);
     for (const [ lineIndex, line ] of params.lines.entries()) {
-      if (!codeBlockLineNumbers.has(lineIndex + 1)) {
+      const lineNumber = lineIndex + 1;
+      if (!codeBlockLineNumbers.has(lineNumber)) {
         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 + 1, index, length)
+            !linkDestination.endsWith("\\")
           ) {
-            addError(
-              onError,
-              lineIndex + 1,
-              reversedLink.slice(preChar.length),
-              undefined,
-              [ index + 1, length ],
-              {
-                "editColumn": index + 1,
-                "deleteCount": length,
-                "insertText": `[${linkText}](${linkDestination})`
-              }
-            );
+            const column = match.index + preChar.length + 1;
+            const length = match[0].length - preChar.length;
+            /** @type {import("../helpers").FileRange} */
+            const range = { "startLine": lineNumber, "startColumn": column, "endLine": lineNumber, "endColumn": column + length - 1 };
+            if (!codeTexts.some((codeText) => hasOverlap(codeText, range))) {
+              addError(
+                onError,
+                lineNumber,
+                reversedLink.slice(preChar.length),
+                undefined,
+                [ column, length ],
+                {
+                  "editColumn": column,
+                  "deleteCount": length,
+                  "insertText": `[${linkText}](${linkDestination})`
+                }
+              );
+            }
           }
         }
       }
@@ -3839,7 +3877,7 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -3894,7 +3932,7 @@ module.exports = {
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 const { getReferenceLinkImageData } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
-const { addRangeToSet, getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addRangeToSet, getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const longLineRePrefix = "^.{";
@@ -4009,7 +4047,6 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByTypes } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const dollarCommandRe = /^(\s*)(\$\s+)/;
@@ -4023,18 +4060,15 @@ module.exports = {
   "parser": "micromark",
   "function": function MD014(params, onError) {
     for (const codeBlock of filterByTypesCached([ "codeFenced", "codeIndented" ])) {
-      const codeFlowValues = filterByTypes(
-        codeBlock.children,
-        [ "codeFlowValue" ]
-      );
-      const dollarMatches = codeFlowValues.
-        map((codeFlowValue) => ({
+      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);
+        }))
+        .filter((dollarMatch) => dollarMatch.result);
       if (dollarMatches.length === codeFlowValues.length) {
         for (const dollarMatch of dollarMatches) {
           // @ts-ignore
@@ -4074,7 +4108,7 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -4131,7 +4165,7 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers/helpers */ "../helpers/helpers.js");
-const { getHeadingStyle } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHeadingStyle } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 /**
@@ -4222,7 +4256,7 @@ module.exports = [
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addRangeToSet } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -4241,7 +4275,7 @@ module.exports = {
     for (const [ lineIndex, line ] of lines.entries()) {
       if (!ignoreBlockLineNumbers.has(lineIndex + 1)) {
         const match =
-          /^(#+)([ \t]*)([^#]*?[^#\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
+          /^(#+)([ \t]*)([^# \t\\]|[^# \t][^#]*?[^# \t\\])([ \t]*)((?:\\#)?)(#+)(\s*)$/.exec(line);
         if (match) {
           const [
             ,
@@ -4303,8 +4337,8 @@ module.exports = {
 
 
 
-const { addErrorDetailIf, blockquotePrefixRe, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHeadingLevel } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addErrorDetailIf, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { getBlockQuotePrefixText, getHeadingLevel } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const defaultLines = 1;
@@ -4322,15 +4356,6 @@ const getLinesFunction = (linesParam) => {
   return () => lines;
 };
 
-const getBlockQuote = (str, count) => (
-  (str || "")
-    .match(blockquotePrefixRe)[0]
-    .trimEnd()
-    // eslint-disable-next-line unicorn/prefer-spread
-    .concat("\n")
-    .repeat(count)
-);
-
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
 module.exports = {
@@ -4342,6 +4367,7 @@ module.exports = {
     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();
@@ -4366,8 +4392,9 @@ module.exports = {
           line,
           undefined,
           {
-            "insertText": getBlockQuote(
-              lines[startLine - 2],
+            "insertText": getBlockQuotePrefixText(
+              blockQuotePrefixes,
+              startLine - 1,
               linesAbove - actualAbove
             )
           }
@@ -4395,8 +4422,9 @@ module.exports = {
           undefined,
           {
             "lineNumber": endLine + 1,
-            "insertText": getBlockQuote(
-              lines[endLine],
+            "insertText": getBlockQuotePrefixText(
+              blockQuotePrefixes,
+              endLine + 1,
               linesBelow - actualBelow
             )
           }
@@ -4472,7 +4500,7 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHeadingLevel, getHeadingText } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHeadingLevel, getHeadingText } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -4531,7 +4559,7 @@ module.exports = {
 
 
 const { addErrorContext, frontMatterHasTitle } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHeadingLevel, getHeadingText } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHeadingLevel, getHeadingText } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -4647,9 +4675,9 @@ const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
 module.exports = {
-  "names": ["MD027", "no-multiple-space-blockquote"],
+  "names": [ "MD027", "no-multiple-space-blockquote" ],
   "description": "Multiple spaces after blockquote symbol",
-  "tags": ["blockquote", "whitespace", "indentation"],
+  "tags": [ "blockquote", "whitespace", "indentation" ],
   "parser": "micromark",
   "function": function MD027(params, onError) {
     for (const token of filterByTypesCached([ "linePrefix" ])) {
@@ -4743,7 +4771,7 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getDescendantsByType, getTokenTextByType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const listStyleExamples = {
@@ -4755,11 +4783,11 @@ const listStyleExamples = {
 /**
  * Gets the value of an ordered list item prefix token.
  *
- * @param {import("../helpers/micromark.cjs").Token} listItemPrefix List item prefix token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} listItemPrefix List item prefix token.
  * @returns {number} List item value.
  */
 function getOrderedListItemValue(listItemPrefix) {
-  return Number(getTokenTextByType(listItemPrefix.children, "listItemValue"));
+  return Number(getDescendantsByType(listItemPrefix, [ "listItemValue" ])[0].text);
 }
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -4901,7 +4929,7 @@ module.exports = {
 
 
 const { addErrorContext, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getTokenParentOfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getParentOfType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const codeFencePrefixRe = /^(.*?)[`~]/;
@@ -4921,10 +4949,12 @@ const codeFencePrefixRe = /^(.*?)[`~]/;
 function addError(onError, lines, lineNumber, top) {
   const line = lines[lineNumber - 1];
   const [ , prefix ] = line.match(codeFencePrefixRe) || [];
-  const fixInfo = (prefix === undefined) ? null : {
-    "lineNumber": lineNumber + (top ? 0 : 1),
-    "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
-  };
+  const fixInfo = (prefix === undefined) ?
+    null :
+    {
+      "lineNumber": lineNumber + (top ? 0 : 1),
+      "insertText": `${prefix.replace(/[^>]/g, " ").trim()}\n`
+    };
   addErrorContext(
     onError,
     lineNumber,
@@ -4948,7 +4978,7 @@ module.exports = {
     const includeListItems = (listItems === undefined) ? true : !!listItems;
     const { lines } = params;
     for (const codeBlock of filterByTypesCached([ "codeFenced" ])) {
-      if (includeListItems || !(getTokenParentOfType(codeBlock, [ "listOrdered", "listUnordered" ]))) {
+      if (includeListItems || !(getParentOfType(codeBlock, [ "listOrdered", "listUnordered" ]))) {
         if (!isBlankLine(lines[codeBlock.startLine - 2])) {
           addError(onError, lines, codeBlock.startLine, true);
         }
@@ -4974,8 +5004,9 @@ module.exports = {
 
 
 
-const { addErrorContextForLine, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, nonContentTokens } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addErrorContext, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { filterByPredicate, getBlockQuotePrefixText, nonContentTokens } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
+const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const isList = (token) => (
   (token.type === "listOrdered") || (token.type === "listUnordered")
@@ -4990,6 +5021,7 @@ module.exports = {
   "parser": "micromark",
   "function": function MD032(params, onError) {
     const { lines, parsers } = params;
+    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
 
     // For every top-level list...
     const topLevelLists = filterByPredicate(
@@ -5002,13 +5034,18 @@ module.exports = {
     for (const list of topLevelLists) {
 
       // Look for a blank line above the list
-      const firstIndex = list.startLine - 1;
-      if (!isBlankLine(lines[firstIndex - 1])) {
-        addErrorContextForLine(
+      const firstLineNumber = list.startLine;
+      if (!isBlankLine(lines[firstLineNumber - 2])) {
+        addErrorContext(
           onError,
-          // @ts-ignore
-          lines,
-          firstIndex
+          firstLineNumber,
+          lines[firstLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, firstLineNumber)
+          }
         );
       }
 
@@ -5023,14 +5060,19 @@ module.exports = {
       }
 
       // Look for a blank line below the list
-      const lastIndex = endLine - 1;
-      if (!isBlankLine(lines[lastIndex + 1])) {
-        addErrorContextForLine(
+      const lastLineNumber = endLine;
+      if (!isBlankLine(lines[lastLineNumber])) {
+        addErrorContext(
           onError,
-          // @ts-ignore
-          lines,
-          lastIndex,
-          lastIndex + 2
+          lastLineNumber,
+          lines[lastLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "lineNumber": lastLineNumber + 1,
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, lastLineNumber)
+          }
         );
       }
     }
@@ -5052,7 +5094,7 @@ module.exports = {
 
 
 const { addError, nextLinesRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHtmlTagInfo } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHtmlTagInfo } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -5104,8 +5146,7 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, getHtmlTagInfo, inHtmlFlow, parse } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
-const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
+const { filterByPredicate, getHtmlTagInfo, inHtmlFlow } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -5122,8 +5163,6 @@ module.exports = {
           if ((token.type === "literalAutolink") && !inHtmlFlow(token)) {
             // Detect and ignore https://github.com/micromark/micromark/issues/164
             const siblings = token.parent?.children;
-              // Commented-out due to not being able to exercise in test/code coverage
-              // || micromarkTokens;
             const index = siblings?.indexOf(token);
             // @ts-ignore
             const prev = siblings?.at(index - 1);
@@ -5141,6 +5180,7 @@ module.exports = {
           return false;
         },
         (token) => {
+          // Ignore content of inline HTML tags
           const { children } = token;
           const result = [];
           for (let i = 0; i < children.length; i++) {
@@ -5171,31 +5211,25 @@ module.exports = {
         }
       )
     );
-    const autoLinks = filterByTypesCached([ "literalAutolink" ]);
-    if (autoLinks.length > 0) {
-      // Re-parse with correct link/image reference definition handling
-      const document = params.lines.join("\n");
-      const tokens = parse(document, undefined, false);
-      for (const token of literalAutolinks(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
-        );
-      }
+    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
+      );
     }
   }
 };
@@ -5252,15 +5286,15 @@ module.exports = {
 
 
 const { addErrorContext, allPunctuation } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { matchAndGetTokensByType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
-/** @typedef {import("../helpers/micromark.cjs").TokenType} TokenType */
-/** @type {Map<TokenType, TokenType[]>} */
-const emphasisAndChildrenTypes = new Map([
-  [ "emphasis", [ "emphasisSequence", "emphasisText", "emphasisSequence" ] ],
-  [ "strong", [ "strongSequence", "strongText", "strongSequence" ] ]
-]);
+/** @typedef {import("../helpers/micromark-helpers.cjs").TokenType} TokenType */
+/** @type {TokenType[][]} */
+const emphasisTypes = [
+  [ "emphasis", "emphasisText" ],
+  [ "strong", "strongText" ]
+];
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -5274,25 +5308,19 @@ module.exports = {
     punctuation = String((punctuation === undefined) ? allPunctuation : punctuation);
     const punctuationRe = new RegExp("[" + punctuation + "]$");
     const paragraphTokens =
-      filterByTypesCached([ "paragraph" ]).
-        filter((token) =>
+      filterByTypesCached([ "paragraph" ])
+        .filter((token) =>
           (token.parent?.type === "content") && !token.parent?.parent && (token.children.length === 1)
         );
-    for (const paragraphToken of paragraphTokens) {
-      const childToken = paragraphToken.children[0];
-      for (const [ emphasisType, emphasisChildrenTypes ] of emphasisAndChildrenTypes) {
-        if (childToken.type === emphasisType) {
-          const matchingTokens = matchAndGetTokensByType(childToken.children, emphasisChildrenTypes);
-          if (matchingTokens) {
-            const textToken = matchingTokens[1];
-            if (
-              (textToken.children.length === 1) &&
-              (textToken.children[0].type === "data") &&
-              !punctuationRe.test(textToken.text)
-            ) {
-              addErrorContext(onError, textToken.startLine, textToken.text);
-            }
-          }
+    for (const emphasisType of emphasisTypes) {
+      const textTokens = getDescendantsByType(paragraphTokens, emphasisType);
+      for (const textToken of textTokens) {
+        if (
+          (textToken.children.length === 1) &&
+          (textToken.children[0].type === "data") &&
+          !punctuationRe.test(textToken.text)
+        ) {
+          addErrorContext(onError, textToken.startLine, textToken.text);
         }
       }
     }
@@ -5314,7 +5342,7 @@ module.exports = {
 
 
 const { addError } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, inHtmlFlow } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { filterByPredicate, inHtmlFlow } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -5419,7 +5447,7 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { tokenIfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const leftSpaceRe = /^\s(?:[^`]|$)/;
@@ -5445,24 +5473,19 @@ module.exports = {
   "function": function MD038(params, onError) {
     const codeTexts = filterByTypesCached([ "codeText" ]);
     for (const codeText of codeTexts) {
-      const { children } = codeText;
-      const first = 0;
-      const last = children.length - 1;
-      const startSequence = tokenIfType(children[first], "codeTextSequence");
-      const endSequence = tokenIfType(children[last], "codeTextSequence");
-      const startData =
-        tokenIfType(children[first + 1], "codeTextData") ||
-        tokenIfType(children[first + 2], "codeTextData");
-      const endData =
-        tokenIfType(children[last - 1], "codeTextData") ||
-        tokenIfType(children[last - 2], "codeTextData");
+      const sequences = getDescendantsByType(codeText, [ "codeTextSequence" ]);
+      const startSequence = sequences[0];
+      const endSequence = sequences[sequences.length - 1];
+      const datas = getDescendantsByType(codeText, [ "codeTextData" ]);
+      const startData = datas[0];
+      const endData = datas[datas.length - 1];
       if (startSequence && endSequence && startData && endData) {
         const spaceLeft = leftSpaceRe.test(startData.text);
         const spaceRight = rightSpaceRe.test(endData.text);
         if (spaceLeft || spaceRight) {
           let lineNumber = startSequence.startLine;
-          let range = null;
-          let fixInfo = null;
+          let range = undefined;
+          let fixInfo = undefined;
           if (startSequence.startLine === endSequence.endLine) {
             range = [
               startSequence.startColumn,
@@ -5530,15 +5553,14 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByTypes } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
 const { getReferenceLinkImageData, filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 /**
  * Adds an error for a label space issue.
  *
  * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
- * @param {import("../helpers/micromark.cjs").Token} label Label token.
- * @param {import("../helpers/micromark.cjs").Token} labelText LabelText token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} label Label token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} labelText LabelText token.
  * @param {boolean} isStart True iff error is at the start of the link.
  */
 function addLabelSpaceError(onError, label, labelText, isStart) {
@@ -5556,18 +5578,20 @@ function addLabelSpaceError(onError, label, labelText, isStart) {
     isStart,
     !isStart,
     range,
-    range ? {
-      "editColumn": range[0],
-      "deleteCount": range[1]
-    } : undefined
+    range ?
+      {
+        "editColumn": range[0],
+        "deleteCount": range[1]
+      } :
+      undefined
   );
 }
 
 /**
  * Determines if a link is a valid link (and not a fake shortcut link due to parser tricks).
  *
- * @param {import("../helpers/micromark.cjs").Token} label Label token.
- * @param {import("../helpers/micromark.cjs").Token} labelText LabelText token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} label Label token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} labelText LabelText token.
  * @param {Map<string, any>} definitions Map of link definitions.
  * @returns {boolean} True iff the link is valid.
  */
@@ -5584,13 +5608,10 @@ module.exports = {
   "parser": "micromark",
   "function": function MD039(params, onError) {
     const { definitions } = getReferenceLinkImageData();
-    const labels = filterByTypesCached([ "label" ]).
-      filter((label) => label.parent?.type === "link");
+    const labels = filterByTypesCached([ "label" ])
+      .filter((label) => label.parent?.type === "link");
     for (const label of labels) {
-      const labelTexts = filterByTypes(
-        label.children,
-        [ "labelText" ]
-      );
+      const labelTexts = label.children.filter((child) => child.type === "labelText");
       for (const labelText of labelTexts) {
         if (
           (labelText.text.trimStart().length !== labelText.text.length) &&
@@ -5624,7 +5645,7 @@ module.exports = {
 
 
 const { addError, addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getTokenTextByType, tokenIfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -5640,18 +5661,16 @@ module.exports = {
     const languageOnly = !!params.config.language_only;
     const fencedCodes = filterByTypesCached([ "codeFenced" ]);
     for (const fencedCode of fencedCodes) {
-      const openingFence = tokenIfType(fencedCode.children[0], "codeFencedFence");
-      if (openingFence) {
-        const { children, startLine, text } = openingFence;
-        const info = getTokenTextByType(children, "codeFencedFenceInfo");
-        if (!info) {
-          addErrorContext(onError, startLine, text);
-        } else if ((allowed.length > 0) && !allowed.includes(info)) {
-          addError(onError, startLine, `"${info}" is not allowed`);
-        }
-        if (languageOnly && getTokenTextByType(children, "codeFencedFenceMeta")) {
-          addError(onError, startLine, `Info string contains more than language: "${text}"`);
-        }
+      const openingFence = getDescendantsByType(fencedCode, [ "codeFencedFence" ])[0];
+      const { startLine, text } = openingFence;
+      const info = getDescendantsByType(openingFence, [ "codeFencedFenceInfo" ])[0]?.text;
+      if (!info) {
+        addErrorContext(onError, startLine, text);
+      } else if ((allowed.length > 0) && !allowed.includes(info)) {
+        addError(onError, startLine, `"${info}" is not allowed`);
+      }
+      if (languageOnly && getDescendantsByType(openingFence, [ "codeFencedFenceMeta" ]).length > 0) {
+        addError(onError, startLine, `Info string contains more than language: "${text}"`);
       }
     }
   }
@@ -5673,7 +5692,7 @@ module.exports = {
 
 const { addErrorContext, frontMatterHasTitle } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 const { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } =
-  __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+  __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
@@ -5685,9 +5704,9 @@ module.exports = {
   "function": function MD041(params, onError) {
     const level = Number(params.config.level || 1);
     if (!frontMatterHasTitle(params.frontMatterLines, params.config.front_matter_title)) {
-      params.parsers.micromark.tokens.
-        filter((token) => !nonContentTokens.has(token.type) && !isHtmlFlowComment(token)).
-        every((token) => {
+      params.parsers.micromark.tokens
+        .filter((token) => !nonContentTokens.has(token.type) && !isHtmlFlowComment(token))
+        .every((token) => {
           let isError = true;
           if ((token.type === "atxHeading") || (token.type === "setextHeading")) {
             isError = (getHeadingLevel(token) !== level);
@@ -5720,7 +5739,7 @@ module.exports = {
 
 
 const { addErrorContext } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { getReferenceLinkImageData, filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -5742,11 +5761,7 @@ module.exports = {
       const reference = getDescendantsByType(link, [ "reference" ]);
       const resource = getDescendantsByType(link, [ "resource" ]);
       const referenceString = getDescendantsByType(reference, [ "referenceString" ]);
-      const resourceDestination = getDescendantsByType(resource, [ "resourceDestination" ]);
-      const resourceDestinationString = [
-        ...getDescendantsByType(resourceDestination, [ "resourceDestinationRaw", "resourceDestinationString" ]),
-        ...getDescendantsByType(resourceDestination, [ "resourceDestinationLiteral", "resourceDestinationString" ])
-      ];
+      const resourceDestinationString = getDescendantsByType(resource, [ "resourceDestination", [ "resourceDestinationLiteral", "resourceDestinationRaw" ], "resourceDestinationString" ]);
       const hasLabelText = labelText.length > 0;
       const hasReference = reference.length > 0;
       const hasResource = resource.length > 0;
@@ -5794,7 +5809,7 @@ module.exports = {
 
 
 const { addErrorContext, addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { getHeadingLevel, getHeadingText } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHeadingLevel, getHeadingText } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -5877,10 +5892,9 @@ module.exports = {
 
 
 
-const { addErrorDetailIf, escapeForRegExp, withinAnyRange } =
-  __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, filterByTypes, parse } =
-  __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addErrorDetailIf, escapeForRegExp, hasOverlap } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { filterByPredicate, filterByTypes } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
+const { parse } = __webpack_require__(/*! ../helpers/micromark-parse.cjs */ "../helpers/micromark-parse.cjs");
 
 const ignoredChildTypes = new Set(
   [ "codeFencedFence", "definition", "reference", "resource" ]
@@ -5924,43 +5938,47 @@ module.exports = {
           token.children.filter((t) => !ignoredChildTypes.has(t.type))
         )
       );
+    /** @type {import("../helpers").FileRange[]} */
     const exclusions = [];
-    const autoLinked = new Set();
+    const scannedTokens = new Set();
     for (const name of names) {
       const escapedName = escapeForRegExp(name);
       const startNamePattern = /^\W/.test(name) ? "" : "\\b_*";
       const endNamePattern = /\W$/.test(name) ? "" : "_*\\b";
-      const namePattern =
-        `(${startNamePattern})(${escapedName})${endNamePattern}`;
+      const namePattern = `(${startNamePattern})(${escapedName})${endNamePattern}`;
       const nameRe = new RegExp(namePattern, "gi");
       for (const token of contentTokens) {
         let match = null;
         while ((match = nameRe.exec(token.text)) !== null) {
           const [ , leftMatch, nameMatch ] = match;
-          const index = token.startColumn - 1 + match.index + leftMatch.length;
+          const column = token.startColumn + match.index + leftMatch.length;
           const length = nameMatch.length;
-          const lineIndex = token.startLine - 1;
+          const lineNumber = token.startLine;
+          /** @type {import("../helpers").FileRange} */
+          const nameRange = {
+            "startLine": lineNumber,
+            "startColumn": column,
+            "endLine": lineNumber,
+            "endColumn": column + length - 1
+          };
           if (
-            !withinAnyRange(exclusions, lineIndex, index, length) &&
-            !names.includes(nameMatch)
+            !names.includes(nameMatch) &&
+            !exclusions.some((exclusion) => hasOverlap(exclusion, nameRange))
           ) {
-            let urlRanges = [];
-            if (!autoLinked.has(token)) {
-              urlRanges = filterByTypes(
-                parse(token.text),
-                [ "literalAutolink" ]
-              ).map(
-                (t) => [
-                  lineIndex,
-                  token.startColumn - 1 + t.startColumn - 1,
-                  t.endColumn - t.startColumn
-                ]
-              );
-              exclusions.push(...urlRanges);
-              autoLinked.add(token);
+            /** @type {import("../helpers").FileRange[]} */
+            let autolinkRanges = [];
+            if (!scannedTokens.has(token)) {
+              autolinkRanges = filterByTypes(parse(token.text), [ "literalAutolink" ])
+                .map((tok) => ({
+                  "startLine": lineNumber,
+                  "startColumn": token.startColumn + tok.startColumn - 1,
+                  "endLine": lineNumber,
+                  "endColumn": token.endColumn + tok.endColumn - 1
+                }));
+              exclusions.push(...autolinkRanges);
+              scannedTokens.add(token);
             }
-            if (!withinAnyRange(urlRanges, lineIndex, index, length)) {
-              const column = index + 1;
+            if (!autolinkRanges.some((autolinkRange) => hasOverlap(autolinkRange, nameRange))) {
               addErrorDetailIf(
                 onError,
                 token.startLine,
@@ -5977,7 +5995,7 @@ module.exports = {
               );
             }
           }
-          exclusions.push([ lineIndex, index, length ]);
+          exclusions.push(nameRange);
         }
       }
     }
@@ -5999,7 +6017,7 @@ module.exports = {
 
 
 const { addError, getHtmlAttributeRe, nextLinesRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByTypes, getHtmlTagInfo } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getHtmlTagInfo, getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const altRe = getHtmlAttributeRe("alt");
@@ -6015,7 +6033,7 @@ module.exports = {
     // Process Markdown images
     const images = filterByTypesCached([ "image" ]);
     for (const image of images) {
-      const labelTexts = filterByTypes(image.children, [ "labelText" ]);
+      const labelTexts = getDescendantsByType(image, [ "label", "labelText" ]);
       if (labelTexts.some((labelText) => labelText.text.length === 0)) {
         const range = (image.startLine === image.endLine) ?
           [ image.startColumn, image.endColumn - image.startColumn ] :
@@ -6158,10 +6176,25 @@ module.exports = {
 
 
 
-const { addErrorDetailIf, fencedCodeBlockStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { tokenIfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
+/**
+ * Return the string representation of a fence markup character.
+ *
+ * @param {string} markup Fence string.
+ * @returns {"tilde" | "backtick"} String representation.
+ */
+function fencedCodeBlockStyleFor(markup) {
+  switch (markup[0]) {
+    case "~":
+      return "tilde";
+    default:
+      return "backtick";
+  }
+};
+
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
 module.exports = {
@@ -6174,22 +6207,18 @@ module.exports = {
     let expectedStyle = style;
     const codeFenceds = filterByTypesCached([ "codeFenced" ]);
     for (const codeFenced of codeFenceds) {
-      const codeFencedFence = tokenIfType(codeFenced.children[0], "codeFencedFence");
-      if (codeFencedFence) {
-        const codeFencedFenceSequence = tokenIfType(codeFencedFence.children[0], "codeFencedFenceSequence");
-        if (codeFencedFenceSequence) {
-          const { startLine, text } = codeFencedFenceSequence;
-          if (expectedStyle === "consistent") {
-            expectedStyle = fencedCodeBlockStyleFor(text);
-          }
-          addErrorDetailIf(
-            onError,
-            startLine,
-            expectedStyle,
-            fencedCodeBlockStyleFor(text)
-          );
-        }
+      const codeFencedFenceSequence =
+        getDescendantsByType(codeFenced, [ "codeFencedFence", "codeFencedFenceSequence" ])[0];
+      const { startLine, text } = codeFencedFenceSequence;
+      if (expectedStyle === "consistent") {
+        expectedStyle = fencedCodeBlockStyleFor(text);
       }
+      addErrorDetailIf(
+        onError,
+        startLine,
+        expectedStyle,
+        fencedCodeBlockStyleFor(text)
+      );
     }
   }
 };
@@ -6208,11 +6237,26 @@ module.exports = {
 
 
 
-const { addError, emphasisOrStrongStyleFor } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, tokenIfType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addError } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { filterByPredicate, getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 
 const intrawordRe = /^\w$/;
 
+/**
+ * Return the string representation of a emphasis or strong markup character.
+ *
+ * @param {string} markup Emphasis or strong string.
+ * @returns {"asterisk" | "underscore"} String representation.
+ */
+function emphasisOrStrongStyleFor(markup) {
+  switch (markup[0]) {
+    case "*":
+      return "asterisk";
+    default:
+      return "underscore";
+  }
+};
+
 /**
  * @param {import("./markdownlint").RuleParams} params Rule parameters.
  * @param {import("./markdownlint").RuleOnError} onError Error-reporting callback.
@@ -6231,9 +6275,9 @@ const impl =
       (token) => ((token.type === "htmlFlow") ? [] : token.children)
     );
     for (const token of emphasisTokens) {
-      const { children } = token;
-      const startSequence = tokenIfType(children[0], typeSequence);
-      const endSequence = tokenIfType(children[children.length - 1], typeSequence);
+      const sequences = getDescendantsByType(token, [ typeSequence ]);
+      const startSequence = sequences[0];
+      const endSequence = sequences[sequences.length - 1];
       if (startSequence && endSequence) {
         const markupStyle = emphasisOrStrongStyleFor(startSequence.text);
         if (style === "consistent") {
@@ -6322,8 +6366,8 @@ module.exports = [
 
 
 
-const { addError, addErrorDetailIf, getHtmlAttributeRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, filterByTypes, getHtmlTagInfo } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { addError, getHtmlAttributeRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { filterByPredicate, filterByTypes, getHtmlTagInfo } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // Regular expression for identifying HTML anchor names
@@ -6342,7 +6386,7 @@ const tokensInclude = new Set(
  * Converts a Markdown heading into an HTML fragment according to the rules
  * used by GitHub.
  *
- * @param {import("../helpers/micromark.cjs").Token} headingText Heading text token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} headingText Heading text token.
  * @returns {string} Fragment string for heading.
  */
 function convertHeadingToHTMLFragment(headingText) {
@@ -6371,7 +6415,7 @@ function convertHeadingToHTMLFragment(headingText) {
 /**
  * Unescapes the text of a String-type micromark Token.
  *
- * @param {import("../helpers/micromark.cjs").Token} token String-type micromark Token.
+ * @param {import("../helpers/micromark-helpers.cjs").Token} token String-type micromark Token.
  * @returns {string} Unescaped token text.
  */
 function unescapeStringTokenText(token) {
@@ -6388,6 +6432,7 @@ module.exports = {
   "tags": [ "links" ],
   "parser": "micromark",
   "function": function MD051(params, onError) {
+    const ignoreCase = params.config.ignore_case || false;
     const fragments = new Map();
 
     // Process headings
@@ -6424,7 +6469,7 @@ module.exports = {
 
     // Process link and definition fragments
     // eslint-disable-next-line jsdoc/valid-types
-    /** @type import("../helpers/micromark.cjs").TokenType[][] */
+    /** @type import("../helpers/micromark-helpers.cjs").TokenType[][] */
     const parentChilds = [
       [ "link", "resourceDestinationString" ],
       [ "definition", "definitionDestinationString" ]
@@ -6443,11 +6488,8 @@ module.exports = {
             !fragments.has(encodedText) &&
             !lineFragmentRe.test(encodedText)
           ) {
-            // eslint-disable-next-line no-undef-init
             let context = undefined;
-            // eslint-disable-next-line no-undef-init
             let range = undefined;
-            // eslint-disable-next-line no-undef-init
             let fixInfo = undefined;
             if (link.startLine === link.endLine) {
               context = link.text;
@@ -6463,16 +6505,16 @@ module.exports = {
             if (mixedCaseKey) {
               // @ts-ignore
               (fixInfo || {}).insertText = mixedCaseKey;
-              addErrorDetailIf(
-                onError,
-                link.startLine,
-                mixedCaseKey,
-                text,
-                undefined,
-                context,
-                range,
-                fixInfo
-              );
+              if (!ignoreCase && (mixedCaseKey !== text)) {
+                addError(
+                  onError,
+                  link.startLine,
+                  `Expected: ${mixedCaseKey}; Actual: ${text}`,
+                  context,
+                  range,
+                  fixInfo
+                );
+              }
             } else {
               addError(
                 onError,
@@ -6556,10 +6598,11 @@ module.exports = {
 
 
 
-const { addError, ellipsify, linkReferenceDefinitionRe } =
-  __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { addError, ellipsify } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
 const { getReferenceLinkImageData } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
+const linkReferenceDefinitionRe = /^ {0,3}\[([^\]]*[^\\])\]:/;
+
 // eslint-disable-next-line jsdoc/valid-types
 /** @type import("./markdownlint").Rule */
 module.exports = {
@@ -6593,7 +6636,7 @@ module.exports = {
           `Unused link or image reference definition: "${label}"`,
           ellipsify(line),
           [ 1, line.length ],
-          singleLineDefinition(line) ? deleteFixInfo : 0
+          singleLineDefinition(line) ? deleteFixInfo : undefined
         );
       }
     }
@@ -6608,7 +6651,7 @@ module.exports = {
           `Duplicate link or image reference definition: "${label}"`,
           ellipsify(line),
           [ 1, line.length ],
-          singleLineDefinition(line) ? deleteFixInfo : 0
+          singleLineDefinition(line) ? deleteFixInfo : undefined
         );
       }
     }
@@ -6630,7 +6673,7 @@ module.exports = {
 
 
 const { addErrorContext, nextLinesRe } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByPredicate, getTokenTextByType } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getDescendantsByType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { getReferenceLinkImageData, filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const backslashEscapeRe = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g;
@@ -6672,24 +6715,23 @@ module.exports = {
       let label = null;
       let destination = null;
       const {
-        children, endColumn, endLine, startColumn, startLine, text, type
+        endColumn, endLine, startColumn, startLine, text, type
       } = link;
       const image = (type === "image");
       let isError = false;
       if (type === "autolink") {
         // link kind is an autolink
-        destination = getTokenTextByType(children, "autolinkProtocol");
+        destination = getDescendantsByType(link, [ "autolinkProtocol" ])[0].text;
         label = destination;
         isError = !autolink;
       } else {
         // link type is "image" or "link"
-        const descendents = filterByPredicate(children);
-        label = getTokenTextByType(descendents, "labelText");
+        label = getDescendantsByType(link, [ "label", "labelText" ])[0].text;
         destination =
-          getTokenTextByType(descendents, "resourceDestinationString");
+          getDescendantsByType(link, [ "resource", "resourceDestination", [ "resourceDestinationLiteral", "resourceDestinationRaw" ], "resourceDestinationString" ])[0]?.text;
         if (destination) {
           // link kind is an inline link
-          const title = getTokenTextByType(descendents, "resourceTitleString");
+          const title = getDescendantsByType(link, [ "resource", "resourceTitle", "resourceTitleString" ])[0]?.text;
           isError = !inline || (
             !urlInline &&
             autolink &&
@@ -6700,9 +6742,9 @@ module.exports = {
           );
         } else {
           // link kind is a full/collapsed/shortcut reference link
-          const isShortcut = !children.some((t) => t.type === "reference");
-          const referenceString = getTokenTextByType(descendents, "referenceString");
-          const isCollapsed = (referenceString === null);
+          const isShortcut = getDescendantsByType(link, [ "reference" ]).length === 0;
+          const referenceString = getDescendantsByType(link, [ "reference", "referenceString" ])[0]?.text;
+          const isCollapsed = (referenceString === undefined);
           const definition = definitions.get(referenceString || label);
           destination = definition && definition[1];
           isError = destination &&
@@ -6710,9 +6752,8 @@ module.exports = {
         }
       }
       if (isError) {
-        // eslint-disable-next-line no-undef-init
         let range = undefined;
-        let fixInfo = null;
+        let fixInfo = undefined;
         if (startLine === endLine) {
           range = [ startColumn, endColumn - startColumn ];
           let insertText = null;
@@ -6766,7 +6807,6 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByTypes } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const whitespaceTypes = new Set([ "linePrefix", "whitespace" ]);
@@ -6791,51 +6831,45 @@ module.exports = {
       ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "trailing_only"));
     let expectedTrailingPipe =
       ((expectedStyle !== "no_leading_or_trailing") && (expectedStyle !== "leading_only"));
-    const tables = filterByTypesCached([ "table" ]);
-    for (const table of tables) {
-      const rows = filterByTypes(
-        table.children,
-        [ "tableDelimiterRow", "tableRow" ]
-      );
-      for (const row of rows) {
-        // The following uses of first/lastOrNothing lack fallback handling
-        // because it seems not to be possible (i.e., 0% coverage)
-        const firstCell = firstOrNothing(row.children);
-        const leadingToken = firstOrNothing(ignoreWhitespace(firstCell.children));
-        const actualLeadingPipe = (leadingToken.type === "tableCellDivider");
-        const lastCell = lastOrNothing(row.children);
-        const trailingToken = lastOrNothing(ignoreWhitespace(lastCell.children));
-        const actualTrailingPipe = (trailingToken.type === "tableCellDivider");
-        const actualStyle = actualLeadingPipe ?
-          (actualTrailingPipe ? "leading_and_trailing" : "leading_only") :
-          (actualTrailingPipe ? "trailing_only" : "no_leading_or_trailing");
-        if (expectedStyle === "consistent") {
-          expectedStyle = actualStyle;
-          expectedLeadingPipe = actualLeadingPipe;
-          expectedTrailingPipe = actualTrailingPipe;
-        }
-        if (actualLeadingPipe !== expectedLeadingPipe) {
-          addErrorDetailIf(
-            onError,
-            firstCell.startLine,
-            expectedStyle,
-            actualStyle,
-            `${expectedLeadingPipe ? "Missing" : "Unexpected"} leading pipe`,
-            undefined,
-            makeRange(row.startColumn, firstCell.startColumn)
-          );
-        }
-        if (actualTrailingPipe !== expectedTrailingPipe) {
-          addErrorDetailIf(
-            onError,
-            lastCell.endLine,
-            expectedStyle,
-            actualStyle,
-            `${expectedTrailingPipe ? "Missing" : "Unexpected"} trailing pipe`,
-            undefined,
-            makeRange(lastCell.endColumn - 1, row.endColumn - 1)
-          );
-        }
+    const rows = filterByTypesCached([ "tableDelimiterRow", "tableRow" ]);
+    for (const row of rows) {
+      // The following uses of first/lastOrNothing lack fallback handling
+      // because it seems not to be possible (i.e., 0% coverage)
+      const firstCell = firstOrNothing(row.children);
+      const leadingToken = firstOrNothing(ignoreWhitespace(firstCell.children));
+      const actualLeadingPipe = (leadingToken.type === "tableCellDivider");
+      const lastCell = lastOrNothing(row.children);
+      const trailingToken = lastOrNothing(ignoreWhitespace(lastCell.children));
+      const actualTrailingPipe = (trailingToken.type === "tableCellDivider");
+      const actualStyle = actualLeadingPipe ?
+        (actualTrailingPipe ? "leading_and_trailing" : "leading_only") :
+        (actualTrailingPipe ? "trailing_only" : "no_leading_or_trailing");
+      if (expectedStyle === "consistent") {
+        expectedStyle = actualStyle;
+        expectedLeadingPipe = actualLeadingPipe;
+        expectedTrailingPipe = actualTrailingPipe;
+      }
+      if (actualLeadingPipe !== expectedLeadingPipe) {
+        addErrorDetailIf(
+          onError,
+          firstCell.startLine,
+          expectedStyle,
+          actualStyle,
+          `${expectedLeadingPipe ? "Missing" : "Unexpected"} leading pipe`,
+          undefined,
+          makeRange(row.startColumn, firstCell.startColumn)
+        );
+      }
+      if (actualTrailingPipe !== expectedTrailingPipe) {
+        addErrorDetailIf(
+          onError,
+          lastCell.endLine,
+          expectedStyle,
+          actualStyle,
+          `${expectedTrailingPipe ? "Missing" : "Unexpected"} trailing pipe`,
+          undefined,
+          makeRange(lastCell.endColumn - 1, row.endColumn - 1)
+        );
       }
     }
   }
@@ -6856,7 +6890,7 @@ module.exports = {
 
 
 const { addErrorDetailIf } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
-const { filterByTypes } = __webpack_require__(/*! ../helpers/micromark.cjs */ "../helpers/micromark.cjs");
+const { getParentOfType } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 const makeRange = (start, end) => [ start, end - start + 1 ];
@@ -6869,44 +6903,39 @@ module.exports = {
   "tags": [ "table" ],
   "parser": "micromark",
   "function": function MD056(params, onError) {
-    const tables = filterByTypesCached([ "table" ]);
-    for (const table of tables) {
-      const rows = filterByTypes(
-        table.children,
-        [ "tableDelimiterRow", "tableRow" ]
-      );
-      let expectedCount = 0;
-      for (const row of rows) {
-        const cells = filterByTypes(
-          row.children,
-          [ "tableData", "tableDelimiter", "tableHeader" ]
-        );
-        const actualCount = cells.length;
-        expectedCount ||= actualCount;
-        // eslint-disable-next-line no-undef-init
-        let detail = undefined;
-        // eslint-disable-next-line no-undef-init
-        let range = undefined;
-        if (actualCount < expectedCount) {
-          detail = "Too few cells, row will be missing data";
-          range = [ row.endColumn - 1, 1 ];
-        } else if (expectedCount < actualCount) {
-          detail = "Too many cells, extra data will be missing";
-          range = makeRange(cells[expectedCount].startColumn, row.endColumn - 1);
-        }
-        addErrorDetailIf(
-          onError,
-          row.endLine,
-          expectedCount,
-          actualCount,
-          detail,
-          undefined,
-          range
-        );
+    const rows = filterByTypesCached([ "tableDelimiterRow", "tableRow" ]);
+    let expectedCount = 0;
+    let currentTable = null;
+    for (const row of rows) {
+      const table = getParentOfType(row, [ "table" ]);
+      if (currentTable !== table) {
+        expectedCount = 0;
+        currentTable = table;
+      }
+      const cells = row.children.filter((child) => [ "tableData", "tableDelimiter", "tableHeader" ].includes(child.type));
+      const actualCount = cells.length;
+      expectedCount ||= actualCount;
+      let detail = undefined;
+      let range = undefined;
+      if (actualCount < expectedCount) {
+        detail = "Too few cells, row will be missing data";
+        range = [ row.endColumn - 1, 1 ];
+      } else if (expectedCount < actualCount) {
+        detail = "Too many cells, extra data will be missing";
+        range = makeRange(cells[expectedCount].startColumn, row.endColumn - 1);
       }
+      addErrorDetailIf(
+        onError,
+        row.endLine,
+        expectedCount,
+        actualCount,
+        detail,
+        undefined,
+        range
+      );
     }
   }
-}
+};
 
 
 /***/ }),
@@ -6922,7 +6951,8 @@ module.exports = {
 
 
 
-const { addErrorContextForLine, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { addErrorContext, isBlankLine } = __webpack_require__(/*! ../helpers */ "../helpers/helpers.js");
+const { getBlockQuotePrefixText } = __webpack_require__(/*! ../helpers/micromark-helpers.cjs */ "../helpers/micromark-helpers.cjs");
 const { filterByTypesCached } = __webpack_require__(/*! ./cache */ "../lib/cache.js");
 
 // eslint-disable-next-line jsdoc/valid-types
@@ -6934,28 +6964,42 @@ module.exports = {
   "parser": "micromark",
   "function": function MD058(params, onError) {
     const { lines } = params;
+    const blockQuotePrefixes = filterByTypesCached([ "blockQuotePrefix", "linePrefix" ]);
+
     // For every table...
     const tables = filterByTypesCached([ "table" ]);
     for (const table of tables) {
+
       // Look for a blank line above the table
-      const firstIndex = table.startLine - 1;
-      if (!isBlankLine(lines[firstIndex - 1])) {
-        addErrorContextForLine(
+      const firstLineNumber = table.startLine;
+      if (!isBlankLine(lines[firstLineNumber - 2])) {
+        addErrorContext(
           onError,
-          // @ts-ignore
-          lines,
-          firstIndex
+          firstLineNumber,
+          lines[firstLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, firstLineNumber)
+          }
         );
       }
+
       // Look for a blank line below the table
-      const lastIndex = table.endLine - 1;
-      if (!isBlankLine(lines[lastIndex + 1])) {
-        addErrorContextForLine(
+      const lastLineNumber = table.endLine;
+      if (!isBlankLine(lines[lastLineNumber])) {
+        addErrorContext(
           onError,
-          // @ts-ignore
-          lines,
-          lastIndex,
-          lastIndex + 2
+          lastLineNumber,
+          lines[lastLineNumber - 1].trim(),
+          undefined,
+          undefined,
+          undefined,
+          {
+            "lineNumber": lastLineNumber + 1,
+            "insertText": getBlockQuotePrefixText(blockQuotePrefixes, lastLineNumber)
+          }
         );
       }
     }