eslint-plugin-markdown-preferences 0.23.0 → 0.24.0

package/lib/index.js

@@ -1,4 +1,4 @@
-import { __export } from "./chunk-Cl8Af3a2.js";
+import { __export } from "./chunk-CTAAG5j7.js";
 import stringWidth from "string-width";
 import emojiRegex from "emoji-regex-xs";
 import path from "node:path";
@@ -600,12 +600,28 @@ function getBlockquoteLevelFromLine(sourceCode, lineNumber) {
 	const lineText = sourceCode.lines[lineNumber - 1];
 	let prefix = "";
 	let level = 0;
+	let width = 0;
+	let leadingMarkerOffset = 0;
 	const blockquoteMarkers = /* @__PURE__ */ new Map();
 	for (const c of lineText) {
 		if (c === ">") {
+			if (width - leadingMarkerOffset > 3) break;
+			leadingMarkerOffset = width + 1;
 			level++;
-			blockquoteMarkers.set(level, { index: prefix.length });
-		} else if (c.trim()) break;
+			blockquoteMarkers.set(level, { loc: {
+				start: {
+					line: lineNumber,
+					column: prefix.length + 1
+				},
+				end: {
+					line: lineNumber,
+					column: prefix.length + 2
+				}
+			} });
+		} else if (!isSpaceOrTab(c)) break;
+		if (c === "	") width += 4 - width % 4;
+		else width++;
+		if (c !== ">" && prefix.at(-1) === ">") leadingMarkerOffset++;
 		prefix += c;
 	}
 	const result = {
@@ -618,6 +634,64 @@ function getBlockquoteLevelFromLine(sourceCode, lineNumber) {
 	return result;
 }
 
+//#endregion
+//#region src/utils/width.ts
+/**
+* Get the visual width of the string.
+*/
+function getWidth(str) {
+	let width = 0;
+	for (const c of str) if (c === "	") width += 4 - width % 4;
+	else width++;
+	return width;
+}
+/**
+* Get a slice of the string by visual width.
+*/
+function sliceWidth(str, start, end) {
+	const buffer = [...str];
+	let width = 0;
+	let c;
+	while (c = buffer.shift()) {
+		if (start <= width) {
+			buffer.unshift(c);
+			break;
+		}
+		if (c === "	") width += 4 - width % 4;
+		else width++;
+	}
+	if (buffer.length === 0) return "";
+	let result = " ".repeat(width - start);
+	if (end == null) return `${result}${buffer.join("")}`;
+	while (c = buffer.shift()) {
+		let newWidth;
+		if (c === "	") newWidth = width + 4 - width % 4;
+		else newWidth = width + 1;
+		if (end < newWidth) {
+			buffer.unshift(c);
+			break;
+		}
+		result += c;
+		width = newWidth;
+	}
+	if (buffer.length === 0) return result;
+	result += " ".repeat(end - width);
+	return result;
+}
+/**
+* Get the character at the visual width.
+*/
+function atWidth(str, target) {
+	let width = 0;
+	for (const c of str) {
+		if (target === width) return c;
+		if (target < width) return " ";
+		if (c === "	") width += 4 - width % 4;
+		else width++;
+	}
+	return null;
+}
+
 //#endregion
 //#region src/rules/blockquote-marker-alignment.ts
 var blockquote_marker_alignment_default = createRule("blockquote-marker-alignment", {
@@ -655,38 +729,33 @@ var blockquote_marker_alignment_default = createRule("blockquote-marker-alignmen
 				const endLine = loc.end.line;
 				const base = getBlockquoteLevelFromLine(sourceCode, startLine).blockquoteMarkers.get(blockquoteLevel);
 				if (!base) return;
+				const baseBeforeMarker = sourceCode.lines[startLine - 1].slice(0, base.loc.start.column - 1);
+				const baseIndentWidth = getWidth(baseBeforeMarker);
 				for (let lineNumber = startLine + 1; lineNumber <= endLine; lineNumber++) {
 					const marker = getBlockquoteLevelFromLine(sourceCode, lineNumber).blockquoteMarkers.get(blockquoteLevel);
 					if (!marker) continue;
-					if (base.index === marker.index) continue;
+					const indentWidth = getWidth(sourceCode.lines[lineNumber - 1].slice(0, marker.loc.start.column - 1));
+					if (baseIndentWidth === indentWidth) continue;
 					blockquoteStack.reported = true;
 					context.report({
 						node,
-						loc: {
-							start: {
-								line: lineNumber,
-								column: marker.index + 1
-							},
-							end: {
-								line: lineNumber,
-								column: marker.index + 2
-							}
-						},
+						loc: marker.loc,
 						messageId: "inconsistentAlignment",
 						fix(fixer) {
 							const line = getParsedLines(sourceCode).get(lineNumber);
-							if (marker.index < base.index) {
-								const addSpaces = " ".repeat(base.index - marker.index);
-								return fixer.insertTextBeforeRange([line.range[0] + marker.index, line.range[0] + marker.index], addSpaces);
+							if (indentWidth < baseIndentWidth) {
+								const addSpaces = " ".repeat(baseIndentWidth - indentWidth);
+								return fixer.insertTextBeforeRange([line.range[0] + marker.loc.start.column - 1, line.range[0] + marker.loc.start.column - 1], addSpaces);
 							}
-							if (blockquoteLevel === 1) {
-								const expectedSpaces = " ".repeat(base.index);
-								return fixer.replaceTextRange([line.range[0], line.range[0] + marker.index], expectedSpaces);
+							let newBeforeMarker = line.text.slice(0, marker.loc.start.column - 1);
+							while (getWidth(newBeforeMarker) > baseIndentWidth) {
+								const last = newBeforeMarker.at(-1);
+								if (last && isWhitespace(last)) newBeforeMarker = newBeforeMarker.slice(0, -1);
+								else return null;
 							}
-							if (line.text.slice(0, line.range[0] + marker.index).includes("	")) return null;
-							let removeStartIndex = marker.index;
-							for (; removeStartIndex > base.index; removeStartIndex--) if (line.text[removeStartIndex - 1] !== " ") break;
-							return fixer.removeRange([line.range[0] + removeStartIndex, line.range[0] + marker.index]);
+							if (getWidth(newBeforeMarker) < baseIndentWidth) newBeforeMarker += " ".repeat(baseIndentWidth - getWidth(newBeforeMarker));
+							if (!baseBeforeMarker.includes(">") || baseBeforeMarker === newBeforeMarker) return fixer.replaceTextRange([line.range[0], line.range[0] + marker.loc.start.column - 1], newBeforeMarker);
+							return null;
 						}
 					});
 				}
@@ -714,7 +783,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$2(options) {
+function parseOptions$3(options) {
 	const primary = options.primary || "-";
 	const secondary = options.secondary || getOtherMarker(primary);
 	if (primary === secondary) throw new Error(`\`primary\` and \`secondary\` cannot be the same (primary: "${primary}", secondary: "${secondary}").`);
@@ -782,7 +851,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$2(context.options[0] || {});
+		const options = parseOptions$3(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -4334,275 +4403,224 @@ var heading_casing_default = createRule("heading-casing", {
 });
 
 //#endregion
-//#region src/utils/setext-heading.ts
-/**
-* Parse the setext heading.
-*/
-function parseSetextHeading(sourceCode, node) {
-	if (getHeadingKind(sourceCode, node) !== "setext") return null;
-	const lines = getParsedLines(sourceCode);
-	const contentLines = [];
-	const nodeLoc = sourceCode.getLoc(node);
-	for (let lineNumber = nodeLoc.start.line; lineNumber < nodeLoc.end.line; lineNumber++) {
-		const content = parseContent(lines.get(lineNumber));
-		contentLines.push(content);
+//#region src/utils/character-cursor.ts
+var CharacterCursor = class {
+	text;
+	constructor(text) {
+		this.text = text;
 	}
-	const underline = parseUnderline(lines.get(nodeLoc.end.line));
-	if (!underline) return null;
-	return {
-		contentLines,
-		underline
-	};
-}
-/**
-* Parse the content line of a setext heading.
-*/
-function parseContent(line) {
-	let prefix = "";
-	let spaceBefore = "";
-	let suffix = "";
-	for (let index = 0; index < line.text.length; index++) {
-		const c = line.text[index];
-		if (!c.trim()) {
-			spaceBefore += c;
-			continue;
+	curr() {
+		return this.text[this.index];
+	}
+	currIndex() {
+		return this.index;
+	}
+	setCurrIndex(index) {
+		this.index = index;
+	}
+	isWhitespace(index) {
+		if (index >= this.text.length) return false;
+		const ch = this.text[index];
+		if (isWhitespace(ch)) return true;
+		if (ch !== ">") return false;
+		const prefix = [ch];
+		for (let prev = index - 1; prev >= 0; prev--) {
+			const prevCh$1 = this.text[prev];
+			if (prevCh$1 === "\n") break;
+			if (isSpaceOrTab(prevCh$1) || prevCh$1 === ">") {
+				prefix.unshift(prevCh$1);
+				continue;
+			}
+			return false;
 		}
-		if (c === ">" && spaceBefore.length < 4) {
-			prefix += spaceBefore + c;
-			spaceBefore = "";
-			continue;
+		let width = 0;
+		let leadingMarkerOffset = 0;
+		let prevCh;
+		for (const currCh of prefix) {
+			if (currCh === ">") {
+				if (width - leadingMarkerOffset > 3) return false;
+				leadingMarkerOffset = width + 1;
+			}
+			if (currCh === "	") width += 4 - width % 4;
+			else width++;
+			if (prevCh === ">" && isSpaceOrTab(currCh)) leadingMarkerOffset++;
+			prevCh = currCh;
 		}
-		suffix = line.text.slice(index);
-		break;
+		return true;
 	}
-	const content = suffix.trimEnd();
-	const spaceAfter = suffix.slice(content.length);
-	return {
-		text: content,
-		range: [line.range[0] + prefix.length + spaceBefore.length, line.range[1] - line.linebreak.length - spaceAfter.length],
-		loc: {
-			start: {
-				line: line.line,
-				column: prefix.length + spaceBefore.length + 1
-			},
-			end: {
-				line: line.line,
-				column: prefix.length + spaceBefore.length + content.length + 1
+};
+var ForwardCharacterCursor = class extends CharacterCursor {
+	index;
+	constructor(text) {
+		super(text);
+		this.index = 0;
+	}
+	next() {
+		this.index++;
+		return this.text[this.index];
+	}
+	finished() {
+		return this.index >= this.text.length;
+	}
+	skipSpaces() {
+		while (this.index < this.text.length && this.isWhitespace(this.index)) this.index++;
+	}
+	/**
+	* Skip until the end by the given condition
+	*/
+	skipUntilEnd(checkEnd) {
+		while (this.index < this.text.length) {
+			const c = this.text[this.index];
+			if (checkEnd(c, this.index)) return true;
+			this.index++;
+			if (c !== "\\") continue;
+			if (this.index < this.text.length && (this.text[this.index] === "\\" || checkEnd(this.text[this.index], this.index)) && !isWhitespace(this.text[this.index])) this.index++;
+		}
+		return false;
+	}
+};
+var BackwardCharacterCursor = class extends CharacterCursor {
+	index;
+	constructor(text) {
+		super(text);
+		this.index = text.length - 1;
+	}
+	prev() {
+		this.index--;
+		return this.text[this.index];
+	}
+	finished() {
+		return this.index < 0;
+	}
+	skipSpaces() {
+		while (this.index >= 0 && this.isWhitespace(this.index)) this.index--;
+	}
+	/**
+	* Skip until the start by the given condition
+	*/
+	skipUntilStart(checkStart) {
+		while (this.index >= 0) {
+			const c = this.text[this.index];
+			if (checkStart(c, this.index)) {
+				if (this.index > 1 && !isWhitespace(c)) {
+					let escapeText = "";
+					while (this.text.endsWith(`${escapeText}\\`, this.index)) escapeText += "\\";
+					if (escapeText.length % 2 === 1) {
+						this.index -= escapeText.length + 1;
+						continue;
+					}
+				}
+				return true;
 			}
-		},
-		raws: {
-			prefix,
-			spaceBefore,
-			spaceAfter
+			this.index--;
 		}
+		return false;
+	}
+};
+
+//#endregion
+//#region src/utils/link-definition.ts
+/**
+* Parse the link definition.
+*/
+function parseLinkDefinition(sourceCode, node) {
+	const text = sourceCode.getText(node);
+	const parsed = parseLinkDefinitionFromText(text);
+	if (!parsed) return null;
+	const nodeRange = sourceCode.getRange(node);
+	const labelRange = [nodeRange[0] + parsed.label.range[0], nodeRange[0] + parsed.label.range[1]];
+	const destinationRange = [nodeRange[0] + parsed.destination.range[0], nodeRange[0] + parsed.destination.range[1]];
+	return {
+		label: {
+			text: parsed.label.text,
+			range: labelRange,
+			loc: getSourceLocationFromRange(sourceCode, node, labelRange)
+		},
+		destination: {
+			type: parsed.destination.type,
+			text: parsed.destination.text,
+			range: destinationRange,
+			loc: getSourceLocationFromRange(sourceCode, node, destinationRange)
+		},
+		title: parsed.title ? {
+			type: parsed.title.type,
+			text: parsed.title.text,
+			range: [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]],
+			loc: getSourceLocationFromRange(sourceCode, node, [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]])
+		} : null
 	};
 }
 /**
-* Parse the underline of a setext heading.
+* Parse the link definition from the given text.
 */
-function parseUnderline(line) {
-	let marker = null;
-	let underlineText = "";
-	let prefix = "";
-	let spaceBefore = "";
-	let spaceAfter = "";
-	for (let index = line.text.length - 1; index >= 0; index--) {
-		const c = line.text[index];
-		if (!marker) {
-			if (c === "=" || c === "-") {
-				underlineText = c + underlineText;
-				marker = c;
-			} else if (!c.trim()) spaceAfter = c + spaceAfter;
-			else return null;
-			continue;
-		}
-		if (c === marker) {
-			underlineText = c + spaceBefore + underlineText;
-			spaceBefore = "";
-		} else if (!c.trim()) spaceBefore = c + spaceBefore;
-		else {
-			prefix = line.text.slice(0, index + 1);
-			break;
-		}
+function parseLinkDefinitionFromText(text) {
+	if (!text.startsWith("[")) return null;
+	const cursor = new ForwardCharacterCursor(text);
+	const labelStartIndex = 0;
+	cursor.next();
+	if (!cursor.skipUntilEnd((c) => c === "]")) return null;
+	cursor.next();
+	const labelRange = [labelStartIndex, cursor.currIndex()];
+	if (!text.slice(labelRange[0] + 1, labelRange[1] - 1).trim()) return null;
+	if (cursor.curr() !== ":") return null;
+	const label = {
+		text: text.slice(...labelRange),
+		range: labelRange
+	};
+	cursor.next();
+	cursor.skipSpaces();
+	let destination;
+	const destinationStartIndex = cursor.currIndex();
+	if (cursor.curr() === "<") {
+		cursor.next();
+		if (!cursor.skipUntilEnd((c) => c === ">")) return null;
+		cursor.next();
+		const destinationRange = [destinationStartIndex, cursor.currIndex()];
+		destination = {
+			type: "pointy-bracketed",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
+	} else {
+		if (cursor.finished()) return null;
+		cursor.skipUntilEnd((c, i) => cursor.isWhitespace(i) || isAsciiControlCharacter(c));
+		const destinationRange = [destinationStartIndex, cursor.currIndex()];
+		destination = {
+			type: "bare",
+			text: text.slice(...destinationRange),
+			range: destinationRange
+		};
 	}
-	if (!marker) return null;
-	const underlineLoc = {
-		start: {
-			line: line.line,
-			column: prefix.length + spaceBefore.length + 1
-		},
-		end: {
-			line: line.line,
-			column: prefix.length + spaceBefore.length + underlineText.length + 1
-		}
+	cursor.skipSpaces();
+	if (cursor.finished()) return {
+		label,
+		destination,
+		title: null
 	};
+	let title;
+	const titleStartIndex = cursor.currIndex();
+	const startChar = cursor.curr();
+	if (startChar === "'" || startChar === "\"" || startChar === "(") {
+		cursor.next();
+		const endChar = startChar === "(" ? ")" : startChar;
+		if (!cursor.skipUntilEnd((c) => c === endChar)) return null;
+		cursor.next();
+		const titleRange = [titleStartIndex, cursor.currIndex()];
+		title = {
+			type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
+			text: text.slice(...titleRange),
+			range: titleRange
+		};
+	} else return null;
+	cursor.skipSpaces();
+	if (!cursor.finished()) return null;
 	return {
-		text: underlineText,
-		range: [line.range[0] + prefix.length + spaceBefore.length, line.range[1] - line.linebreak.length - spaceAfter.length],
-		loc: underlineLoc,
-		marker,
-		raws: {
-			prefix,
-			spaceBefore,
-			spaceAfter
-		}
+		label,
+		destination,
+		title
 	};
 }
 
-//#endregion
-//#region src/rules/level1-heading-style.ts
-var level1_heading_style_default = createRule("level1-heading-style", {
-	meta: {
-		type: "layout",
-		docs: {
-			description: "enforce consistent style for level 1 headings",
-			categories: ["standard"],
-			listCategory: "Stylistic"
-		},
-		fixable: "code",
-		hasSuggestions: false,
-		schema: [{
-			type: "object",
-			properties: {
-				style: { enum: ["atx", "setext"] },
-				allowMultilineSetext: { type: "boolean" }
-			},
-			additionalProperties: false
-		}],
-		messages: {
-			expectedAtx: "Expected ATX style heading (# Heading).",
-			expectedSetext: "Expected Setext style heading (Heading\\n======).",
-			multilineSetextNotAllowed: "Multiline Setext headings are not allowed."
-		}
-	},
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const opt = context.options[0] || {};
-		const style = opt.style ?? "atx";
-		const allowMultilineSetext = opt.allowMultilineSetext;
-		return { heading(node) {
-			if (node.depth !== 1) return;
-			const headingKind = getHeadingKind(sourceCode, node);
-			if (style === "atx") {
-				if (headingKind !== "setext") return;
-				const parsed = parseSetextHeading(sourceCode, node);
-				if (!parsed) return;
-				if (parsed.contentLines.length > 1) {
-					if (allowMultilineSetext) return;
-					context.report({
-						node,
-						messageId: "multilineSetextNotAllowed"
-					});
-					return;
-				}
-				context.report({
-					node,
-					messageId: "expectedAtx",
-					*fix(fixer) {
-						const heading = parsed.contentLines[0];
-						yield fixer.insertTextBeforeRange(heading.range, "# ");
-						const lines = getParsedLines(sourceCode);
-						yield fixer.removeRange(lines.get(parsed.underline.loc.start.line).range);
-					}
-				});
-			} else if (style === "setext") {
-				if (headingKind !== "atx" || node.children.length === 0) return;
-				context.report({
-					node,
-					messageId: "expectedSetext",
-					*fix(fixer) {
-						const parsed = parseATXHeading(sourceCode, node);
-						if (!parsed) return;
-						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.content.range[0]]);
-						if (parsed.closingSequence) yield fixer.removeRange([parsed.content.range[1], parsed.after?.range[1] ?? parsed.closingSequence.range[1]]);
-						const lines = getParsedLines(sourceCode);
-						const underline = "=".repeat(Math.max(getTextWidth(parsed.content.text), 3));
-						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
-						yield fixer.insertTextAfter(node, appendingText);
-					}
-				});
-			}
-		} };
-	}
-});
-
-//#endregion
-//#region src/rules/level2-heading-style.ts
-var level2_heading_style_default = createRule("level2-heading-style", {
-	meta: {
-		type: "layout",
-		docs: {
-			description: "enforce consistent style for level 2 headings",
-			categories: ["standard"],
-			listCategory: "Stylistic"
-		},
-		fixable: "code",
-		hasSuggestions: false,
-		schema: [{
-			type: "object",
-			properties: {
-				style: { enum: ["atx", "setext"] },
-				allowMultilineSetext: { type: "boolean" }
-			},
-			additionalProperties: false
-		}],
-		messages: {
-			expectedAtx: "Expected ATX style heading (## Heading).",
-			expectedSetext: "Expected Setext style heading (Heading\\n------).",
-			multilineSetextNotAllowed: "Multiline Setext headings are not allowed."
-		}
-	},
-	create(context) {
-		const sourceCode = context.sourceCode;
-		const opt = context.options[0] || {};
-		const style = opt.style ?? "atx";
-		const allowMultilineSetext = opt.allowMultilineSetext;
-		return { heading(node) {
-			if (node.depth !== 2) return;
-			const headingKind = getHeadingKind(sourceCode, node);
-			if (style === "atx") {
-				if (headingKind !== "setext") return;
-				const parsed = parseSetextHeading(sourceCode, node);
-				if (!parsed) return;
-				if (parsed.contentLines.length > 1) {
-					if (allowMultilineSetext) return;
-					context.report({
-						node,
-						messageId: "multilineSetextNotAllowed"
-					});
-					return;
-				}
-				context.report({
-					node,
-					messageId: "expectedAtx",
-					*fix(fixer) {
-						const heading = parsed.contentLines[0];
-						yield fixer.insertTextBeforeRange(heading.range, "## ");
-						const lines = getParsedLines(sourceCode);
-						yield fixer.removeRange(lines.get(parsed.underline.loc.start.line).range);
-					}
-				});
-			} else if (style === "setext") {
-				if (headingKind !== "atx" || node.children.length === 0) return;
-				context.report({
-					node,
-					messageId: "expectedSetext",
-					*fix(fixer) {
-						const parsed = parseATXHeading(sourceCode, node);
-						if (!parsed) return;
-						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.content.range[0]]);
-						if (parsed.closingSequence) yield fixer.removeRange([parsed.content.range[1], parsed.after?.range[1] ?? parsed.closingSequence.range[1]]);
-						const lines = getParsedLines(sourceCode);
-						const underline = "-".repeat(Math.max(getTextWidth(parsed.content.text), 3));
-						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
-						yield fixer.insertTextAfter(node, appendingText);
-					}
-				});
-			}
-		} };
-	}
-});
-
 //#endregion
 //#region src/utils/link.ts
 /**
@@ -4653,92 +4671,73 @@ function parseInlineLink(sourceCode, node) {
 * Parse the inline link destination and link title from the given text.
 */
 function parseInlineLinkDestAndTitleFromText(text) {
-	let index = 0;
-	if (text[index] !== "(") return null;
-	index++;
-	skipSpaces();
+	if (!text.startsWith("(")) return null;
+	const cursor = new ForwardCharacterCursor(text);
+	cursor.next();
+	cursor.skipSpaces();
 	let destination;
-	const destinationStartIndex = index;
-	if (text[index] === "<") {
-		index++;
-		if (!skipUntilEnd((c) => c === ">")) return null;
-		index++;
-		const destinationRange = [destinationStartIndex, index];
+	const destinationStartIndex = cursor.currIndex();
+	if (cursor.curr() === "<") {
+		cursor.next();
+		if (!cursor.skipUntilEnd((c) => c === ">")) return null;
+		cursor.next();
+		const destinationRange = [destinationStartIndex, cursor.currIndex()];
 		destination = {
 			type: "pointy-bracketed",
 			text: text.slice(...destinationRange),
 			range: destinationRange
 		};
 	} else {
-		if (text.length <= index) return null;
-		skipUntilEnd((c) => isWhitespace(c) || isAsciiControlCharacter(c) || c === ")");
-		const destinationRange = [destinationStartIndex, index];
+		if (cursor.finished()) return null;
+		cursor.skipUntilEnd((c, i) => cursor.isWhitespace(i) || isAsciiControlCharacter(c) || c === ")");
+		const destinationRange = [destinationStartIndex, cursor.currIndex()];
 		destination = {
 			type: "bare",
 			text: text.slice(...destinationRange),
 			range: destinationRange
 		};
 	}
-	skipSpaces();
-	if (text[index] === ")") {
-		const closingParenStartIndex$1 = index;
-		index++;
-		skipSpaces();
-		if (index < text.length) return null;
+	cursor.skipSpaces();
+	if (cursor.curr() === ")") {
+		const closingParenStartIndex$1 = cursor.currIndex();
+		cursor.next();
+		cursor.skipSpaces();
+		if (!cursor.finished()) return null;
 		return {
 			openingParen: { range: [0, 1] },
 			destination,
 			title: null,
-			closingParen: { range: [closingParenStartIndex$1, index] }
+			closingParen: { range: [closingParenStartIndex$1, closingParenStartIndex$1 + 1] }
 		};
 	}
-	if (text.length <= index) return null;
+	if (cursor.finished()) return null;
 	let title;
-	const titleStartIndex = index;
-	const startChar = text[index];
+	const titleStartIndex = cursor.currIndex();
+	const startChar = cursor.curr();
 	if (startChar === "'" || startChar === "\"" || startChar === "(") {
-		index++;
+		cursor.next();
 		const endChar = startChar === "(" ? ")" : startChar;
-		if (!skipUntilEnd((c) => c === endChar)) return null;
-		index++;
-		const titleRange = [titleStartIndex, index];
+		if (!cursor.skipUntilEnd((c) => c === endChar)) return null;
+		cursor.next();
+		const titleRange = [titleStartIndex, cursor.currIndex()];
 		title = {
 			type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
 			text: text.slice(...titleRange),
 			range: titleRange
 		};
 	} else return null;
-	skipSpaces();
-	if (text[index] !== ")") return null;
-	const closingParenStartIndex = index;
-	index++;
-	skipSpaces();
-	if (index < text.length) return null;
+	cursor.skipSpaces();
+	if (cursor.curr() !== ")") return null;
+	const closingParenStartIndex = cursor.currIndex();
+	cursor.next();
+	cursor.skipSpaces();
+	if (!cursor.finished()) return null;
 	return {
 		openingParen: { range: [0, 1] },
 		destination,
 		title,
-		closingParen: { range: [closingParenStartIndex, index] }
+		closingParen: { range: [closingParenStartIndex, closingParenStartIndex + 1] }
 	};
-	/**
-	* Skip spaces
-	*/
-	function skipSpaces() {
-		while (index < text.length && isWhitespace(text[index])) index++;
-	}
-	/**
-	* Skip until the end by the given condition
-	*/
-	function skipUntilEnd(checkEnd) {
-		while (index < text.length) {
-			const c = text[index];
-			if (checkEnd(c)) return true;
-			index++;
-			if (c !== "\\") continue;
-			if (index < text.length && (text[index] === "\\" || checkEnd(text[index])) && !isWhitespace(text[index])) index++;
-		}
-		return false;
-	}
 }
 
 //#endregion
@@ -4845,58 +4844,57 @@ function parseImage(sourceCode, node) {
 */
 function parseImageFromText(text) {
 	if (!text.startsWith("![")) return null;
-	let index = text.length - 1;
-	skipSpaces();
-	if (text[index] !== ")") return null;
-	const closingParenStartIndex = index;
-	index--;
-	skipSpaces();
+	const cursor = new BackwardCharacterCursor(text);
+	cursor.skipSpaces();
+	if (cursor.curr() !== ")") return null;
+	const closingParenStartIndex = cursor.currIndex();
+	cursor.prev();
+	cursor.skipSpaces();
 	let title = null;
-	const titleEndIndex = index + 1;
-	const endChar = text[index];
+	const titleEndIndex = cursor.currIndex() + 1;
+	const endChar = cursor.curr();
 	if (endChar === "'" || endChar === "\"" || endChar === ")") {
-		index--;
+		cursor.prev();
 		const startChar = endChar === ")" ? "(" : endChar;
-		if (skipUntilStart((c) => c === startChar)) {
-			const titleRange = [index, titleEndIndex];
-			index--;
+		if (cursor.skipUntilStart((c) => c === startChar)) {
+			const titleRange = [cursor.currIndex(), titleEndIndex];
+			cursor.prev();
 			title = {
 				type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
 				text: text.slice(...titleRange),
 				range: titleRange
 			};
-			skipSpaces();
+			cursor.skipSpaces();
 		}
 	}
-	if (title == null) index = titleEndIndex - 1;
+	if (title == null) cursor.setCurrIndex(titleEndIndex - 1);
 	let destination;
-	const destinationEndIndex = index + 1;
-	if (text[index] === ">") {
-		index--;
-		if (!skipUntilStart((c) => c === "<")) return null;
-		const destinationRange = [index, destinationEndIndex];
-		index--;
+	const destinationEndIndex = cursor.currIndex() + 1;
+	if (cursor.curr() === ">") {
+		cursor.prev();
+		if (!cursor.skipUntilStart((c) => c === "<")) return null;
+		const destinationRange = [cursor.currIndex(), destinationEndIndex];
+		cursor.prev();
 		destination = {
 			type: "pointy-bracketed",
 			text: text.slice(...destinationRange),
 			range: destinationRange
 		};
 	} else {
-		if (text.length <= index) return null;
-		skipUntilStart((c) => isWhitespace(c) || isAsciiControlCharacter(c) || c === "(");
-		const destinationRange = [index + 1, destinationEndIndex];
+		if (cursor.finished()) return null;
+		cursor.skipUntilStart((c, i) => cursor.isWhitespace(i) || isAsciiControlCharacter(c) || c === "(");
+		const destinationRange = [cursor.currIndex() + 1, destinationEndIndex];
 		destination = {
 			type: "bare",
 			text: text.slice(...destinationRange),
 			range: destinationRange
 		};
 	}
-	skipSpaces();
-	if (text[index] !== "(") return null;
-	const openingParenStartIndex = index;
-	index--;
-	if (text[index] !== "]") return null;
-	const textRange = [1, index + 1];
+	cursor.skipSpaces();
+	if (cursor.curr() !== "(") return null;
+	const openingParenStartIndex = cursor.currIndex();
+	if (cursor.prev() !== "]") return null;
+	const textRange = [1, cursor.currIndex() + 1];
 	return {
 		openingParen: { range: [openingParenStartIndex, openingParenStartIndex + 1] },
 		text: { range: textRange },
@@ -4904,33 +4902,6 @@ function parseImageFromText(text) {
 		title,
 		closingParen: { range: [closingParenStartIndex, closingParenStartIndex + 1] }
 	};
-	/**
-	* Skip spaces
-	*/
-	function skipSpaces() {
-		while (index >= 0 && isWhitespace(text[index])) index--;
-	}
-	/**
-	* Skip until the start by the given condition
-	*/
-	function skipUntilStart(checkStart) {
-		while (index >= 0) {
-			const c = text[index];
-			if (checkStart(c)) {
-				if (index > 1 && !isWhitespace(c)) {
-					let escapeText = "";
-					while (text.endsWith(`${escapeText}\\`, index)) escapeText += "\\";
-					if (escapeText.length % 2 === 1) {
-						index -= escapeText.length + 1;
-						continue;
-					}
-				}
-				return true;
-			}
-			index--;
-		}
-		return false;
-	}
 }
 
 //#endregion
@@ -4990,21 +4961,20 @@ function parseImageReference(sourceCode, node) {
 */
 function parseFullImageReferenceFromText(text) {
 	if (!text.startsWith("![")) return null;
-	let index = text.length - 1;
-	skipSpaces();
-	if (text[index] !== "]") return null;
-	const labelEndIndex = index + 1;
-	index--;
-	skipSpaces();
-	if (!skipUntilStart((c) => c === "[")) return null;
-	const labelRange = [index, labelEndIndex];
-	index--;
+	const cursor = new BackwardCharacterCursor(text);
+	cursor.skipSpaces();
+	if (cursor.curr() !== "]") return null;
+	const labelEndIndex = cursor.currIndex() + 1;
+	cursor.prev();
+	cursor.skipSpaces();
+	if (!cursor.skipUntilStart((c) => c === "[")) return null;
+	const labelRange = [cursor.currIndex(), labelEndIndex];
 	const label = {
 		text: text.slice(...labelRange),
 		range: labelRange
 	};
-	if (text[index] !== "]") return null;
-	const textRange = [1, index + 1];
+	if (cursor.prev() !== "]") return null;
+	const textRange = [1, cursor.currIndex() + 1];
 	return {
 		text: {
 			text: text.slice(...textRange),
@@ -5012,156 +4982,1208 @@ function parseFullImageReferenceFromText(text) {
 		},
 		label
 	};
-	/**
-	* Skip spaces
-	*/
-	function skipSpaces() {
-		while (index >= 0 && isWhitespace(text[index])) index--;
-	}
-	/**
-	* Skip until the start by the given condition
-	*/
-	function skipUntilStart(checkStart) {
-		while (index >= 0) {
-			const c = text[index];
-			if (checkStart(c)) {
-				if (index > 1) {
-					let escapeText = "";
-					while (text.endsWith(`${escapeText}\\`, index)) escapeText += "\\";
-					if (escapeText.length % 2 === 1) {
-						index -= escapeText.length + 1;
-						continue;
-					}
-				}
-				return true;
-			}
-			index--;
-		}
-		return false;
-	}
 }
 
 //#endregion
-//#region src/utils/link-definition.ts
+//#region src/utils/list-item.ts
 /**
-* Parse the link definition.
+* Parse the list item.
 */
-function parseLinkDefinition(sourceCode, node) {
-	const text = sourceCode.getText(node);
-	const parsed = parseLinkDefinitionFromText(text);
-	if (!parsed) return null;
+function parseListItem(sourceCode, node) {
+	const marker = getListItemMarker(sourceCode, node);
 	const nodeRange = sourceCode.getRange(node);
-	const labelRange = [nodeRange[0] + parsed.label.range[0], nodeRange[0] + parsed.label.range[1]];
-	const destinationRange = [nodeRange[0] + parsed.destination.range[0], nodeRange[0] + parsed.destination.range[1]];
+	const markerRange = [nodeRange[0], nodeRange[0] + marker.raw.length];
+	const parsedMarker = marker.kind === "." || marker.kind === ")" ? {
+		kind: marker.kind,
+		text: marker.raw,
+		value: marker.sequence.value,
+		range: markerRange,
+		loc: getSourceLocationFromRange(sourceCode, node, markerRange)
+	} : {
+		kind: marker.kind,
+		text: marker.raw,
+		range: markerRange,
+		loc: getSourceLocationFromRange(sourceCode, node, markerRange)
+	};
+	if (node.checked == null) return {
+		marker: parsedMarker,
+		taskListItemMarker: null
+	};
+	for (let index = nodeRange[0] + marker.raw.length; index < nodeRange[1]; index++) {
+		const c = sourceCode.text[index];
+		if (isSpaceOrTab(c)) continue;
+		if (c !== "[") break;
+		const middle = sourceCode.text[index + 1];
+		if (middle !== "x" && middle !== " ") break;
+		if (sourceCode.text[index + 2] !== "]") break;
+		const taskListItemMarkerRange = [index, index + 3];
+		return {
+			marker: parsedMarker,
+			taskListItemMarker: {
+				text: sourceCode.text.slice(...taskListItemMarkerRange),
+				range: taskListItemMarkerRange,
+				loc: getSourceLocationFromRange(sourceCode, node, taskListItemMarkerRange)
+			}
+		};
+	}
 	return {
-		label: {
-			text: parsed.label.text,
-			range: labelRange,
-			loc: getSourceLocationFromRange(sourceCode, node, labelRange)
-		},
-		destination: {
-			type: parsed.destination.type,
-			text: parsed.destination.text,
-			range: destinationRange,
-			loc: getSourceLocationFromRange(sourceCode, node, destinationRange)
+		marker: parsedMarker,
+		taskListItemMarker: null
+	};
+}
+
+//#endregion
+//#region src/rules/indent.ts
+/**
+* Parse options.
+*/
+function parseOptions$2(options) {
+	const listItems = options?.listItems;
+	return { listItems: {
+		first: listItems?.first ?? 1,
+		other: listItems?.other ?? "first",
+		relativeTo: listItems?.relativeTo ?? "taskListMarkerEnd"
+	} };
+}
+var indent_default = createRule("indent", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent indentation in Markdown files",
+			categories: ["standard"],
+			listCategory: "Stylistic"
 		},
-		title: parsed.title ? {
-			type: parsed.title.type,
-			text: parsed.title.text,
-			range: [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]],
-			loc: getSourceLocationFromRange(sourceCode, node, [nodeRange[0] + parsed.title.range[0], nodeRange[0] + parsed.title.range[1]])
-		} : null
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: { listItems: {
+				type: "object",
+				properties: {
+					first: { anyOf: [{ const: "ignore" }, {
+						type: "number",
+						minimum: 1
+					}] },
+					other: { anyOf: [{ enum: ["first", "minimum"] }, {
+						type: "number",
+						minimum: 1
+					}] },
+					relativeTo: { enum: [
+						"markerStart",
+						"markerEnd",
+						"taskListMarkerStart",
+						"taskListMarkerEnd"
+					] }
+				},
+				additionalProperties: false
+			} },
+			additionalProperties: false
+		}],
+		messages: {
+			wrongIndentation: "Expected indentation of {{expected}} but found {{actual}}.",
+			wrongIndentationFromBlockquoteMarker: "Expected indentation of {{expected}} from the blockquote marker but found {{actual}}.",
+			wrongIndentationFromListMarker: "Expected indentation of {{expected}} from the list marker but found {{actual}}.",
+			wrongIndentationWithTab: "Expected indentation of {{expected}} but found {{actual}} (tab width is 4).",
+			wrongIndentationFromBlockquoteMarkerWithTab: "Expected indentation of {{expected}} from the blockquote marker but found {{actual}} (tab width is 4).",
+			wrongIndentationFromListMarkerWithTab: "Expected indentation of {{expected}} from the list marker but found {{actual}} (tab width is 4)."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions$2(context.options[0]);
+		class AbsBlockStack {
+			violations = [];
+			getCurrentBlockquote() {
+				let block = this;
+				while (block) {
+					if (block.type === "blockquote") return block;
+					block = block.upper;
+				}
+				return null;
+			}
+			getCurrentListItemAtLine(lineNumber) {
+				let block = this;
+				while (block) {
+					if (block.type === "blockquote") return null;
+					if (block.type === "listItem") {
+						if (sourceCode.getLoc(block.node).start.line === lineNumber) return block;
+					}
+					block = block.upper;
+				}
+				return null;
+			}
+		}
+		class RootStack extends AbsBlockStack {
+			type = "root";
+			node;
+			upper = null;
+			constructor(node) {
+				super();
+				this.node = node;
+			}
+			getExpectedIndent() {
+				return 0;
+			}
+		}
+		class BlockquoteStack extends AbsBlockStack {
+			type = "blockquote";
+			node;
+			upper;
+			_expectedIndent;
+			_markerIndent;
+			constructor(node) {
+				super();
+				this.node = node;
+				this.upper = blockStack;
+			}
+			getExpectedIndent() {
+				if (this._expectedIndent == null) this._expectedIndent = this.getMarkerIndent() + 1 + 1;
+				return this._expectedIndent;
+			}
+			getMarkerIndent() {
+				if (this._markerIndent == null) {
+					const loc = sourceCode.getLoc(this.node);
+					this._markerIndent = getWidth(sourceCode.lines[loc.start.line - 1].slice(0, loc.start.column - 1));
+				}
+				return this._markerIndent;
+			}
+		}
+		class ListItemStack extends AbsBlockStack {
+			type = "listItem";
+			node;
+			upper;
+			_expectedIndentForFirstLine;
+			_expectedIndentForOtherLines;
+			_parsed;
+			nodeLoc;
+			constructor(node) {
+				super();
+				this.node = node;
+				this.upper = blockStack;
+				this.nodeLoc = sourceCode.getLoc(this.node);
+			}
+			getParsedListItem() {
+				return this._parsed ??= parseListItem(sourceCode, this.node);
+			}
+			getExpectedIndent({ lineNumber, block }) {
+				const loc = this.nodeLoc;
+				if (lineNumber === loc.start.line) return this.getExpectedIndentForFirstLine();
+				const expected = this.getExpectedIndentAfterFirstLine();
+				if (expected === "ignore") return "ignore";
+				if (!block) return expected;
+				const actualFirstLineIndent = this.getActualFirstLineIndent({ withoutTaskListMarker: true });
+				if (actualFirstLineIndent != null) return Math.min(expected, actualFirstLineIndent + 3);
+				return expected;
+			}
+			getExpectedIndentForFirstLine() {
+				if (options.listItems.first === "ignore") return "ignore";
+				if (this._expectedIndentForFirstLine != null) return this._expectedIndentForFirstLine;
+				const loc = this.nodeLoc;
+				const parsed = this.getParsedListItem();
+				const lineText = sourceCode.lines[loc.start.line - 1];
+				if (options.listItems.relativeTo === "markerStart") {
+					const baseIndent = getWidth(lineText.slice(0, loc.start.column - 1));
+					return this._expectedIndentForFirstLine = Math.max(baseIndent + options.listItems.first, baseIndent + parsed.marker.text.length + 1);
+				}
+				if (options.listItems.relativeTo === "taskListMarkerEnd" && parsed.taskListItemMarker) return this._expectedIndentForFirstLine = getWidth(lineText.slice(0, parsed.taskListItemMarker.loc.end.column - 1)) + options.listItems.first;
+				return this._expectedIndentForFirstLine = getWidth(lineText.slice(0, parsed.marker.loc.end.column - 1)) + options.listItems.first;
+			}
+			getExpectedIndentAfterFirstLine() {
+				if (this._expectedIndentForOtherLines != null) return this._expectedIndentForOtherLines;
+				const loc = this.nodeLoc;
+				if (options.listItems.other === "first") {
+					const firstLineIndent = this.getExpectedIndentForFirstLine();
+					if (firstLineIndent === "ignore") {
+						const actualFirstLineIndent = this.getActualFirstLineIndent();
+						if (actualFirstLineIndent != null) return this._expectedIndentForOtherLines = actualFirstLineIndent;
+						for (const child of this.node.children) {
+							const childLoc = sourceCode.getLoc(child);
+							if (loc.start.line < childLoc.start.line) return this._expectedIndentForOtherLines = getWidth(sourceCode.lines[childLoc.start.line - 1].slice(0, childLoc.start.column - 1));
+						}
+					}
+					return this._expectedIndentForOtherLines = firstLineIndent;
+				}
+				if (options.listItems.other === "minimum") return this._expectedIndentForOtherLines = this.getMinimumLineIndent();
+				const lineText = sourceCode.lines[loc.start.line - 1];
+				if (options.listItems.relativeTo === "markerStart") {
+					const baseIndent = getWidth(lineText.slice(0, loc.start.column - 1));
+					const minimumLineIndent = this.getMinimumLineIndent();
+					return this._expectedIndentForOtherLines = Math.max(baseIndent + options.listItems.other, minimumLineIndent);
+				}
+				const parsed = this.getParsedListItem();
+				if (options.listItems.relativeTo === "taskListMarkerEnd" && parsed.taskListItemMarker) return this._expectedIndentForOtherLines = getWidth(lineText.slice(0, parsed.taskListItemMarker.loc.end.column - 1)) + options.listItems.other;
+				return this._expectedIndentForOtherLines = getWidth(lineText.slice(0, parsed.marker.loc.end.column - 1)) + options.listItems.other;
+			}
+			getMinimumLineIndent() {
+				const actualFirstLineIndent = this.getActualFirstLineIndent({ withoutTaskListMarker: true });
+				if (actualFirstLineIndent != null) return this._expectedIndentForOtherLines = actualFirstLineIndent;
+				const parsed = this.getParsedListItem();
+				const lineText = sourceCode.lines[parsed.marker.loc.end.line - 1];
+				return getWidth(lineText.slice(0, parsed.marker.loc.end.column - 1)) + 1;
+			}
+			getActualFirstLineIndent({ withoutTaskListMarker = false } = {}) {
+				const parsed = this.getParsedListItem();
+				const markerEndPos = withoutTaskListMarker ? parsed.marker.loc.end : parsed.taskListItemMarker?.loc.end ?? parsed.marker.loc.end;
+				const lineText = sourceCode.lines[markerEndPos.line - 1];
+				const afterMarkerText = lineText.slice(markerEndPos.column - 1);
+				const trimmedAfterMarkerText = afterMarkerText.trimStart();
+				if (trimmedAfterMarkerText) {
+					const afterMarkerSpacesLength = afterMarkerText.length - trimmedAfterMarkerText.length;
+					return getWidth(lineText.slice(0, markerEndPos.column - 1 + afterMarkerSpacesLength));
+				}
+				return null;
+			}
+		}
+		class FootnoteDefinitionStack extends AbsBlockStack {
+			type = "footnoteDefinition";
+			node;
+			upper;
+			_expectedIndent;
+			constructor(node) {
+				super();
+				this.node = node;
+				this.upper = blockStack;
+			}
+			getExpectedIndent() {
+				if (this._expectedIndent == null) {
+					const loc = sourceCode.getLoc(this.node);
+					this._expectedIndent = getWidth(sourceCode.lines[loc.start.line - 1].slice(0, loc.start.column - 1)) + 4;
+				}
+				return this._expectedIndent;
+			}
+		}
+		class LinkStack extends AbsBlockStack {
+			type = "link";
+			node;
+			upper;
+			nodeLoc;
+			constructor(node) {
+				super();
+				this.node = node;
+				this.upper = blockStack;
+				this.nodeLoc = sourceCode.getLoc(this.node);
+			}
+			getExpectedIndent(ctx) {
+				const loc = this.nodeLoc;
+				if (ctx.lineNumber === loc.start.line) return this.upper.getExpectedIndent(ctx);
+				const base = this.upper.getExpectedIndent({
+					lineNumber: loc.start.line,
+					block: ctx.block
+				});
+				if (base === "ignore") return "ignore";
+				return base + 2;
+			}
+		}
+		let blockStack = new RootStack(sourceCode.ast);
+		const reportedLocations = Object.create(null);
+		/**
+		* Reported locations (line and column) to avoid duplicate reports.
+		*/
+		function reportIncorrectIndent(violation) {
+			const reportedColumns = reportedLocations[violation.loc.start.line] ??= /* @__PURE__ */ new Set();
+			if (reportedColumns.has(violation.loc.start.column)) return;
+			reportedColumns.add(violation.loc.start.column);
+			blockStack.violations.push(violation);
+		}
+		/**
+		* Flush violations to the context.
+		*/
+		function flushViolations({ violations }) {
+			for (const violation of violations) context.report({
+				loc: violation.loc,
+				messageId: violation.messageId,
+				data: {
+					expected: String(violation.data.expected),
+					actual: String(violation.data.actual)
+				},
+				fix(fixer) {
+					const result = [];
+					for (const { fix } of violations) result.push(...fix(fixer));
+					return result;
+				}
+			});
+		}
+		return {
+			thematicBreak: verifyThematicBreak,
+			heading: verifyHeading,
+			code: verifyCodeBlock,
+			html: verifyHtml,
+			definition: verifyLinkDefinition,
+			table: verifyTable,
+			list: verifyList,
+			inlineCode: verifyInlineCode,
+			emphasis: verifyEmphasisOrStrongOrDelete,
+			strong: verifyEmphasisOrStrongOrDelete,
+			delete: verifyEmphasisOrStrongOrDelete,
+			image: verifyImage,
+			imageReference: verifyImageReference,
+			footnoteReference: verifyInline,
+			break: verifyInline,
+			text: verifyText,
+			blockquote(node) {
+				verifyBlockquote(node);
+				blockStack = new BlockquoteStack(node);
+			},
+			listItem(node) {
+				blockStack = new ListItemStack(node);
+			},
+			footnoteDefinition(node) {
+				verifyFootnoteDefinition(node);
+				blockStack = new FootnoteDefinitionStack(node);
+			},
+			link(node) {
+				verifyLink(node);
+				blockStack = new LinkStack(node);
+			},
+			linkReference(node) {
+				verifyLinkReference(node);
+				blockStack = new LinkStack(node);
+			},
+			"blockquote, listItem, footnoteDefinition, link, linkReference:exit"() {
+				flushViolations(blockStack);
+				blockStack = blockStack.upper;
+			},
+			"root:exit"() {
+				flushViolations(blockStack);
+			}
+		};
+		/**
+		* Verify a thematic break node.
+		*/
+		function verifyThematicBreak(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a heading node.
+		*/
+		function verifyHeading(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a code block node.
+		*/
+		function verifyCodeBlock(node) {
+			if (getCodeBlockKind(sourceCode, node) === "indented") return;
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent([loc.start.line, loc.end.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}), additionalFixes);
+			/**
+			* Additional fixes for code block content lines.
+			*/
+			function* additionalFixes(fixer, info) {
+				if (info.loc.start.line !== loc.start.line) return;
+				for (let lineNumber = loc.start.line + 1; lineNumber < loc.end.line; lineNumber++) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) continue;
+					if (info.expectedIndentWidth > info.actualIndentWidth) {
+						const before = sliceWidth(line.text, 0, info.actualIndentWidth);
+						const after = sliceWidth(line.text, info.actualIndentWidth);
+						const diffWidth = info.expectedIndentWidth - info.actualIndentWidth;
+						yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + " ".repeat(diffWidth) + after);
+					} else {
+						let before = sliceWidth(line.text, 0, info.expectedIndentWidth);
+						let between = sliceWidth(line.text, info.expectedIndentWidth, info.actualIndentWidth);
+						const after = sliceWidth(line.text, info.actualIndentWidth);
+						while (between && !isSpaceOrTab(between)) {
+							before += between[0];
+							between = between.slice(1);
+						}
+						yield fixer.replaceTextRange([line.range[0], line.range[0] + line.text.length], before + after);
+					}
+				}
+			}
+		}
+		/**
+		* Verify an HTML node.
+		*/
+		function verifyHtml(node) {
+			const loc = sourceCode.getLoc(node);
+			if (!inlineToBeChecked(loc.start)) return;
+			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a link definition node.
+		*/
+		function verifyLinkDefinition(node) {
+			const parsed = parseLinkDefinition(sourceCode, node);
+			if (!parsed) return;
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber, column) => {
+				const baseIndent = blockStack.getExpectedIndent({
+					lineNumber,
+					block: true
+				});
+				if (baseIndent === "ignore") return "ignore";
+				if (lineNumber <= loc.start.line) return baseIndent;
+				if (lineNumber < parsed.label.loc.end.line) return baseIndent + 2;
+				if (lineNumber === parsed.label.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.label.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent : baseIndent + 2;
+				}
+				if (lineNumber <= parsed.destination.loc.end.line) return baseIndent + 4;
+				if (!parsed.title) return baseIndent;
+				if (lineNumber <= parsed.title.loc.start.line) return baseIndent + 4;
+				if (lineNumber < parsed.title.loc.end.line) return baseIndent + 6;
+				if (lineNumber === parsed.title.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.title.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent + 4 : baseIndent + 6;
+				}
+				return baseIndent;
+			});
+		}
+		/**
+		* Verify a blockquote node.
+		*/
+		function verifyBlockquote(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a table node.
+		*/
+		function verifyTable(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent(lineNumbersFromRange(loc.start.line, loc.end.line), (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify a list node.
+		*/
+		function verifyList(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}), additionalFixes);
+			/**
+			* Additional fixes for list item lines.
+			*/
+			function* additionalFixes(fixer, info) {
+				const [firstItem, ...otherItems] = node.children;
+				yield* fixAfterFirstLine(firstItem, info.actualIndentWidth);
+				for (const listItem of otherItems) {
+					const listItemLoc = sourceCode.getLoc(listItem);
+					const listItemIndentWidth = getWidth(sourceCode.lines[listItemLoc.start.line - 1].slice(0, listItemLoc.start.column - 1));
+					if (listItemIndentWidth === info.expectedIndentWidth) continue;
+					yield getFixForLine(listItemLoc.start.line, listItemIndentWidth);
+					yield* fixAfterFirstLine(listItem, listItemIndentWidth);
+				}
+				/**
+				* Get fixes for lines after the first line of the list item.
+				*/
+				function* fixAfterFirstLine(item, actualIndentWidth) {
+					const itemLoc = sourceCode.getLoc(item);
+					for (let lineNumber = itemLoc.start.line + 1; lineNumber <= itemLoc.end.line; lineNumber++) yield getFixForLine(lineNumber, actualIndentWidth);
+				}
+				/**
+				* Get a fix for a line.
+				*/
+				function getFixForLine(lineNumber, actualIndentWidth) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (info.expectedIndentWidth > actualIndentWidth) {
+						const before$1 = sliceWidth(line.text, 0, actualIndentWidth);
+						const diffWidth = info.expectedIndentWidth - actualIndentWidth;
+						return fixer.insertTextAfterRange([line.range[0], line.range[0] + before$1.length], " ".repeat(diffWidth));
+					}
+					let before = sliceWidth(line.text, 0, info.expectedIndentWidth);
+					let between = sliceWidth(line.text, info.expectedIndentWidth, actualIndentWidth);
+					while (between && !isSpaceOrTab(between)) {
+						before += between[0];
+						between = between.slice(1);
+					}
+					return fixer.replaceTextRange([line.range[0], line.range[0] + before.length + between.length], before);
+				}
+			}
+		}
+		/**
+		* Verify a footnote definition node.
+		*/
+		function verifyFootnoteDefinition(node) {
+			const loc = sourceCode.getLoc(node);
+			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: true
+			}));
+		}
+		/**
+		* Verify an inline code node.
+		*/
+		function verifyInlineCode(node) {
+			const loc = sourceCode.getLoc(node);
+			if (!inlineToBeChecked(loc.start)) return;
+			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: false
+			}));
+		}
+		/**
+		* Verify an emphasis, strong, or delete node.
+		*/
+		function verifyEmphasisOrStrongOrDelete(node) {
+			const loc = sourceCode.getLoc(node);
+			if (!inlineToBeChecked(loc.start)) return;
+			verifyLinesIndent([loc.start.line], (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: false
+			}));
+		}
+		/**
+		* Verify a link node.
+		*/
+		function verifyLink(node) {
+			const loc = sourceCode.getLoc(node);
+			let lines = lineNumbersFromRange(loc.start.line, loc.end.line);
+			if (!inlineToBeChecked(loc.start)) lines = lines.slice(1);
+			const kind = getLinkKind(sourceCode, node);
+			if (kind === "autolink" || kind === "gfm-autolink") verifyLinesIndent(lines, (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: false
+			}));
+			else if (kind === "inline") {
+				const parsed = parseInlineLink(sourceCode, node);
+				if (!parsed) return;
+				const lastChild = node.children.at(-1);
+				if (lastChild && parsed.text.loc.start.line < parsed.text.loc.end.line) {
+					const lastChildLoc = sourceCode.getLoc(lastChild);
+					const lastChildEndLine = lastChild.type === "text" && lastChild.value.endsWith("\n") ? lastChildLoc.end.line - 1 : lastChildLoc.end.line;
+					lines = lines.filter((lineNumber) => lineNumber <= parsed.text.loc.start.line || lastChildEndLine < lineNumber);
+				}
+				verifyLinesIndent(lines, (lineNumber, column) => {
+					const baseIndent = blockStack.getExpectedIndent({
+						lineNumber,
+						block: false
+					});
+					if (baseIndent === "ignore") return "ignore";
+					if (lineNumber <= loc.start.line) return baseIndent;
+					if (lineNumber < parsed.text.loc.end.line) return baseIndent + 2;
+					if (lineNumber <= parsed.openingParen.loc.end.line) return baseIndent;
+					if (lineNumber <= parsed.destination.loc.end.line) return baseIndent + 2;
+					if (!parsed.title) return baseIndent;
+					if (lineNumber <= parsed.title.loc.start.line) return baseIndent + 2;
+					if (lineNumber < parsed.title.loc.end.line) return baseIndent + 4;
+					if (lineNumber === parsed.title.loc.end.line) {
+						const line = getParsedLines(sourceCode).get(lineNumber);
+						if (!line) return baseIndent;
+						const between = line.text.slice(column - 1, parsed.title.loc.end.column - 2);
+						return !between || isWhitespace(between) ? baseIndent + 2 : baseIndent + 4;
+					}
+					return baseIndent;
+				});
+			}
+		}
+		/**
+		* Verify a link reference node.
+		*/
+		function verifyLinkReference(node) {
+			const loc = sourceCode.getLoc(node);
+			const parsed = parseLinkReference(sourceCode, node);
+			if (!parsed) return;
+			let lines = lineNumbersFromRange(loc.start.line, loc.end.line);
+			if (!inlineToBeChecked(loc.start)) lines = lines.slice(1);
+			const lastChild = node.children.at(-1);
+			if (lastChild && parsed.text.loc.start.line < parsed.text.loc.end.line) {
+				const lastChildLoc = sourceCode.getLoc(lastChild);
+				const lastChildEndLine = lastChild.type === "text" && lastChild.value.endsWith("\n") ? lastChildLoc.end.line - 1 : lastChildLoc.end.line;
+				lines = lines.filter((lineNumber) => lineNumber <= parsed.text.loc.start.line || lastChildEndLine < lineNumber);
+			}
+			verifyLinesIndent(lines, (lineNumber, column) => {
+				const baseIndent = blockStack.getExpectedIndent({
+					lineNumber,
+					block: false
+				});
+				if (baseIndent === "ignore") return "ignore";
+				if (lineNumber <= loc.start.line) return baseIndent;
+				if (lineNumber < parsed.text.loc.end.line) return baseIndent + 2;
+				if (!parsed.label) return baseIndent;
+				if (lineNumber <= parsed.label.loc.start.line) return baseIndent;
+				if (lineNumber < parsed.label.loc.end.line) return baseIndent + 2;
+				if (lineNumber === parsed.label.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.label.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent : baseIndent + 2;
+				}
+				return baseIndent;
+			});
+		}
+		/**
+		* Verify an image node.
+		*/
+		function verifyImage(node) {
+			const loc = sourceCode.getLoc(node);
+			let lines = lineNumbersFromRange(loc.start.line, loc.end.line);
+			if (!inlineToBeChecked(loc.start)) lines = lines.slice(1);
+			const parsed = parseImage(sourceCode, node);
+			if (!parsed) return;
+			verifyLinesIndent(lines, (lineNumber, column) => {
+				const baseIndent = blockStack.getExpectedIndent({
+					lineNumber,
+					block: false
+				});
+				if (baseIndent === "ignore") return "ignore";
+				if (lineNumber <= loc.start.line) return baseIndent;
+				if (lineNumber < parsed.text.loc.end.line) return baseIndent + 2;
+				if (lineNumber === parsed.text.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.text.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent : baseIndent + 2;
+				}
+				if (lineNumber <= parsed.openingParen.loc.end.line) return baseIndent;
+				if (lineNumber <= parsed.destination.loc.end.line) return baseIndent + 2;
+				if (!parsed.title) return baseIndent;
+				if (lineNumber <= parsed.title.loc.start.line) return baseIndent + 2;
+				if (lineNumber < parsed.title.loc.end.line) return baseIndent + 4;
+				if (lineNumber === parsed.title.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.title.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent + 2 : baseIndent + 4;
+				}
+				return baseIndent;
+			});
+		}
+		/**
+		* Verify an image reference node.
+		*/
+		function verifyImageReference(node) {
+			const loc = sourceCode.getLoc(node);
+			const parsed = parseImageReference(sourceCode, node);
+			if (!parsed) return;
+			let lines = lineNumbersFromRange(loc.start.line, loc.end.line);
+			if (!inlineToBeChecked(loc.start)) lines = lines.slice(1);
+			verifyLinesIndent(lines, (lineNumber, column) => {
+				const baseIndent = blockStack.getExpectedIndent({
+					lineNumber,
+					block: false
+				});
+				if (baseIndent === "ignore") return "ignore";
+				if (lineNumber <= loc.start.line) return baseIndent;
+				if (lineNumber < parsed.text.loc.end.line) return baseIndent + 2;
+				if (lineNumber === parsed.text.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.text.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent : baseIndent + 2;
+				}
+				if (!parsed.label) return baseIndent;
+				if (lineNumber <= parsed.label.loc.start.line) return baseIndent;
+				if (lineNumber < parsed.label.loc.end.line) return baseIndent + 2;
+				if (lineNumber === parsed.label.loc.end.line) {
+					const line = getParsedLines(sourceCode).get(lineNumber);
+					if (!line) return baseIndent;
+					const between = line.text.slice(column - 1, parsed.label.loc.end.column - 2);
+					return !between || isWhitespace(between) ? baseIndent : baseIndent + 2;
+				}
+				return baseIndent;
+			});
+		}
+		/**
+		* Verify a text node.
+		*/
+		function verifyText(node) {
+			const loc = sourceCode.getLoc(node);
+			let lines = lineNumbersFromRange(loc.start.line, loc.end.line);
+			if (!inlineToBeChecked(loc.start)) lines = lines.slice(1);
+			if (node.value.endsWith("\n")) lines = lines.slice(0, -1);
+			verifyLinesIndent(lines, (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: false
+			}));
+		}
+		/**
+		* Verify an inline node.
+		*/
+		function verifyInline(node) {
+			const loc = sourceCode.getLoc(node);
+			let lines = lineNumbersFromRange(loc.start.line, loc.end.line);
+			if (!inlineToBeChecked(loc.start)) lines = lines.slice(1);
+			verifyLinesIndent(lines, (lineNumber) => blockStack.getExpectedIndent({
+				lineNumber,
+				block: false
+			}));
+		}
+		/**
+		* Check whether the inline node should be checked.
+		*/
+		function inlineToBeChecked(position) {
+			const blockquote = blockStack.getCurrentBlockquote();
+			const listItem = blockStack.getCurrentListItemAtLine(position.line);
+			const lineText = sourceCode.lines[position.line - 1];
+			if (listItem) {
+				const parsed = listItem.getParsedListItem();
+				const indentText = lineText.slice((parsed.taskListItemMarker?.loc ?? parsed.marker.loc).end.column - 1, position.column - 1);
+				if (indentText && !isSpaceOrTab(indentText)) return false;
+			} else if (blockquote) {
+				if (atWidth(lineText, blockquote.getMarkerIndent()) !== ">") return false;
+				const indentText = sliceWidth(lineText.slice(0, position.column - 1), blockquote.getMarkerIndent() + 1);
+				if (indentText && !isSpaceOrTab(indentText)) return false;
+			} else {
+				const indentText = lineText.slice(0, position.column - 1);
+				if (indentText && !isSpaceOrTab(indentText)) return false;
+			}
+			return true;
+		}
+		/**
+		* Get line numbers from the range.
+		*/
+		function lineNumbersFromRange(lineNumberFrom, lineNumberTo) {
+			const lines = [];
+			for (let lineNumber = lineNumberFrom; lineNumber <= lineNumberTo; lineNumber++) lines.push(lineNumber);
+			return lines;
+		}
+		/**
+		* Verify the indentation of the lines.
+		*/
+		function verifyLinesIndent(lineNumbers, expectedIndentWidthProvider, additionalFixes) {
+			const blockquote = blockStack.getCurrentBlockquote();
+			if (!blockquote) {
+				verifyLinesIndentFromRoot(lineNumbers, expectedIndentWidthProvider, additionalFixes);
+				return;
+			}
+			verifyLinesIndentFromBlockquoteMarker(lineNumbers, blockquote, expectedIndentWidthProvider, additionalFixes);
+		}
+		/**
+		* Verify the indentation of the lines from the root.
+		*/
+		function verifyLinesIndentFromRoot(lineNumbers, expectedIndentWidthProvider, additionalFixes) {
+			const reports = [];
+			for (const lineNumber of lineNumbers) {
+				const line = getParsedLines(sourceCode).get(lineNumber);
+				if (!line) return;
+				const listItem = blockStack.getCurrentListItemAtLine(lineNumber);
+				if (!listItem) {
+					const indentText = /^\s*/u.exec(line.text)[0];
+					const actualIndentWidth = getWidth(indentText);
+					const expectedIndentWidth = expectedIndentWidthProvider(lineNumber, 1);
+					if (expectedIndentWidth === "ignore") continue;
+					if (actualIndentWidth === expectedIndentWidth) continue;
+					reports.push({
+						loc: {
+							start: {
+								line: line.line,
+								column: 1
+							},
+							end: {
+								line: line.line,
+								column: indentText.length + 1
+							}
+						},
+						messageId: indentText.includes("	") ? "wrongIndentationWithTab" : "wrongIndentation",
+						data: {
+							expected: expectedIndentWidth,
+							actual: actualIndentWidth
+						},
+						fix(fixer) {
+							return fixer.replaceTextRange([line.range[0], line.range[0] + indentText.length], " ".repeat(expectedIndentWidth));
+						},
+						expectedIndentWidth,
+						actualIndentWidth
+					});
+					continue;
+				}
+				const report = verifyLineIndentFromListItemMarker(line, listItem, expectedIndentWidthProvider);
+				if (!report) continue;
+				reports.push(report);
+			}
+			if (!reports.length) return;
+			for (const report of reports) reportIncorrectIndent({
+				loc: report.loc,
+				messageId: report.messageId,
+				data: report.data,
+				*fix(fixer) {
+					yield report.fix(fixer);
+					if (additionalFixes) yield* additionalFixes(fixer, report) ?? [];
+				}
+			});
+		}
+		/**
+		* Verify the indentation of the lines from the blockquote marker.
+		*/
+		function verifyLinesIndentFromBlockquoteMarker(lineNumbers, blockquote, expectedIndentWidthProvider, additionalFixes) {
+			const blockquoteLoc = sourceCode.getLoc(blockquote.node);
+			const reports = [];
+			let cannotFix = false;
+			for (const lineNumber of lineNumbers) {
+				const line = getParsedLines(sourceCode).get(lineNumber);
+				if (!line) return;
+				if (atWidth(line.text, blockquote.getMarkerIndent()) !== ">") {
+					cannotFix = true;
+					continue;
+				}
+				const listItem = blockStack.getCurrentListItemAtLine(lineNumber);
+				if (!listItem) {
+					const before = line.text.slice(0, blockquoteLoc.start.column);
+					const after = line.text.slice(blockquoteLoc.start.column);
+					const indentText = /^\s*/u.exec(after)[0];
+					const actualIndentWidth = getWidth(before + indentText);
+					const expectedIndentWidth = expectedIndentWidthProvider(lineNumber, blockquoteLoc.start.column + 1);
+					if (expectedIndentWidth === "ignore") continue;
+					if (actualIndentWidth === expectedIndentWidth) continue;
+					const linePrefixWidth = getWidth(before);
+					reports.push({
+						loc: {
+							start: {
+								line: line.line,
+								column: blockquoteLoc.start.column + 1
+							},
+							end: {
+								line: line.line,
+								column: blockquoteLoc.start.column + 1 + indentText.length
+							}
+						},
+						messageId: indentText.includes("	") ? "wrongIndentationFromBlockquoteMarkerWithTab" : "wrongIndentationFromBlockquoteMarker",
+						data: {
+							expected: expectedIndentWidth - linePrefixWidth,
+							actual: actualIndentWidth - linePrefixWidth
+						},
+						fix(fixer) {
+							return fixer.replaceTextRange([line.range[0] + blockquoteLoc.start.column, line.range[0] + blockquoteLoc.start.column + indentText.length], " ".repeat(expectedIndentWidth - linePrefixWidth));
+						},
+						expectedIndentWidth,
+						actualIndentWidth
+					});
+					continue;
+				}
+				const report = verifyLineIndentFromListItemMarker(line, listItem, expectedIndentWidthProvider);
+				if (!report) continue;
+				reports.push(report);
+			}
+			if (!reports.length) return;
+			for (const report of reports) reportIncorrectIndent({
+				loc: report.loc,
+				messageId: report.messageId,
+				data: report.data,
+				*fix(fixer) {
+					if (cannotFix) return;
+					yield report.fix(fixer);
+					if (additionalFixes) yield* additionalFixes(fixer, report) ?? [];
+				}
+			});
+		}
+		/**
+		* Verify the indentation of the line from the list item marker.
+		*/
+		function verifyLineIndentFromListItemMarker(line, listItem, expectedIndentWidthProvider) {
+			const parsed = listItem.getParsedListItem();
+			const markerAfterColumn = (parsed.taskListItemMarker?.loc ?? parsed.marker.loc).end.column;
+			const before = line.text.slice(0, markerAfterColumn - 1);
+			const after = line.text.slice(markerAfterColumn - 1);
+			const indentText = /^\s*/u.exec(after)[0];
+			const actualIndentWidth = getWidth(before + indentText);
+			const expectedIndentWidth = expectedIndentWidthProvider(line.line, markerAfterColumn);
+			if (expectedIndentWidth === "ignore") return null;
+			if (actualIndentWidth === expectedIndentWidth) return null;
+			const linePrefixWidth = getWidth(before);
+			const range = [line.range[0] + before.length, line.range[0] + before.length + indentText.length];
+			return {
+				loc: getSourceLocationFromRange(sourceCode, listItem.node, range),
+				messageId: indentText.includes("	") ? "wrongIndentationFromListMarkerWithTab" : "wrongIndentationFromListMarker",
+				data: {
+					expected: expectedIndentWidth - linePrefixWidth,
+					actual: actualIndentWidth - linePrefixWidth
+				},
+				fix(fixer) {
+					return fixer.replaceTextRange(range, " ".repeat(expectedIndentWidth - linePrefixWidth));
+				},
+				expectedIndentWidth,
+				actualIndentWidth
+			};
+		}
+	}
+});
+
+//#endregion
+//#region src/utils/setext-heading.ts
+/**
+* Parse the setext heading.
+*/
+function parseSetextHeading(sourceCode, node) {
+	if (getHeadingKind(sourceCode, node) !== "setext") return null;
+	const lines = getParsedLines(sourceCode);
+	const contentLines = [];
+	const nodeLoc = sourceCode.getLoc(node);
+	for (let lineNumber = nodeLoc.start.line; lineNumber < nodeLoc.end.line; lineNumber++) {
+		const content = parseContent(lines.get(lineNumber));
+		contentLines.push(content);
+	}
+	const underline = parseUnderline(lines.get(nodeLoc.end.line));
+	if (!underline) return null;
+	return {
+		contentLines,
+		underline
+	};
+}
+/**
+* Parse the content line of a setext heading.
+*/
+function parseContent(line) {
+	let prefix = "";
+	let spaceBefore = "";
+	let suffix = "";
+	for (let index = 0; index < line.text.length; index++) {
+		const c = line.text[index];
+		if (!c.trim()) {
+			spaceBefore += c;
+			continue;
+		}
+		if (c === ">" && spaceBefore.length < 4) {
+			prefix += spaceBefore + c;
+			spaceBefore = "";
+			continue;
+		}
+		suffix = line.text.slice(index);
+		break;
+	}
+	const content = suffix.trimEnd();
+	const spaceAfter = suffix.slice(content.length);
+	return {
+		text: content,
+		range: [line.range[0] + prefix.length + spaceBefore.length, line.range[1] - line.linebreak.length - spaceAfter.length],
+		loc: {
+			start: {
+				line: line.line,
+				column: prefix.length + spaceBefore.length + 1
+			},
+			end: {
+				line: line.line,
+				column: prefix.length + spaceBefore.length + content.length + 1
+			}
+		},
+		raws: {
+			prefix,
+			spaceBefore,
+			spaceAfter
+		}
 	};
 }
 /**
-* Parse the link definition from the given text.
+* Parse the underline of a setext heading.
 */
-function parseLinkDefinitionFromText(text) {
-	let index = 0;
-	if (text[index] !== "[") return null;
-	const labelStartIndex = index;
-	index++;
-	if (!skipUntilEnd((c) => c === "]")) return null;
-	index++;
-	const labelRange = [labelStartIndex, index];
-	if (!text.slice(labelRange[0] + 1, labelRange[1] - 1).trim()) return null;
-	if (text[index] !== ":") return null;
-	const label = {
-		text: text.slice(...labelRange),
-		range: labelRange
-	};
-	index++;
-	skipSpaces();
-	let destination;
-	const destinationStartIndex = index;
-	if (text[index] === "<") {
-		index++;
-		if (!skipUntilEnd((c) => c === ">")) return null;
-		index++;
-		const destinationRange = [destinationStartIndex, index];
-		destination = {
-			type: "pointy-bracketed",
-			text: text.slice(...destinationRange),
-			range: destinationRange
-		};
-	} else {
-		if (text.length <= index) return null;
-		skipUntilEnd((c) => isWhitespace(c) || isAsciiControlCharacter(c));
-		const destinationRange = [destinationStartIndex, index];
-		destination = {
-			type: "bare",
-			text: text.slice(...destinationRange),
-			range: destinationRange
-		};
+function parseUnderline(line) {
+	let marker = null;
+	let underlineText = "";
+	let prefix = "";
+	let spaceBefore = "";
+	let spaceAfter = "";
+	for (let index = line.text.length - 1; index >= 0; index--) {
+		const c = line.text[index];
+		if (!marker) {
+			if (c === "=" || c === "-") {
+				underlineText = c + underlineText;
+				marker = c;
+			} else if (!c.trim()) spaceAfter = c + spaceAfter;
+			else return null;
+			continue;
+		}
+		if (c === marker) {
+			underlineText = c + spaceBefore + underlineText;
+			spaceBefore = "";
+		} else if (!c.trim()) spaceBefore = c + spaceBefore;
+		else {
+			prefix = line.text.slice(0, index + 1);
+			break;
+		}
 	}
-	skipSpaces();
-	if (text.length <= index) return {
-		label,
-		destination,
-		title: null
+	if (!marker) return null;
+	const underlineLoc = {
+		start: {
+			line: line.line,
+			column: prefix.length + spaceBefore.length + 1
+		},
+		end: {
+			line: line.line,
+			column: prefix.length + spaceBefore.length + underlineText.length + 1
+		}
 	};
-	let title;
-	const titleStartIndex = index;
-	const startChar = text[index];
-	if (startChar === "'" || startChar === "\"" || startChar === "(") {
-		index++;
-		const endChar = startChar === "(" ? ")" : startChar;
-		if (!skipUntilEnd((c) => c === endChar)) return null;
-		index++;
-		const titleRange = [titleStartIndex, index];
-		title = {
-			type: startChar === "'" ? "single-quoted" : startChar === "\"" ? "double-quoted" : "parenthesized",
-			text: text.slice(...titleRange),
-			range: titleRange
-		};
-	} else return null;
-	skipSpaces();
-	if (index < text.length) return null;
 	return {
-		label,
-		destination,
-		title
+		text: underlineText,
+		range: [line.range[0] + prefix.length + spaceBefore.length, line.range[1] - line.linebreak.length - spaceAfter.length],
+		loc: underlineLoc,
+		marker,
+		raws: {
+			prefix,
+			spaceBefore,
+			spaceAfter
+		}
 	};
-	/**
-	* Skip spaces
-	*/
-	function skipSpaces() {
-		while (index < text.length && isWhitespace(text[index])) index++;
+}
+
+//#endregion
+//#region src/rules/level1-heading-style.ts
+var level1_heading_style_default = createRule("level1-heading-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent style for level 1 headings",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["atx", "setext"] },
+				allowMultilineSetext: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedAtx: "Expected ATX style heading (# Heading).",
+			expectedSetext: "Expected Setext style heading (Heading\\n======).",
+			multilineSetextNotAllowed: "Multiline Setext headings are not allowed."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const opt = context.options[0] || {};
+		const style = opt.style ?? "atx";
+		const allowMultilineSetext = opt.allowMultilineSetext;
+		return { heading(node) {
+			if (node.depth !== 1) return;
+			const headingKind = getHeadingKind(sourceCode, node);
+			if (style === "atx") {
+				if (headingKind !== "setext") return;
+				const parsed = parseSetextHeading(sourceCode, node);
+				if (!parsed) return;
+				if (parsed.contentLines.length > 1) {
+					if (allowMultilineSetext) return;
+					context.report({
+						node,
+						messageId: "multilineSetextNotAllowed"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "expectedAtx",
+					*fix(fixer) {
+						const heading = parsed.contentLines[0];
+						yield fixer.insertTextBeforeRange(heading.range, "# ");
+						const lines = getParsedLines(sourceCode);
+						yield fixer.removeRange(lines.get(parsed.underline.loc.start.line).range);
+					}
+				});
+			} else if (style === "setext") {
+				if (headingKind !== "atx" || node.children.length === 0) return;
+				context.report({
+					node,
+					messageId: "expectedSetext",
+					*fix(fixer) {
+						const parsed = parseATXHeading(sourceCode, node);
+						if (!parsed) return;
+						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.content.range[0]]);
+						if (parsed.closingSequence) yield fixer.removeRange([parsed.content.range[1], parsed.after?.range[1] ?? parsed.closingSequence.range[1]]);
+						const lines = getParsedLines(sourceCode);
+						const underline = "=".repeat(Math.max(getTextWidth(parsed.content.text), 3));
+						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
+						yield fixer.insertTextAfter(node, appendingText);
+					}
+				});
+			}
+		} };
 	}
-	/**
-	* Skip until the end by the given condition
-	*/
-	function skipUntilEnd(checkEnd) {
-		while (index < text.length) {
-			const c = text[index];
-			if (checkEnd(c)) return true;
-			index++;
-			if (c !== "\\") continue;
-			if (index < text.length && (text[index] === "\\" || checkEnd(text[index])) && !isWhitespace(text[index])) index++;
+});
+
+//#endregion
+//#region src/rules/level2-heading-style.ts
+var level2_heading_style_default = createRule("level2-heading-style", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce consistent style for level 2 headings",
+			categories: ["standard"],
+			listCategory: "Stylistic"
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				style: { enum: ["atx", "setext"] },
+				allowMultilineSetext: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			expectedAtx: "Expected ATX style heading (## Heading).",
+			expectedSetext: "Expected Setext style heading (Heading\\n------).",
+			multilineSetextNotAllowed: "Multiline Setext headings are not allowed."
 		}
-		return false;
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const opt = context.options[0] || {};
+		const style = opt.style ?? "atx";
+		const allowMultilineSetext = opt.allowMultilineSetext;
+		return { heading(node) {
+			if (node.depth !== 2) return;
+			const headingKind = getHeadingKind(sourceCode, node);
+			if (style === "atx") {
+				if (headingKind !== "setext") return;
+				const parsed = parseSetextHeading(sourceCode, node);
+				if (!parsed) return;
+				if (parsed.contentLines.length > 1) {
+					if (allowMultilineSetext) return;
+					context.report({
+						node,
+						messageId: "multilineSetextNotAllowed"
+					});
+					return;
+				}
+				context.report({
+					node,
+					messageId: "expectedAtx",
+					*fix(fixer) {
+						const heading = parsed.contentLines[0];
+						yield fixer.insertTextBeforeRange(heading.range, "## ");
+						const lines = getParsedLines(sourceCode);
+						yield fixer.removeRange(lines.get(parsed.underline.loc.start.line).range);
+					}
+				});
+			} else if (style === "setext") {
+				if (headingKind !== "atx" || node.children.length === 0) return;
+				context.report({
+					node,
+					messageId: "expectedSetext",
+					*fix(fixer) {
+						const parsed = parseATXHeading(sourceCode, node);
+						if (!parsed) return;
+						yield fixer.removeRange([parsed.openingSequence.range[0], parsed.content.range[0]]);
+						if (parsed.closingSequence) yield fixer.removeRange([parsed.content.range[1], parsed.after?.range[1] ?? parsed.closingSequence.range[1]]);
+						const lines = getParsedLines(sourceCode);
+						const underline = "-".repeat(Math.max(getTextWidth(parsed.content.text), 3));
+						const appendingText = `\n${lines.get(parsed.openingSequence.loc.start.line).text.slice(0, parsed.openingSequence.loc.start.column - 1)}${underline}`;
+						yield fixer.insertTextAfter(node, appendingText);
+					}
+				});
+			}
+		} };
 	}
-}
+});
 
 //#endregion
 //#region src/rules/link-bracket-newline.ts
@@ -5196,11 +6218,11 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$3(context.options[0]);
+		const optionProvider = parseOptions$4(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$3(option) {
+		function parseOptions$4(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (bracketsRange) => {
@@ -5674,11 +6696,11 @@ var link_paren_newline_default = createRule("link-paren-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$3(context.options[0]);
+		const optionProvider = parseOptions$4(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$3(option) {
+		function parseOptions$4(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (openingParenIndex, closingParenIndex) => {
@@ -6044,10 +7066,22 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 			const items = listNode.children;
 			if (items.length <= 1) return;
 			const referenceMarkerLocation = getMarkerLocation(items[0]);
+			const expectedWidth = getWidth(sourceCode.lines[referenceMarkerLocation.line - 1].slice(0, referenceMarkerLocation[alignPositionName]));
 			for (const item of items.slice(1)) {
 				const markerLocation = getMarkerLocation(item);
-				const diff = markerLocation[alignPositionName] - referenceMarkerLocation[alignPositionName];
+				const actualWidth = getWidth(sourceCode.lines[markerLocation.line - 1].slice(0, markerLocation[alignPositionName]));
+				const diff = actualWidth - expectedWidth;
 				if (diff === 0) continue;
+				const messageData = alignPositionName === "start" ? {
+					expected: String(expectedWidth),
+					actual: String(actualWidth)
+				} : (() => {
+					const start = getWidth(sourceCode.lines[markerLocation.line - 1].slice(0, markerLocation.start));
+					return {
+						expected: String(start - diff),
+						actual: String(start)
+					};
+				})();
 				context.report({
 					node: item,
 					loc: {
@@ -6061,10 +7095,7 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 						}
 					},
 					messageId: "incorrectAlignment",
-					data: {
-						expected: String(markerLocation.start - diff),
-						actual: String(markerLocation.start)
-					},
+					data: messageData,
 					fix(fixer) {
 						const lines = getParsedLines(sourceCode);
 						const line = lines.get(markerLocation.line);
@@ -6072,13 +7103,17 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 							const addSpaces = " ".repeat(-diff);
 							return fixer.insertTextBeforeRange([line.range[0] + markerLocation.start, line.range[0] + markerLocation.start], addSpaces);
 						}
-						const itemBefore = line.text.slice(0, markerLocation.start - diff);
-						if (itemBefore.includes("	")) return null;
-						if (lines.get(referenceMarkerLocation.line).text.slice(0, referenceMarkerLocation.start) === itemBefore) {
-							const removeEndIndex = line.range[0] + markerLocation.start;
-							const removeStartIndex = removeEndIndex - diff;
-							return fixer.removeRange([removeStartIndex, removeEndIndex]);
+						const beforeItemMarker = line.text.slice(0, markerLocation.start);
+						const newWidth = getWidth(beforeItemMarker) - diff;
+						let newBeforeItemMarker = beforeItemMarker;
+						while (getWidth(newBeforeItemMarker) > newWidth) {
+							const last = newBeforeItemMarker.at(-1);
+							if (last && isWhitespace(last)) newBeforeItemMarker = newBeforeItemMarker.slice(0, -1);
+							else return null;
 						}
+						if (getWidth(newBeforeItemMarker) < newWidth) newBeforeItemMarker += " ".repeat(newWidth - getWidth(newBeforeItemMarker));
+						const referenceBeforeItemMarker = lines.get(referenceMarkerLocation.line).text.slice(0, referenceMarkerLocation.start);
+						if (!referenceBeforeItemMarker.includes(">") || referenceBeforeItemMarker === newBeforeItemMarker) return fixer.replaceTextRange([line.range[0], line.range[0] + markerLocation.start], newBeforeItemMarker);
 						return null;
 					}
 				});
@@ -6212,6 +7247,7 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
+		let codeText = sourceCode.text;
 		return {
 			definition: verifyLinkDefinition,
 			footnoteDefinition: verifyFootnoteDefinition,
@@ -6221,6 +7257,7 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			link: verifyLink,
 			linkReference: verifyLinkReference,
 			listItem: verifyListItem,
+			blockquote: processBlockquote,
 			text: verifyText
 		};
 		/**
@@ -6294,7 +7331,13 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 		* Verify a list item node
 		*/
 		function verifyListItem(node) {
-			verifyTextOutsideChildren(node);
+			const nodeRange = sourceCode.getRange(node);
+			const parsed = parseListItem(sourceCode, node);
+			if (parsed.taskListItemMarker) verifyTextInRange(node, [nodeRange[0], parsed.taskListItemMarker.range[0]]);
+			let newCodeText = codeText.slice(0, parsed.marker.range[0]) + " ".repeat(parsed.marker.range[1] - parsed.marker.range[0]);
+			if (parsed.taskListItemMarker) newCodeText += codeText.slice(parsed.marker.range[1], parsed.taskListItemMarker.range[0]) + " ".repeat(parsed.taskListItemMarker.range[1] - parsed.taskListItemMarker.range[0]) + codeText.slice(parsed.taskListItemMarker.range[1]);
+			else newCodeText += codeText.slice(parsed.marker.range[1]);
+			codeText = newCodeText;
 		}
 		/**
 		* Verify spaces in a node
@@ -6304,6 +7347,26 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 			verifyTextInRange(node, nodeRange);
 		}
 		/**
+		* Process a blockquote node
+		*/
+		function processBlockquote(node) {
+			const nodeRange = sourceCode.getRange(node);
+			let newCodeText = "";
+			let inIndent = true;
+			for (let index = nodeRange[0]; index < nodeRange[1]; index++) {
+				const c = codeText[index];
+				if (c === "\n") {
+					inIndent = true;
+					continue;
+				}
+				if (isWhitespace(c)) continue;
+				if (c === ">" && inIndent) newCodeText += `${codeText.slice(newCodeText.length, index)} `;
+				inIndent = false;
+			}
+			newCodeText += codeText.slice(newCodeText.length);
+			codeText = newCodeText;
+		}
+		/**
 		* Verify spaces in a node excluding children
 		*/
 		function verifyTextOutsideChildren(node) {
@@ -6322,14 +7385,14 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 		*/
 		function verifyTextInRange(node, textRange) {
 			const nodeRange = sourceCode.getRange(node);
-			const text = sourceCode.text.slice(...textRange);
+			const text = codeText.slice(...textRange);
 			const reSpaces = /\s{2,}|\n/gu;
 			let match;
 			while ((match = reSpaces.exec(text)) !== null) {
 				const spaces = match[0];
 				if (spaces.includes("\n")) {
 					let c = "";
-					while ((c = text[reSpaces.lastIndex]) && (c === ">" || !c.trim())) reSpaces.lastIndex++;
+					while ((c = text[reSpaces.lastIndex]) && isWhitespace(c)) reSpaces.lastIndex++;
 					continue;
 				}
 				if (spaces.length < 2) continue;
@@ -6339,7 +7402,7 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 				if (nodeRange[0] === range[0]) {
 					let isIndentation = true;
 					for (let index = nodeRange[0] - 1; index >= 0; index--) {
-						const c = sourceCode.text[index];
+						const c = codeText[index];
 						if (c === "\n") break;
 						if (isWhitespace(c)) continue;
 						isIndentation = false;
@@ -6349,8 +7412,8 @@ var no_multi_spaces_default = createRule("no-multi-spaces", {
 				}
 				if (nodeRange[1] === range[1]) {
 					let isTrailingSpaces = true;
-					for (let index = nodeRange[1]; index < sourceCode.text.length; index++) {
-						const c = sourceCode.text[index];
+					for (let index = nodeRange[1]; index < codeText.length; index++) {
+						const c = codeText[index];
 						if (c === "\n") break;
 						if (isWhitespace(c)) continue;
 						isTrailingSpaces = false;
@@ -8814,6 +9877,7 @@ const rules$1 = [
 	emphasis_delimiters_style_default,
 	hard_linebreak_style_default,
 	heading_casing_default,
+	indent_default,
 	level1_heading_style_default,
 	level2_heading_style_default,
 	link_bracket_newline_default,
@@ -8848,8 +9912,7 @@ const rules$1 = [
 
 //#endregion
 //#region src/configs/recommended.ts
-var recommended_exports = {};
-__export(recommended_exports, {
+var recommended_exports = __export({
 	files: () => files$1,
 	language: () => language$1,
 	languageOptions: () => languageOptions$1,
@@ -8879,8 +9942,7 @@ const rules$3 = {
 
 //#endregion
 //#region src/configs/standard.ts
-var standard_exports = {};
-__export(standard_exports, {
+var standard_exports = __export({
 	files: () => files,
 	language: () => language,
 	languageOptions: () => languageOptions,
@@ -8907,6 +9969,7 @@ const rules$2 = {
 	"markdown-preferences/code-fence-style": "error",
 	"markdown-preferences/emphasis-delimiters-style": "error",
 	"markdown-preferences/hard-linebreak-style": "error",
+	"markdown-preferences/indent": "error",
 	"markdown-preferences/level1-heading-style": "error",
 	"markdown-preferences/level2-heading-style": "error",
 	"markdown-preferences/link-bracket-newline": "error",
@@ -8937,13 +10000,12 @@ const rules$2 = {
 
 //#endregion
 //#region src/meta.ts
-var meta_exports = {};
-__export(meta_exports, {
+var meta_exports = __export({
 	name: () => name,
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.23.0";
+const version = "0.24.0";
 
 //#endregion
 //#region src/index.ts